4 # Copyright (c) 2007 - 2018, Intel Corporation. All rights reserved.<BR>
5 # Copyright (c) 2015, Hewlett Packard Enterprise Development, L.P.<BR>
7 # This program and the accompanying materials
8 # are licensed and made available under the terms and conditions of the BSD License
9 # which accompanies this distribution. The full text of the license may be found at
10 # http://opensource.org/licenses/bsd-license.php
12 # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
13 # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
25 import FfsInfStatement
26 import FfsFileStatement
32 import CompressSection
37 import RuleComplexFile
41 import ComponentStatement
43 import OptRomInfStatement
44 import OptRomFileStatement
46 from GenFdsGlobalVariable
import GenFdsGlobalVariable
47 from Common
.BuildToolError
import *
48 from Common
import EdkLogger
49 from Common
.Misc
import PathClass
50 from Common
.String
import NormPath
51 import Common
.GlobalData
as GlobalData
52 from Common
.Expression
import *
53 from Common
import GlobalData
54 from Common
.String
import ReplaceMacro
56 from Common
.Misc
import tdict
57 from Common
.MultipleWorkspace
import MultipleWorkspace
as mws
58 import Common
.LongFilePathOs
as os
59 from Common
.LongFilePathSupport
import OpenLongFilePath
as open
60 from Capsule
import EFI_CERT_TYPE_PKCS7_GUID
61 from Capsule
import EFI_CERT_TYPE_RSA2048_SHA256_GUID
63 ##define T_CHAR_SPACE ' '
64 ##define T_CHAR_NULL '\0'
65 ##define T_CHAR_CR '\r'
66 ##define T_CHAR_TAB '\t'
67 ##define T_CHAR_LF '\n'
68 ##define T_CHAR_SLASH '/'
69 ##define T_CHAR_BACKSLASH '\\'
70 ##define T_CHAR_DOUBLE_QUOTE '\"'
71 ##define T_CHAR_SINGLE_QUOTE '\''
72 ##define T_CHAR_STAR '*'
73 ##define T_CHAR_HASH '#'
75 (T_CHAR_SPACE
, T_CHAR_NULL
, T_CHAR_CR
, T_CHAR_TAB
, T_CHAR_LF
, T_CHAR_SLASH
, \
76 T_CHAR_BACKSLASH
, T_CHAR_DOUBLE_QUOTE
, T_CHAR_SINGLE_QUOTE
, T_CHAR_STAR
, T_CHAR_HASH
) = \
77 (' ', '\0', '\r', '\t', '\n', '/', '\\', '\"', '\'', '*', '#')
79 SEPERATOR_TUPLE
= ('=', '|', ',', '{', '}')
81 RegionSizePattern
= re
.compile("\s*(?P<base>(?:0x|0X)?[a-fA-F0-9]+)\s*\|\s*(?P<size>(?:0x|0X)?[a-fA-F0-9]+)\s*")
82 RegionSizeGuidPattern
= re
.compile("\s*(?P<base>\w+\.\w+)\s*\|\s*(?P<size>\w+\.\w+)\s*")
83 RegionOffsetPcdPattern
= re
.compile("\s*(?P<base>\w+\.\w+)\s*$")
84 ShortcutPcdPattern
= re
.compile("\s*\w+\s*=\s*(?P<value>(?:0x|0X)?[a-fA-F0-9]+)\s*\|\s*(?P<name>\w+\.\w+)\s*")
86 AllIncludeFileList
= []
88 # Get the closest parent
89 def GetParentAtLine (Line
):
90 for Profile
in AllIncludeFileList
:
91 if Profile
.IsLineInFile(Line
):
96 def IsValidInclude (File
, Line
):
97 for Profile
in AllIncludeFileList
:
98 if Profile
.IsLineInFile(Line
) and Profile
.FileName
== File
:
103 def GetRealFileLine (File
, Line
):
106 for Profile
in AllIncludeFileList
:
107 if Profile
.IsLineInFile(Line
):
108 return Profile
.GetLineInFile(Line
)
109 elif Line
>= Profile
.InsertStartLineNumber
and Profile
.Level
== 1:
110 InsertedLines
+= Profile
.GetTotalLines()
112 return (File
, Line
- InsertedLines
)
114 ## The exception class that used to report error messages when parsing FDF
116 # Currently the "ToolName" is set to be "FDF Parser".
118 class Warning (Exception):
121 # @param self The object pointer
122 # @param Str The message to record
123 # @param File The FDF name
124 # @param Line The Line number that error occurs
126 def __init__(self
, Str
, File
= None, Line
= None):
128 FileLineTuple
= GetRealFileLine(File
, Line
)
129 self
.FileName
= FileLineTuple
[0]
130 self
.LineNumber
= FileLineTuple
[1]
131 self
.OriginalLineNumber
= Line
133 self
.ToolName
= 'FdfParser'
138 ## The MACRO class that used to record macro value data when parsing include file
144 # @param self The object pointer
145 # @param FileName The file that to be parsed
147 def __init__(self
, FileName
, Line
):
148 self
.FileName
= FileName
149 self
.DefinedAtLine
= Line
150 self
.MacroName
= None
151 self
.MacroValue
= None
153 ## The Include file content class that used to record file data when parsing include file
155 # May raise Exception when opening file.
157 class IncludeFileProfile
:
160 # @param self The object pointer
161 # @param FileName The file that to be parsed
163 def __init__(self
, FileName
):
164 self
.FileName
= FileName
165 self
.FileLinesList
= []
167 fsock
= open(FileName
, "rb", 0)
169 self
.FileLinesList
= fsock
.readlines()
170 for index
, line
in enumerate(self
.FileLinesList
):
171 if not line
.endswith('\n'):
172 self
.FileLinesList
[index
] += '\n'
178 EdkLogger
.error("FdfParser", FILE_OPEN_FAILURE
, ExtraData
=FileName
)
180 self
.InsertStartLineNumber
= None
181 self
.InsertAdjust
= 0
182 self
.IncludeFileList
= []
183 self
.Level
= 1 # first level include file
185 def GetTotalLines(self
):
186 TotalLines
= self
.InsertAdjust
+ len(self
.FileLinesList
)
188 for Profile
in self
.IncludeFileList
:
189 TotalLines
+= Profile
.GetTotalLines()
193 def IsLineInFile(self
, Line
):
194 if Line
>= self
.InsertStartLineNumber
and Line
< self
.InsertStartLineNumber
+ self
.GetTotalLines():
199 def GetLineInFile(self
, Line
):
200 if not self
.IsLineInFile (Line
):
201 return (self
.FileName
, -1)
203 InsertedLines
= self
.InsertStartLineNumber
205 for Profile
in self
.IncludeFileList
:
206 if Profile
.IsLineInFile(Line
):
207 return Profile
.GetLineInFile(Line
)
208 elif Line
>= Profile
.InsertStartLineNumber
:
209 InsertedLines
+= Profile
.GetTotalLines()
211 return (self
.FileName
, Line
- InsertedLines
+ 1)
215 ## The FDF content class that used to record file data when parsing FDF
217 # May raise Exception when opening file.
222 # @param self The object pointer
223 # @param FileName The file that to be parsed
225 def __init__(self
, FileName
):
226 self
.FileLinesList
= []
228 fsock
= open(FileName
, "rb", 0)
230 self
.FileLinesList
= fsock
.readlines()
235 EdkLogger
.error("FdfParser", FILE_OPEN_FAILURE
, ExtraData
=FileName
)
240 self
.InfDict
= {'ArchTBD':[]}
241 # ECC will use this Dict and List information
242 self
.PcdFileLineDict
= {}
243 self
.InfFileLineList
= []
246 self
.FdNameNotSet
= False
248 self
.CapsuleDict
= {}
252 self
.FmpPayloadDict
= {}
254 ## The syntax parser for FDF
256 # PreprocessFile method should be called prior to ParseFile
257 # CycleReferenceCheck method can detect cycles in FDF contents
259 # GetNext*** procedures mean these procedures will get next token first, then make judgement.
260 # Get*** procedures mean these procedures will make judgement on current token only.
265 # @param self The object pointer
266 # @param FileName The file that to be parsed
268 def __init__(self
, FileName
):
269 self
.Profile
= FileProfile(FileName
)
270 self
.FileName
= FileName
271 self
.CurrentLineNumber
= 1
272 self
.CurrentOffsetWithinLine
= 0
273 self
.CurrentFdName
= None
274 self
.CurrentFvName
= None
276 self
.__SkippedChars
= ""
277 GlobalData
.gFdfParser
= self
279 # Used to section info
280 self
.__CurSection
= []
281 # Key: [section name, UI name, arch]
282 # Value: {MACRO_NAME : MACRO_VALUE}
283 self
.__MacroDict
= tdict(True, 3)
286 self
.__WipeOffArea
= []
287 if GenFdsGlobalVariable
.WorkSpaceDir
== '':
288 GenFdsGlobalVariable
.WorkSpaceDir
= os
.getenv("WORKSPACE")
290 ## __IsWhiteSpace() method
292 # Whether char at current FileBufferPos is whitespace
294 # @param self The object pointer
295 # @param Char The char to test
296 # @retval True The char is a kind of white space
297 # @retval False The char is NOT a kind of white space
299 def __IsWhiteSpace(self
, Char
):
300 if Char
in (T_CHAR_NULL
, T_CHAR_CR
, T_CHAR_SPACE
, T_CHAR_TAB
, T_CHAR_LF
):
305 ## __SkipWhiteSpace() method
307 # Skip white spaces from current char, return number of chars skipped
309 # @param self The object pointer
310 # @retval Count The number of chars skipped
312 def __SkipWhiteSpace(self
):
314 while not self
.__EndOfFile
():
316 if self
.__CurrentChar
() in (T_CHAR_NULL
, T_CHAR_CR
, T_CHAR_LF
, T_CHAR_SPACE
, T_CHAR_TAB
):
317 self
.__SkippedChars
+= str(self
.__CurrentChar
())
324 ## __EndOfFile() method
326 # Judge current buffer pos is at file end
328 # @param self The object pointer
329 # @retval True Current File buffer position is at file end
330 # @retval False Current File buffer position is NOT at file end
332 def __EndOfFile(self
):
333 NumberOfLines
= len(self
.Profile
.FileLinesList
)
334 SizeOfLastLine
= len(self
.Profile
.FileLinesList
[-1])
335 if self
.CurrentLineNumber
== NumberOfLines
and self
.CurrentOffsetWithinLine
>= SizeOfLastLine
- 1:
337 elif self
.CurrentLineNumber
> NumberOfLines
:
342 ## __EndOfLine() method
344 # Judge current buffer pos is at line end
346 # @param self The object pointer
347 # @retval True Current File buffer position is at line end
348 # @retval False Current File buffer position is NOT at line end
350 def __EndOfLine(self
):
351 if self
.CurrentLineNumber
> len(self
.Profile
.FileLinesList
):
353 SizeOfCurrentLine
= len(self
.Profile
.FileLinesList
[self
.CurrentLineNumber
- 1])
354 if self
.CurrentOffsetWithinLine
>= SizeOfCurrentLine
:
361 # Reset file data buffer to the initial state
363 # @param self The object pointer
364 # @param DestLine Optional new destination line number.
365 # @param DestOffset Optional new destination offset.
367 def Rewind(self
, DestLine
= 1, DestOffset
= 0):
368 self
.CurrentLineNumber
= DestLine
369 self
.CurrentOffsetWithinLine
= DestOffset
371 ## __UndoOneChar() method
373 # Go back one char in the file buffer
375 # @param self The object pointer
376 # @retval True Successfully go back one char
377 # @retval False Not able to go back one char as file beginning reached
379 def __UndoOneChar(self
):
381 if self
.CurrentLineNumber
== 1 and self
.CurrentOffsetWithinLine
== 0:
383 elif self
.CurrentOffsetWithinLine
== 0:
384 self
.CurrentLineNumber
-= 1
385 self
.CurrentOffsetWithinLine
= len(self
.__CurrentLine
()) - 1
387 self
.CurrentOffsetWithinLine
-= 1
390 ## __GetOneChar() method
392 # Move forward one char in the file buffer
394 # @param self The object pointer
396 def __GetOneChar(self
):
397 if self
.CurrentOffsetWithinLine
== len(self
.Profile
.FileLinesList
[self
.CurrentLineNumber
- 1]) - 1:
398 self
.CurrentLineNumber
+= 1
399 self
.CurrentOffsetWithinLine
= 0
401 self
.CurrentOffsetWithinLine
+= 1
403 ## __CurrentChar() method
405 # Get the char pointed to by the file buffer pointer
407 # @param self The object pointer
408 # @retval Char Current char
410 def __CurrentChar(self
):
411 return self
.Profile
.FileLinesList
[self
.CurrentLineNumber
- 1][self
.CurrentOffsetWithinLine
]
413 ## __NextChar() method
415 # Get the one char pass the char pointed to by the file buffer pointer
417 # @param self The object pointer
418 # @retval Char Next char
420 def __NextChar(self
):
421 if self
.CurrentOffsetWithinLine
== len(self
.Profile
.FileLinesList
[self
.CurrentLineNumber
- 1]) - 1:
422 return self
.Profile
.FileLinesList
[self
.CurrentLineNumber
][0]
424 return self
.Profile
.FileLinesList
[self
.CurrentLineNumber
- 1][self
.CurrentOffsetWithinLine
+ 1]
426 ## __SetCurrentCharValue() method
428 # Modify the value of current char
430 # @param self The object pointer
431 # @param Value The new value of current char
433 def __SetCurrentCharValue(self
, Value
):
434 self
.Profile
.FileLinesList
[self
.CurrentLineNumber
- 1][self
.CurrentOffsetWithinLine
] = Value
436 ## __CurrentLine() method
438 # Get the list that contains current line contents
440 # @param self The object pointer
441 # @retval List current line contents
443 def __CurrentLine(self
):
444 return self
.Profile
.FileLinesList
[self
.CurrentLineNumber
- 1]
446 def __StringToList(self
):
447 self
.Profile
.FileLinesList
= [list(s
) for s
in self
.Profile
.FileLinesList
]
448 self
.Profile
.FileLinesList
[-1].append(' ')
450 def __ReplaceFragment(self
, StartPos
, EndPos
, Value
= ' '):
451 if StartPos
[0] == EndPos
[0]:
453 while Offset
<= EndPos
[1]:
454 self
.Profile
.FileLinesList
[StartPos
[0]][Offset
] = Value
459 while self
.Profile
.FileLinesList
[StartPos
[0]][Offset
] not in ('\r', '\n'):
460 self
.Profile
.FileLinesList
[StartPos
[0]][Offset
] = Value
464 while Line
< EndPos
[0]:
466 while self
.Profile
.FileLinesList
[Line
][Offset
] not in ('\r', '\n'):
467 self
.Profile
.FileLinesList
[Line
][Offset
] = Value
472 while Offset
<= EndPos
[1]:
473 self
.Profile
.FileLinesList
[EndPos
[0]][Offset
] = Value
477 def __GetMacroName(self
):
478 if not self
.__GetNextToken
():
479 raise Warning("expected Macro name", self
.FileName
, self
.CurrentLineNumber
)
480 MacroName
= self
.__Token
482 if MacroName
.startswith('!'):
484 MacroName
= MacroName
[1:].strip()
486 if not MacroName
.startswith('$(') or not MacroName
.endswith(')'):
487 raise Warning("Macro name expected(Please use '$(%(Token)s)' if '%(Token)s' is a macro.)" % {"Token" : MacroName
},
488 self
.FileName
, self
.CurrentLineNumber
)
489 MacroName
= MacroName
[2:-1]
490 return MacroName
, NotFlag
492 def __SetMacroValue(self
, Macro
, Value
):
493 if not self
.__CurSection
:
497 if not self
.__MacroDict
[self
.__CurSection
[0], self
.__CurSection
[1], self
.__CurSection
[2]]:
498 self
.__MacroDict
[self
.__CurSection
[0], self
.__CurSection
[1], self
.__CurSection
[2]] = MacroDict
500 MacroDict
= self
.__MacroDict
[self
.__CurSection
[0], self
.__CurSection
[1], self
.__CurSection
[2]]
501 MacroDict
[Macro
] = Value
503 def __GetMacroValue(self
, Macro
):
505 if Macro
in GlobalData
.gCommandLineDefines
:
506 return GlobalData
.gCommandLineDefines
[Macro
]
507 if Macro
in GlobalData
.gGlobalDefines
:
508 return GlobalData
.gGlobalDefines
[Macro
]
510 if self
.__CurSection
:
511 MacroDict
= self
.__MacroDict
[
512 self
.__CurSection
[0],
513 self
.__CurSection
[1],
516 if MacroDict
and Macro
in MacroDict
:
517 return MacroDict
[Macro
]
520 if Macro
in GlobalData
.gPlatformDefines
:
521 return GlobalData
.gPlatformDefines
[Macro
]
524 def __SectionHeaderParser(self
, Section
):
526 # [FD.UiName]: use dummy instead if UI name is optional
529 # [Rule]: don't take rule section into account, macro is not allowed in this section
530 # [VTF.arch.UiName, arch]
531 # [OptionRom.DriverName]
532 self
.__CurSection
= []
533 Section
= Section
.strip()[1:-1].upper().replace(' ', '').strip('.')
534 ItemList
= Section
.split('.')
536 if Item
== '' or Item
== 'RULE':
539 if Item
== 'DEFINES':
540 self
.__CurSection
= ['COMMON', 'COMMON', 'COMMON']
541 elif Item
== 'VTF' and len(ItemList
) == 3:
543 Pos
= UiName
.find(',')
545 UiName
= UiName
[:Pos
]
546 self
.__CurSection
= ['VTF', UiName
, ItemList
[1]]
547 elif len(ItemList
) > 1:
548 self
.__CurSection
= [ItemList
[0], ItemList
[1], 'COMMON']
549 elif len(ItemList
) > 0:
550 self
.__CurSection
= [ItemList
[0], 'DUMMY', 'COMMON']
552 ## PreprocessFile() method
554 # Preprocess file contents, replace comments with spaces.
555 # In the end, rewind the file buffer pointer to the beginning
556 # BUGBUG: No !include statement processing contained in this procedure
557 # !include statement should be expanded at the same FileLinesList[CurrentLineNumber - 1]
559 # @param self The object pointer
561 def PreprocessFile(self
):
565 DoubleSlashComment
= False
567 # HashComment in quoted string " " is ignored.
570 while not self
.__EndOfFile
():
572 if self
.__CurrentChar
() == T_CHAR_DOUBLE_QUOTE
and not InComment
:
573 InString
= not InString
574 # meet new line, then no longer in a comment for // and '#'
575 if self
.__CurrentChar
() == T_CHAR_LF
:
576 self
.CurrentLineNumber
+= 1
577 self
.CurrentOffsetWithinLine
= 0
578 if InComment
and DoubleSlashComment
:
580 DoubleSlashComment
= False
581 if InComment
and HashComment
:
584 # check for */ comment end
585 elif InComment
and not DoubleSlashComment
and not HashComment
and self
.__CurrentChar
() == T_CHAR_STAR
and self
.__NextChar
() == T_CHAR_SLASH
:
586 self
.__SetCurrentCharValue
(T_CHAR_SPACE
)
588 self
.__SetCurrentCharValue
(T_CHAR_SPACE
)
591 # set comments to spaces
593 self
.__SetCurrentCharValue
(T_CHAR_SPACE
)
595 # check for // comment
596 elif self
.__CurrentChar
() == T_CHAR_SLASH
and self
.__NextChar
() == T_CHAR_SLASH
and not self
.__EndOfLine
():
598 DoubleSlashComment
= True
599 # check for '#' comment
600 elif self
.__CurrentChar
() == T_CHAR_HASH
and not self
.__EndOfLine
() and not InString
:
603 # check for /* comment start
604 elif self
.__CurrentChar
() == T_CHAR_SLASH
and self
.__NextChar
() == T_CHAR_STAR
:
605 self
.__SetCurrentCharValue
( T_CHAR_SPACE
)
607 self
.__SetCurrentCharValue
( T_CHAR_SPACE
)
613 # restore from ListOfList to ListOfString
614 self
.Profile
.FileLinesList
= ["".join(list) for list in self
.Profile
.FileLinesList
]
617 ## PreprocessIncludeFile() method
619 # Preprocess file contents, replace !include statements with file contents.
620 # In the end, rewind the file buffer pointer to the beginning
622 # @param self The object pointer
624 def PreprocessIncludeFile(self
):
625 # nested include support
628 while self
.__GetNextToken
():
630 if self
.__Token
== 'DEFINE':
631 if not self
.__GetNextToken
():
632 raise Warning("expected Macro name", self
.FileName
, self
.CurrentLineNumber
)
634 if not self
.__IsToken
( "="):
635 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
636 Value
= self
.__GetExpression
()
637 MacroDict
[Macro
] = Value
639 elif self
.__Token
== '!include':
641 IncludeLine
= self
.CurrentLineNumber
642 IncludeOffset
= self
.CurrentOffsetWithinLine
- len('!include')
643 if not self
.__GetNextToken
():
644 raise Warning("expected include file name", self
.FileName
, self
.CurrentLineNumber
)
645 IncFileName
= self
.__Token
647 StartPos
= IncFileName
.find('$(', PreIndex
)
648 EndPos
= IncFileName
.find(')', StartPos
+2)
649 while StartPos
!= -1 and EndPos
!= -1:
650 Macro
= IncFileName
[StartPos
+2 : EndPos
]
651 MacroVal
= self
.__GetMacroValue
(Macro
)
653 if Macro
in MacroDict
:
654 MacroVal
= MacroDict
[Macro
]
656 IncFileName
= IncFileName
.replace('$(' + Macro
+ ')', MacroVal
, 1)
657 if MacroVal
.find('$(') != -1:
660 PreIndex
= StartPos
+ len(MacroVal
)
662 raise Warning("The Macro %s is not defined" %Macro
, self
.FileName
, self
.CurrentLineNumber
)
663 StartPos
= IncFileName
.find('$(', PreIndex
)
664 EndPos
= IncFileName
.find(')', StartPos
+2)
666 IncludedFile
= NormPath(IncFileName
)
668 # First search the include file under the same directory as FDF file
670 IncludedFile1
= PathClass(IncludedFile
, os
.path
.dirname(self
.FileName
))
671 ErrorCode
= IncludedFile1
.Validate()[0]
674 # Then search the include file under the same directory as DSC file
677 if GenFdsGlobalVariable
.ActivePlatform
:
678 PlatformDir
= GenFdsGlobalVariable
.ActivePlatform
.Dir
679 elif GlobalData
.gActivePlatform
:
680 PlatformDir
= GlobalData
.gActivePlatform
.MetaFile
.Dir
681 IncludedFile1
= PathClass(IncludedFile
, PlatformDir
)
682 ErrorCode
= IncludedFile1
.Validate()[0]
685 # Also search file under the WORKSPACE directory
687 IncludedFile1
= PathClass(IncludedFile
, GlobalData
.gWorkspace
)
688 ErrorCode
= IncludedFile1
.Validate()[0]
690 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
),
691 self
.FileName
, self
.CurrentLineNumber
)
693 if not IsValidInclude (IncludedFile1
.Path
, self
.CurrentLineNumber
):
694 raise Warning("The include file {0} is causing a include loop.\n".format (IncludedFile1
.Path
), self
.FileName
, self
.CurrentLineNumber
)
696 IncFileProfile
= IncludeFileProfile(IncludedFile1
.Path
)
698 CurrentLine
= self
.CurrentLineNumber
699 CurrentOffset
= self
.CurrentOffsetWithinLine
700 # list index of the insertion, note that line number is 'CurrentLine + 1'
701 InsertAtLine
= CurrentLine
702 ParentProfile
= GetParentAtLine (CurrentLine
)
703 if ParentProfile
!= None:
704 ParentProfile
.IncludeFileList
.insert(0, IncFileProfile
)
705 IncFileProfile
.Level
= ParentProfile
.Level
+ 1
706 IncFileProfile
.InsertStartLineNumber
= InsertAtLine
+ 1
707 # deal with remaining portions after "!include filename", if exists.
708 if self
.__GetNextToken
():
709 if self
.CurrentLineNumber
== CurrentLine
:
710 RemainingLine
= self
.__CurrentLine
()[CurrentOffset
:]
711 self
.Profile
.FileLinesList
.insert(self
.CurrentLineNumber
, RemainingLine
)
712 IncFileProfile
.InsertAdjust
+= 1
713 self
.CurrentLineNumber
+= 1
714 self
.CurrentOffsetWithinLine
= 0
716 for Line
in IncFileProfile
.FileLinesList
:
717 self
.Profile
.FileLinesList
.insert(InsertAtLine
, Line
)
718 self
.CurrentLineNumber
+= 1
721 # reversely sorted to better determine error in file
722 AllIncludeFileList
.insert(0, IncFileProfile
)
724 # comment out the processed include file statement
725 TempList
= list(self
.Profile
.FileLinesList
[IncludeLine
- 1])
726 TempList
.insert(IncludeOffset
, '#')
727 self
.Profile
.FileLinesList
[IncludeLine
- 1] = ''.join(TempList
)
728 if Processed
: # Nested and back-to-back support
729 self
.Rewind(DestLine
= IncFileProfile
.InsertStartLineNumber
- 1)
734 def __GetIfListCurrentItemStat(self
, IfList
):
744 ## PreprocessConditionalStatement() method
746 # Preprocess conditional statement.
747 # In the end, rewind the file buffer pointer to the beginning
749 # @param self The object pointer
751 def PreprocessConditionalStatement(self
):
752 # IfList is a stack of if branches with elements of list [Pos, CondSatisfied, BranchDetermined]
756 while self
.__GetNextToken
():
757 # Determine section name and the location dependent macro
758 if self
.__GetIfListCurrentItemStat
(IfList
):
759 if self
.__Token
.startswith('['):
760 Header
= self
.__Token
761 if not self
.__Token
.endswith(']'):
762 self
.__SkipToToken
(']')
763 Header
+= self
.__SkippedChars
764 if Header
.find('$(') != -1:
765 raise Warning("macro cannot be used in section header", self
.FileName
, self
.CurrentLineNumber
)
766 self
.__SectionHeaderParser
(Header
)
768 # Replace macros except in RULE section or out of section
769 elif self
.__CurSection
and ReplacedLine
!= self
.CurrentLineNumber
:
770 ReplacedLine
= self
.CurrentLineNumber
772 CurLine
= self
.Profile
.FileLinesList
[ReplacedLine
- 1]
774 StartPos
= CurLine
.find('$(', PreIndex
)
775 EndPos
= CurLine
.find(')', StartPos
+2)
776 while StartPos
!= -1 and EndPos
!= -1 and self
.__Token
not in ['!ifdef', '!ifndef', '!if', '!elseif']:
777 MacroName
= CurLine
[StartPos
+2 : EndPos
]
778 MacorValue
= self
.__GetMacroValue
(MacroName
)
779 if MacorValue
!= None:
780 CurLine
= CurLine
.replace('$(' + MacroName
+ ')', MacorValue
, 1)
781 if MacorValue
.find('$(') != -1:
784 PreIndex
= StartPos
+ len(MacorValue
)
786 PreIndex
= EndPos
+ 1
787 StartPos
= CurLine
.find('$(', PreIndex
)
788 EndPos
= CurLine
.find(')', StartPos
+2)
789 self
.Profile
.FileLinesList
[ReplacedLine
- 1] = CurLine
792 if self
.__Token
== 'DEFINE':
793 if self
.__GetIfListCurrentItemStat
(IfList
):
794 if not self
.__CurSection
:
795 raise Warning("macro cannot be defined in Rule section or out of section", self
.FileName
, self
.CurrentLineNumber
)
796 DefineLine
= self
.CurrentLineNumber
- 1
797 DefineOffset
= self
.CurrentOffsetWithinLine
- len('DEFINE')
798 if not self
.__GetNextToken
():
799 raise Warning("expected Macro name", self
.FileName
, self
.CurrentLineNumber
)
801 if not self
.__IsToken
( "="):
802 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
804 Value
= self
.__GetExpression
()
805 self
.__SetMacroValue
(Macro
, Value
)
806 self
.__WipeOffArea
.append(((DefineLine
, DefineOffset
), (self
.CurrentLineNumber
- 1, self
.CurrentOffsetWithinLine
- 1)))
807 elif self
.__Token
== 'SET':
808 if not self
.__GetIfListCurrentItemStat
(IfList
):
810 SetLine
= self
.CurrentLineNumber
- 1
811 SetOffset
= self
.CurrentOffsetWithinLine
- len('SET')
812 PcdPair
= self
.__GetNextPcdName
()
813 PcdName
= "%s.%s" % (PcdPair
[1], PcdPair
[0])
814 if not self
.__IsToken
( "="):
815 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
817 Value
= self
.__GetExpression
()
818 Value
= self
.__EvaluateConditional
(Value
, self
.CurrentLineNumber
, 'eval', True)
820 self
.__PcdDict
[PcdName
] = Value
822 self
.Profile
.PcdDict
[PcdPair
] = Value
823 FileLineTuple
= GetRealFileLine(self
.FileName
, self
.CurrentLineNumber
)
824 self
.Profile
.PcdFileLineDict
[PcdPair
] = FileLineTuple
826 self
.__WipeOffArea
.append(((SetLine
, SetOffset
), (self
.CurrentLineNumber
- 1, self
.CurrentOffsetWithinLine
- 1)))
827 elif self
.__Token
in ('!ifdef', '!ifndef', '!if'):
828 IfStartPos
= (self
.CurrentLineNumber
- 1, self
.CurrentOffsetWithinLine
- len(self
.__Token
))
829 IfList
.append([IfStartPos
, None, None])
831 CondLabel
= self
.__Token
832 Expression
= self
.__GetExpression
()
834 if CondLabel
== '!if':
835 ConditionSatisfied
= self
.__EvaluateConditional
(Expression
, IfList
[-1][0][0] + 1, 'eval')
837 ConditionSatisfied
= self
.__EvaluateConditional
(Expression
, IfList
[-1][0][0] + 1, 'in')
838 if CondLabel
== '!ifndef':
839 ConditionSatisfied
= not ConditionSatisfied
841 BranchDetermined
= ConditionSatisfied
842 IfList
[-1] = [IfList
[-1][0], ConditionSatisfied
, BranchDetermined
]
843 if ConditionSatisfied
:
844 self
.__WipeOffArea
.append((IfList
[-1][0], (self
.CurrentLineNumber
- 1, self
.CurrentOffsetWithinLine
- 1)))
845 elif self
.__Token
in ('!elseif', '!else'):
846 ElseStartPos
= (self
.CurrentLineNumber
- 1, self
.CurrentOffsetWithinLine
- len(self
.__Token
))
848 raise Warning("Missing !if statement", self
.FileName
, self
.CurrentLineNumber
)
851 IfList
[-1] = [ElseStartPos
, False, True]
852 self
.__WipeOffArea
.append((ElseStartPos
, (self
.CurrentLineNumber
- 1, self
.CurrentOffsetWithinLine
- 1)))
854 self
.__WipeOffArea
.append((IfList
[-1][0], ElseStartPos
))
855 IfList
[-1] = [ElseStartPos
, True, IfList
[-1][2]]
856 if self
.__Token
== '!elseif':
857 Expression
= self
.__GetExpression
()
858 ConditionSatisfied
= self
.__EvaluateConditional
(Expression
, IfList
[-1][0][0] + 1, 'eval')
859 IfList
[-1] = [IfList
[-1][0], ConditionSatisfied
, IfList
[-1][2]]
863 IfList
[-1][1] = False
866 self
.__WipeOffArea
.append((IfList
[-1][0], (self
.CurrentLineNumber
- 1, self
.CurrentOffsetWithinLine
- 1)))
867 elif self
.__Token
== '!endif':
869 raise Warning("Missing !if statement", self
.FileName
, self
.CurrentLineNumber
)
871 self
.__WipeOffArea
.append(((self
.CurrentLineNumber
- 1, self
.CurrentOffsetWithinLine
- len('!endif')), (self
.CurrentLineNumber
- 1, self
.CurrentOffsetWithinLine
- 1)))
873 self
.__WipeOffArea
.append((IfList
[-1][0], (self
.CurrentLineNumber
- 1, self
.CurrentOffsetWithinLine
- 1)))
876 elif not IfList
: # Don't use PCDs inside conditional directive
877 if self
.CurrentLineNumber
<= RegionLayoutLine
:
878 # Don't try the same line twice
880 SetPcd
= ShortcutPcdPattern
.match(self
.Profile
.FileLinesList
[self
.CurrentLineNumber
- 1])
882 self
.__PcdDict
[SetPcd
.group('name')] = SetPcd
.group('value')
883 RegionLayoutLine
= self
.CurrentLineNumber
885 RegionSize
= RegionSizePattern
.match(self
.Profile
.FileLinesList
[self
.CurrentLineNumber
- 1])
887 RegionLayoutLine
= self
.CurrentLineNumber
889 RegionSizeGuid
= RegionSizeGuidPattern
.match(self
.Profile
.FileLinesList
[self
.CurrentLineNumber
])
890 if not RegionSizeGuid
:
891 RegionLayoutLine
= self
.CurrentLineNumber
+ 1
893 self
.__PcdDict
[RegionSizeGuid
.group('base')] = RegionSize
.group('base')
894 self
.__PcdDict
[RegionSizeGuid
.group('size')] = RegionSize
.group('size')
895 RegionLayoutLine
= self
.CurrentLineNumber
+ 1
898 raise Warning("Missing !endif", self
.FileName
, self
.CurrentLineNumber
)
901 def __CollectMacroPcd(self
):
905 MacroDict
.update(GlobalData
.gPlatformPcds
)
906 MacroDict
.update(self
.__PcdDict
)
909 MacroDict
.update(GlobalData
.gPlatformDefines
)
911 if self
.__CurSection
:
913 ScopeMacro
= self
.__MacroDict
['COMMON', 'COMMON', 'COMMON']
915 MacroDict
.update(ScopeMacro
)
918 ScopeMacro
= self
.__MacroDict
[
919 self
.__CurSection
[0],
920 self
.__CurSection
[1],
924 MacroDict
.update(ScopeMacro
)
926 MacroDict
.update(GlobalData
.gGlobalDefines
)
927 MacroDict
.update(GlobalData
.gCommandLineDefines
)
928 if GlobalData
.BuildOptionPcd
:
929 for Item
in GlobalData
.BuildOptionPcd
:
930 if type(Item
) is tuple:
932 PcdName
, TmpValue
= Item
.split("=")
933 TmpValue
= BuildOptionValue(TmpValue
, {})
934 MacroDict
[PcdName
.strip()] = TmpValue
939 def __EvaluateConditional(self
, Expression
, Line
, Op
= None, Value
= None):
940 FileLineTuple
= GetRealFileLine(self
.FileName
, Line
)
941 MacroPcdDict
= self
.__CollectMacroPcd
()
945 return ValueExpression(Expression
, MacroPcdDict
)(True)
947 return ValueExpression(Expression
, MacroPcdDict
)()
948 except WrnExpression
, Excpt
:
950 # Catch expression evaluation warning here. We need to report
951 # the precise number of line and return the evaluation result
953 EdkLogger
.warn('Parser', "Suspicious expression: %s" % str(Excpt
),
954 File
=self
.FileName
, ExtraData
=self
.__CurrentLine
(),
957 except Exception, Excpt
:
958 if hasattr(Excpt
, 'Pcd'):
959 if Excpt
.Pcd
in GlobalData
.gPlatformOtherPcds
:
960 Info
= GlobalData
.gPlatformOtherPcds
[Excpt
.Pcd
]
961 raise Warning("Cannot use this PCD (%s) in an expression as"
962 " it must be defined in a [PcdsFixedAtBuild] or [PcdsFeatureFlag] section"
963 " of the DSC file (%s), and it is currently defined in this section:"
964 " %s, line #: %d." % (Excpt
.Pcd
, GlobalData
.gPlatformOtherPcds
['DSCFILE'], Info
[0], Info
[1]),
967 raise Warning("PCD (%s) is not defined in DSC file (%s)" % (Excpt
.Pcd
, GlobalData
.gPlatformOtherPcds
['DSCFILE']),
970 raise Warning(str(Excpt
), *FileLineTuple
)
972 if Expression
.startswith('$(') and Expression
[-1] == ')':
973 Expression
= Expression
[2:-1]
974 return Expression
in MacroPcdDict
976 ## __IsToken() method
978 # Check whether input string is found from current char position along
979 # If found, the string value is put into self.__Token
981 # @param self The object pointer
982 # @param String The string to search
983 # @param IgnoreCase Indicate case sensitive/non-sensitive search, default is case sensitive
984 # @retval True Successfully find string, file buffer pointer moved forward
985 # @retval False Not able to find string, file buffer pointer not changed
987 def __IsToken(self
, String
, IgnoreCase
= False):
988 self
.__SkipWhiteSpace
()
990 # Only consider the same line, no multi-line token allowed
991 StartPos
= self
.CurrentOffsetWithinLine
994 index
= self
.__CurrentLine
()[self
.CurrentOffsetWithinLine
: ].upper().find(String
.upper())
996 index
= self
.__CurrentLine
()[self
.CurrentOffsetWithinLine
: ].find(String
)
998 self
.CurrentOffsetWithinLine
+= len(String
)
999 self
.__Token
= self
.__CurrentLine
()[StartPos
: self
.CurrentOffsetWithinLine
]
1003 ## __IsKeyword() method
1005 # Check whether input keyword is found from current char position along, whole word only!
1006 # If found, the string value is put into self.__Token
1008 # @param self The object pointer
1009 # @param Keyword The string to search
1010 # @param IgnoreCase Indicate case sensitive/non-sensitive search, default is case sensitive
1011 # @retval True Successfully find string, file buffer pointer moved forward
1012 # @retval False Not able to find string, file buffer pointer not changed
1014 def __IsKeyword(self
, KeyWord
, IgnoreCase
= False):
1015 self
.__SkipWhiteSpace
()
1017 # Only consider the same line, no multi-line token allowed
1018 StartPos
= self
.CurrentOffsetWithinLine
1021 index
= self
.__CurrentLine
()[self
.CurrentOffsetWithinLine
: ].upper().find(KeyWord
.upper())
1023 index
= self
.__CurrentLine
()[self
.CurrentOffsetWithinLine
: ].find(KeyWord
)
1025 followingChar
= self
.__CurrentLine
()[self
.CurrentOffsetWithinLine
+ len(KeyWord
)]
1026 if not str(followingChar
).isspace() and followingChar
not in SEPERATOR_TUPLE
:
1028 self
.CurrentOffsetWithinLine
+= len(KeyWord
)
1029 self
.__Token
= self
.__CurrentLine
()[StartPos
: self
.CurrentOffsetWithinLine
]
1033 def __GetExpression(self
):
1034 Line
= self
.Profile
.FileLinesList
[self
.CurrentLineNumber
- 1]
1035 Index
= len(Line
) - 1
1036 while Line
[Index
] in ['\r', '\n']:
1038 ExpressionString
= self
.Profile
.FileLinesList
[self
.CurrentLineNumber
- 1][self
.CurrentOffsetWithinLine
:Index
+1]
1039 self
.CurrentOffsetWithinLine
+= len(ExpressionString
)
1040 ExpressionString
= ExpressionString
.strip()
1041 return ExpressionString
1043 ## __GetNextWord() method
1045 # Get next C name from file lines
1046 # If found, the string value is put into self.__Token
1048 # @param self The object pointer
1049 # @retval True Successfully find a C name string, file buffer pointer moved forward
1050 # @retval False Not able to find a C name string, file buffer pointer not changed
1052 def __GetNextWord(self
):
1053 self
.__SkipWhiteSpace
()
1054 if self
.__EndOfFile
():
1057 TempChar
= self
.__CurrentChar
()
1058 StartPos
= self
.CurrentOffsetWithinLine
1059 if (TempChar
>= 'a' and TempChar
<= 'z') or (TempChar
>= 'A' and TempChar
<= 'Z') or TempChar
== '_':
1061 while not self
.__EndOfLine
():
1062 TempChar
= self
.__CurrentChar
()
1063 if (TempChar
>= 'a' and TempChar
<= 'z') or (TempChar
>= 'A' and TempChar
<= 'Z') \
1064 or (TempChar
>= '0' and TempChar
<= '9') or TempChar
== '_' or TempChar
== '-':
1070 self
.__Token
= self
.__CurrentLine
()[StartPos
: self
.CurrentOffsetWithinLine
]
1075 ## __GetNextToken() method
1077 # Get next token unit before a seperator
1078 # If found, the string value is put into self.__Token
1080 # @param self The object pointer
1081 # @retval True Successfully find a token unit, file buffer pointer moved forward
1082 # @retval False Not able to find a token unit, file buffer pointer not changed
1084 def __GetNextToken(self
):
1085 # Skip leading spaces, if exist.
1086 self
.__SkipWhiteSpace
()
1087 if self
.__EndOfFile
():
1089 # Record the token start position, the position of the first non-space char.
1090 StartPos
= self
.CurrentOffsetWithinLine
1091 StartLine
= self
.CurrentLineNumber
1092 while StartLine
== self
.CurrentLineNumber
:
1093 TempChar
= self
.__CurrentChar
()
1094 # Try to find the end char that is not a space and not in seperator tuple.
1095 # That is, when we got a space or any char in the tuple, we got the end of token.
1096 if not str(TempChar
).isspace() and TempChar
not in SEPERATOR_TUPLE
:
1098 # if we happen to meet a seperator as the first char, we must proceed to get it.
1099 # That is, we get a token that is a seperator char. nomally it is the boundary of other tokens.
1100 elif StartPos
== self
.CurrentOffsetWithinLine
and TempChar
in SEPERATOR_TUPLE
:
1108 EndPos
= self
.CurrentOffsetWithinLine
1109 if self
.CurrentLineNumber
!= StartLine
:
1110 EndPos
= len(self
.Profile
.FileLinesList
[StartLine
-1])
1111 self
.__Token
= self
.Profile
.FileLinesList
[StartLine
-1][StartPos
: EndPos
]
1112 if StartPos
!= self
.CurrentOffsetWithinLine
:
1117 def __GetNextOp(self
):
1118 # Skip leading spaces, if exist.
1119 self
.__SkipWhiteSpace
()
1120 if self
.__EndOfFile
():
1122 # Record the token start position, the position of the first non-space char.
1123 StartPos
= self
.CurrentOffsetWithinLine
1124 while not self
.__EndOfLine
():
1125 TempChar
= self
.__CurrentChar
()
1126 # Try to find the end char that is not a space
1127 if not str(TempChar
).isspace():
1134 if StartPos
!= self
.CurrentOffsetWithinLine
:
1135 self
.__Token
= self
.__CurrentLine
()[StartPos
: self
.CurrentOffsetWithinLine
]
1139 ## __GetNextGuid() method
1141 # Get next token unit before a seperator
1142 # If found, the GUID string is put into self.__Token
1144 # @param self The object pointer
1145 # @retval True Successfully find a registry format GUID, file buffer pointer moved forward
1146 # @retval False Not able to find a registry format GUID, file buffer pointer not changed
1148 def __GetNextGuid(self
):
1150 if not self
.__GetNextToken
():
1152 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}')
1153 if p
.match(self
.__Token
) != None:
1159 def __Verify(self
, Name
, Value
, Scope
):
1160 if Scope
in ['UINT64', 'UINT8']:
1163 if Value
.upper().startswith('0X'):
1164 ValueNumber
= int (Value
, 16)
1166 ValueNumber
= int (Value
)
1168 EdkLogger
.error("FdfParser", FORMAT_INVALID
, "The value is not valid dec or hex number for %s." % Name
)
1170 EdkLogger
.error("FdfParser", FORMAT_INVALID
, "The value can't be set to negative value for %s." % Name
)
1171 if Scope
== 'UINT64':
1172 if ValueNumber
>= 0x10000000000000000:
1173 EdkLogger
.error("FdfParser", FORMAT_INVALID
, "Too large value for %s." % Name
)
1174 if Scope
== 'UINT8':
1175 if ValueNumber
>= 0x100:
1176 EdkLogger
.error("FdfParser", FORMAT_INVALID
, "Too large value for %s." % Name
)
1179 ## __UndoToken() method
1181 # Go back one token unit in file buffer
1183 # @param self The object pointer
1185 def __UndoToken(self
):
1186 self
.__UndoOneChar
()
1187 while self
.__CurrentChar
().isspace():
1188 if not self
.__UndoOneChar
():
1193 StartPos
= self
.CurrentOffsetWithinLine
1194 CurrentLine
= self
.CurrentLineNumber
1195 while CurrentLine
== self
.CurrentLineNumber
:
1197 TempChar
= self
.__CurrentChar
()
1198 # Try to find the end char that is not a space and not in seperator tuple.
1199 # That is, when we got a space or any char in the tuple, we got the end of token.
1200 if not str(TempChar
).isspace() and not TempChar
in SEPERATOR_TUPLE
:
1201 if not self
.__UndoOneChar
():
1203 # if we happen to meet a seperator as the first char, we must proceed to get it.
1204 # That is, we get a token that is a seperator char. nomally it is the boundary of other tokens.
1205 elif StartPos
== self
.CurrentOffsetWithinLine
and TempChar
in SEPERATOR_TUPLE
:
1212 ## __HexDigit() method
1214 # Whether char input is a Hex data bit
1216 # @param self The object pointer
1217 # @param TempChar The char to test
1218 # @retval True The char is a Hex data bit
1219 # @retval False The char is NOT a Hex data bit
1221 def __HexDigit(self
, TempChar
):
1222 if (TempChar
>= 'a' and TempChar
<= 'f') or (TempChar
>= 'A' and TempChar
<= 'F') \
1223 or (TempChar
>= '0' and TempChar
<= '9'):
1228 def __IsHex(self
, HexStr
):
1229 if not HexStr
.upper().startswith("0X"):
1231 if len(self
.__Token
) <= 2:
1233 charList
= [c
for c
in HexStr
[2 : ] if not self
.__HexDigit
( c
)]
1234 if len(charList
) == 0:
1238 ## __GetNextHexNumber() method
1240 # Get next HEX data before a seperator
1241 # If found, the HEX data is put into self.__Token
1243 # @param self The object pointer
1244 # @retval True Successfully find a HEX data, file buffer pointer moved forward
1245 # @retval False Not able to find a HEX data, file buffer pointer not changed
1247 def __GetNextHexNumber(self
):
1248 if not self
.__GetNextToken
():
1250 if self
.__IsHex
(self
.__Token
):
1256 ## __GetNextDecimalNumber() method
1258 # Get next decimal data before a seperator
1259 # If found, the decimal data is put into self.__Token
1261 # @param self The object pointer
1262 # @retval True Successfully find a decimal data, file buffer pointer moved forward
1263 # @retval False Not able to find a decimal data, file buffer pointer not changed
1265 def __GetNextDecimalNumber(self
):
1266 if not self
.__GetNextToken
():
1268 if self
.__Token
.isdigit():
1274 ## __GetNextPcdName() method
1276 # Get next PCD token space C name and PCD C name pair before a seperator
1277 # If found, the decimal data is put into self.__Token
1279 # @param self The object pointer
1280 # @retval Tuple PCD C name and PCD token space C name pair
1282 def __GetNextPcdName(self
):
1283 if not self
.__GetNextWord
():
1284 raise Warning("expected format of <PcdTokenSpaceCName>.<PcdCName>", self
.FileName
, self
.CurrentLineNumber
)
1285 pcdTokenSpaceCName
= self
.__Token
1287 if not self
.__IsToken
( "."):
1288 raise Warning("expected format of <PcdTokenSpaceCName>.<PcdCName>", self
.FileName
, self
.CurrentLineNumber
)
1290 if not self
.__GetNextWord
():
1291 raise Warning("expected format of <PcdTokenSpaceCName>.<PcdCName>", self
.FileName
, self
.CurrentLineNumber
)
1292 pcdCName
= self
.__Token
1294 return (pcdCName
, pcdTokenSpaceCName
)
1296 ## __GetStringData() method
1298 # Get string contents quoted in ""
1299 # If found, the decimal data is put into self.__Token
1301 # @param self The object pointer
1302 # @retval True Successfully find a string data, file buffer pointer moved forward
1303 # @retval False Not able to find a string data, file buffer pointer not changed
1305 def __GetStringData(self
):
1306 if self
.__Token
.startswith("\"") or self
.__Token
.startswith("L\""):
1308 self
.__SkipToToken
("\"")
1309 currentLineNumber
= self
.CurrentLineNumber
1311 if not self
.__SkipToToken
("\""):
1312 raise Warning("Missing Quote \" for String", self
.FileName
, self
.CurrentLineNumber
)
1313 if currentLineNumber
!= self
.CurrentLineNumber
:
1314 raise Warning("Missing Quote \" for String", self
.FileName
, self
.CurrentLineNumber
)
1315 self
.__Token
= self
.__SkippedChars
.rstrip('\"')
1318 elif self
.__Token
.startswith("\'") or self
.__Token
.startswith("L\'"):
1320 self
.__SkipToToken
("\'")
1321 currentLineNumber
= self
.CurrentLineNumber
1323 if not self
.__SkipToToken
("\'"):
1324 raise Warning("Missing Quote \' for String", self
.FileName
, self
.CurrentLineNumber
)
1325 if currentLineNumber
!= self
.CurrentLineNumber
:
1326 raise Warning("Missing Quote \' for String", self
.FileName
, self
.CurrentLineNumber
)
1327 self
.__Token
= self
.__SkippedChars
.rstrip('\'')
1333 ## __SkipToToken() method
1335 # Search forward in file buffer for the string
1336 # The skipped chars are put into self.__SkippedChars
1338 # @param self The object pointer
1339 # @param String The string to search
1340 # @param IgnoreCase Indicate case sensitive/non-sensitive search, default is case sensitive
1341 # @retval True Successfully find the string, file buffer pointer moved forward
1342 # @retval False Not able to find the string, file buffer pointer not changed
1344 def __SkipToToken(self
, String
, IgnoreCase
= False):
1345 StartPos
= self
.GetFileBufferPos()
1347 self
.__SkippedChars
= ""
1348 while not self
.__EndOfFile
():
1351 index
= self
.__CurrentLine
()[self
.CurrentOffsetWithinLine
: ].upper().find(String
.upper())
1353 index
= self
.__CurrentLine
()[self
.CurrentOffsetWithinLine
: ].find(String
)
1355 self
.CurrentOffsetWithinLine
+= len(String
)
1356 self
.__SkippedChars
+= String
1358 self
.__SkippedChars
+= str(self
.__CurrentChar
())
1361 self
.SetFileBufferPos( StartPos
)
1362 self
.__SkippedChars
= ""
1365 ## GetFileBufferPos() method
1367 # Return the tuple of current line and offset within the line
1369 # @param self The object pointer
1370 # @retval Tuple Line number and offset pair
1372 def GetFileBufferPos(self
):
1373 return (self
.CurrentLineNumber
, self
.CurrentOffsetWithinLine
)
1375 ## SetFileBufferPos() method
1377 # Restore the file buffer position
1379 # @param self The object pointer
1380 # @param Pos The new file buffer position
1382 def SetFileBufferPos(self
, Pos
):
1383 (self
.CurrentLineNumber
, self
.CurrentOffsetWithinLine
) = Pos
1385 ## Preprocess() method
1387 # Preprocess comment, conditional directive, include directive, replace macro.
1388 # Exception will be raised if syntax error found
1390 # @param self The object pointer
1392 def Preprocess(self
):
1393 self
.__StringToList
()
1394 self
.PreprocessFile()
1395 self
.PreprocessIncludeFile()
1396 self
.__StringToList
()
1397 self
.PreprocessFile()
1398 self
.PreprocessConditionalStatement()
1399 self
.__StringToList
()
1400 for Pos
in self
.__WipeOffArea
:
1401 self
.__ReplaceFragment
(Pos
[0], Pos
[1])
1402 self
.Profile
.FileLinesList
= ["".join(list) for list in self
.Profile
.FileLinesList
]
1404 while self
.__GetDefines
():
1407 ## ParseFile() method
1409 # Parse the file profile buffer to extract fd, fv ... information
1410 # Exception will be raised if syntax error found
1412 # @param self The object pointer
1414 def ParseFile(self
):
1419 # Keep processing sections of the FDF until no new sections or a syntax error is found
1421 while self
.__GetFd
() or self
.__GetFv
() or self
.__GetFmp
() or self
.__GetCapsule
() or self
.__GetVtf
() or self
.__GetRule
() or self
.__GetOptionRom
():
1426 #'\n\tGot Token: \"%s\" from File %s\n' % (self.__Token, FileLineTuple[0]) + \
1427 # At this point, the closest parent would be the included file itself
1428 Profile
= GetParentAtLine(X
.OriginalLineNumber
)
1430 X
.Message
+= ' near line %d, column %d: %s' \
1431 % (X
.LineNumber
, 0, Profile
.FileLinesList
[X
.LineNumber
-1])
1433 FileLineTuple
= GetRealFileLine(self
.FileName
, self
.CurrentLineNumber
)
1434 X
.Message
+= ' near line %d, column %d: %s' \
1435 % (FileLineTuple
[1], self
.CurrentOffsetWithinLine
+ 1, self
.Profile
.FileLinesList
[self
.CurrentLineNumber
- 1][self
.CurrentOffsetWithinLine
:].rstrip('\n').rstrip('\r'))
1438 ## SectionParser() method
1440 # Parse the file section info
1441 # Exception will be raised if syntax error found
1443 # @param self The object pointer
1444 # @param section The section string
1446 def SectionParser(self
, section
):
1448 if not S
.startswith("[DEFINES") and not S
.startswith("[FD.") and not S
.startswith("[FV.") and not S
.startswith("[CAPSULE.") \
1449 and not S
.startswith("[VTF.") and not S
.startswith("[RULE.") and not S
.startswith("[OPTIONROM.") and not S
.startswith('[FMPPAYLOAD.'):
1450 raise Warning("Unknown section or section appear sequence error (The correct sequence should be [DEFINES], [FD.], [FV.], [Capsule.], [VTF.], [Rule.], [OptionRom.], [FMPPAYLOAD.])", self
.FileName
, self
.CurrentLineNumber
)
1452 ## __GetDefines() method
1454 # Get Defines section contents and store its data into AllMacrosList
1456 # @param self The object pointer
1457 # @retval True Successfully find a Defines
1458 # @retval False Not able to find a Defines
1460 def __GetDefines(self
):
1462 if not self
.__GetNextToken
():
1465 S
= self
.__Token
.upper()
1466 if S
.startswith("[") and not S
.startswith("[DEFINES"):
1467 self
.SectionParser(S
)
1472 if not self
.__IsToken
("[DEFINES", True):
1473 FileLineTuple
= GetRealFileLine(self
.FileName
, self
.CurrentLineNumber
)
1474 #print 'Parsing String: %s in File %s, At line: %d, Offset Within Line: %d' \
1475 # % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine :], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine)
1476 raise Warning("expected [DEFINES", self
.FileName
, self
.CurrentLineNumber
)
1478 if not self
.__IsToken
( "]"):
1479 raise Warning("expected ']'", self
.FileName
, self
.CurrentLineNumber
)
1481 while self
.__GetNextWord
():
1482 # handle the SET statement
1483 if self
.__Token
== 'SET':
1485 self
.__GetSetStatement
(None)
1488 Macro
= self
.__Token
1490 if not self
.__IsToken
("="):
1491 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
1492 if not self
.__GetNextToken
() or self
.__Token
.startswith('['):
1493 raise Warning("expected MACRO value", self
.FileName
, self
.CurrentLineNumber
)
1494 Value
= self
.__Token
1500 # Get FD section contents and store its data into FD dictionary of self.Profile
1502 # @param self The object pointer
1503 # @retval True Successfully find a FD
1504 # @retval False Not able to find a FD
1508 if not self
.__GetNextToken
():
1511 S
= self
.__Token
.upper()
1512 if S
.startswith("[") and not S
.startswith("[FD."):
1513 if not S
.startswith("[FV.") and not S
.startswith('[FMPPAYLOAD.') and not S
.startswith("[CAPSULE.") \
1514 and not S
.startswith("[VTF.") and not S
.startswith("[RULE.") and not S
.startswith("[OPTIONROM."):
1515 raise Warning("Unknown section", self
.FileName
, self
.CurrentLineNumber
)
1520 if not self
.__IsToken
("[FD.", True):
1521 FileLineTuple
= GetRealFileLine(self
.FileName
, self
.CurrentLineNumber
)
1522 #print 'Parsing String: %s in File %s, At line: %d, Offset Within Line: %d' \
1523 # % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine :], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine)
1524 raise Warning("expected [FD.]", self
.FileName
, self
.CurrentLineNumber
)
1526 FdName
= self
.__GetUiName
()
1528 if len (self
.Profile
.FdDict
) == 0:
1529 FdName
= GenFdsGlobalVariable
.PlatformName
1530 if FdName
== "" and GlobalData
.gActivePlatform
:
1531 FdName
= GlobalData
.gActivePlatform
.PlatformName
1532 self
.Profile
.FdNameNotSet
= True
1534 raise Warning("expected FdName in [FD.] section", self
.FileName
, self
.CurrentLineNumber
)
1535 self
.CurrentFdName
= FdName
.upper()
1537 if self
.CurrentFdName
in self
.Profile
.FdDict
:
1538 raise Warning("Unexpected the same FD name", self
.FileName
, self
.CurrentLineNumber
)
1540 if not self
.__IsToken
( "]"):
1541 raise Warning("expected ']'", self
.FileName
, self
.CurrentLineNumber
)
1544 FdObj
.FdUiName
= self
.CurrentFdName
1545 self
.Profile
.FdDict
[self
.CurrentFdName
] = FdObj
1547 if len (self
.Profile
.FdDict
) > 1 and self
.Profile
.FdNameNotSet
:
1548 raise Warning("expected all FDs have their name", self
.FileName
, self
.CurrentLineNumber
)
1550 Status
= self
.__GetCreateFile
(FdObj
)
1552 raise Warning("FD name error", self
.FileName
, self
.CurrentLineNumber
)
1554 while self
.__GetTokenStatements
(FdObj
):
1556 for Attr
in ("BaseAddress", "Size", "ErasePolarity"):
1557 if getattr(FdObj
, Attr
) == None:
1558 self
.__GetNextToken
()
1559 raise Warning("Keyword %s missing" % Attr
, self
.FileName
, self
.CurrentLineNumber
)
1561 if not FdObj
.BlockSizeList
:
1562 FdObj
.BlockSizeList
.append((1, FdObj
.Size
, None))
1564 self
.__GetDefineStatements
(FdObj
)
1566 self
.__GetSetStatements
(FdObj
)
1568 if not self
.__GetRegionLayout
(FdObj
):
1569 raise Warning("expected region layout", self
.FileName
, self
.CurrentLineNumber
)
1571 while self
.__GetRegionLayout
(FdObj
):
1575 ## __GetUiName() method
1577 # Return the UI name of a section
1579 # @param self The object pointer
1580 # @retval FdName UI name
1582 def __GetUiName(self
):
1584 if self
.__GetNextWord
():
1589 ## __GetCreateFile() method
1591 # Return the output file name of object
1593 # @param self The object pointer
1594 # @param Obj object whose data will be stored in file
1595 # @retval FdName UI name
1597 def __GetCreateFile(self
, Obj
):
1599 if self
.__IsKeyword
( "CREATE_FILE"):
1600 if not self
.__IsToken
( "="):
1601 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
1603 if not self
.__GetNextToken
():
1604 raise Warning("expected file name", self
.FileName
, self
.CurrentLineNumber
)
1606 FileName
= self
.__Token
1607 Obj
.CreateFileName
= FileName
1611 ## __GetTokenStatements() method
1613 # Get token statements
1615 # @param self The object pointer
1616 # @param Obj for whom token statement is got
1618 def __GetTokenStatements(self
, Obj
):
1619 if self
.__IsKeyword
( "BaseAddress"):
1620 if not self
.__IsToken
( "="):
1621 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
1623 if not self
.__GetNextHexNumber
():
1624 raise Warning("expected Hex base address", self
.FileName
, self
.CurrentLineNumber
)
1626 Obj
.BaseAddress
= self
.__Token
1628 if self
.__IsToken
( "|"):
1629 pcdPair
= self
.__GetNextPcdName
()
1630 Obj
.BaseAddressPcd
= pcdPair
1631 self
.Profile
.PcdDict
[pcdPair
] = Obj
.BaseAddress
1632 FileLineTuple
= GetRealFileLine(self
.FileName
, self
.CurrentLineNumber
)
1633 self
.Profile
.PcdFileLineDict
[pcdPair
] = FileLineTuple
1636 if self
.__IsKeyword
( "Size"):
1637 if not self
.__IsToken
( "="):
1638 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
1640 if not self
.__GetNextHexNumber
():
1641 raise Warning("expected Hex size", self
.FileName
, self
.CurrentLineNumber
)
1644 if self
.__IsToken
( "|"):
1645 pcdPair
= self
.__GetNextPcdName
()
1646 Obj
.SizePcd
= pcdPair
1647 self
.Profile
.PcdDict
[pcdPair
] = Size
1648 FileLineTuple
= GetRealFileLine(self
.FileName
, self
.CurrentLineNumber
)
1649 self
.Profile
.PcdFileLineDict
[pcdPair
] = FileLineTuple
1650 Obj
.Size
= long(Size
, 0)
1653 if self
.__IsKeyword
( "ErasePolarity"):
1654 if not self
.__IsToken
( "="):
1655 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
1657 if not self
.__GetNextToken
():
1658 raise Warning("expected Erase Polarity", self
.FileName
, self
.CurrentLineNumber
)
1660 if self
.__Token
!= "1" and self
.__Token
!= "0":
1661 raise Warning("expected 1 or 0 Erase Polarity", self
.FileName
, self
.CurrentLineNumber
)
1663 Obj
.ErasePolarity
= self
.__Token
1666 return self
.__GetBlockStatements
(Obj
)
1668 ## __GetAddressStatements() method
1670 # Get address statements
1672 # @param self The object pointer
1673 # @param Obj for whom address statement is got
1674 # @retval True Successfully find
1675 # @retval False Not able to find
1677 def __GetAddressStatements(self
, Obj
):
1679 if self
.__IsKeyword
("BsBaseAddress"):
1680 if not self
.__IsToken
( "="):
1681 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
1683 if not self
.__GetNextDecimalNumber
() and not self
.__GetNextHexNumber
():
1684 raise Warning("expected address", self
.FileName
, self
.CurrentLineNumber
)
1686 BsAddress
= long(self
.__Token
, 0)
1687 Obj
.BsBaseAddress
= BsAddress
1689 if self
.__IsKeyword
("RtBaseAddress"):
1690 if not self
.__IsToken
( "="):
1691 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
1693 if not self
.__GetNextDecimalNumber
() and not self
.__GetNextHexNumber
():
1694 raise Warning("expected address", self
.FileName
, self
.CurrentLineNumber
)
1696 RtAddress
= long(self
.__Token
, 0)
1697 Obj
.RtBaseAddress
= RtAddress
1699 ## __GetBlockStatements() method
1701 # Get block statements
1703 # @param self The object pointer
1704 # @param Obj for whom block statement is got
1706 def __GetBlockStatements(self
, Obj
):
1708 while self
.__GetBlockStatement
(Obj
):
1711 Item
= Obj
.BlockSizeList
[-1]
1712 if Item
[0] == None or Item
[1] == None:
1713 raise Warning("expected block statement", self
.FileName
, self
.CurrentLineNumber
)
1716 ## __GetBlockStatement() method
1718 # Get block statement
1720 # @param self The object pointer
1721 # @param Obj for whom block statement is got
1722 # @retval True Successfully find
1723 # @retval False Not able to find
1725 def __GetBlockStatement(self
, Obj
):
1726 if not self
.__IsKeyword
( "BlockSize"):
1729 if not self
.__IsToken
( "="):
1730 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
1732 if not self
.__GetNextHexNumber
() and not self
.__GetNextDecimalNumber
():
1733 raise Warning("expected Hex or Integer block size", self
.FileName
, self
.CurrentLineNumber
)
1735 BlockSize
= self
.__Token
1737 if self
.__IsToken
( "|"):
1738 PcdPair
= self
.__GetNextPcdName
()
1739 BlockSizePcd
= PcdPair
1740 self
.Profile
.PcdDict
[PcdPair
] = BlockSize
1741 FileLineTuple
= GetRealFileLine(self
.FileName
, self
.CurrentLineNumber
)
1742 self
.Profile
.PcdFileLineDict
[PcdPair
] = FileLineTuple
1743 BlockSize
= long(BlockSize
, 0)
1746 if self
.__IsKeyword
( "NumBlocks"):
1747 if not self
.__IsToken
( "="):
1748 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
1750 if not self
.__GetNextDecimalNumber
() and not self
.__GetNextHexNumber
():
1751 raise Warning("expected block numbers", self
.FileName
, self
.CurrentLineNumber
)
1753 BlockNumber
= long(self
.__Token
, 0)
1755 Obj
.BlockSizeList
.append((BlockSize
, BlockNumber
, BlockSizePcd
))
1758 ## __GetDefineStatements() method
1760 # Get define statements
1762 # @param self The object pointer
1763 # @param Obj for whom define statement is got
1764 # @retval True Successfully find
1765 # @retval False Not able to find
1767 def __GetDefineStatements(self
, Obj
):
1768 while self
.__GetDefineStatement
( Obj
):
1771 ## __GetDefineStatement() method
1773 # Get define statement
1775 # @param self The object pointer
1776 # @param Obj for whom define statement is got
1777 # @retval True Successfully find
1778 # @retval False Not able to find
1780 def __GetDefineStatement(self
, Obj
):
1781 if self
.__IsKeyword
("DEFINE"):
1782 self
.__GetNextToken
()
1783 Macro
= self
.__Token
1784 if not self
.__IsToken
( "="):
1785 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
1787 if not self
.__GetNextToken
():
1788 raise Warning("expected value", self
.FileName
, self
.CurrentLineNumber
)
1790 Value
= self
.__Token
1791 Macro
= '$(' + Macro
+ ')'
1792 Obj
.DefineVarDict
[Macro
] = Value
1797 ## __GetSetStatements() method
1799 # Get set statements
1801 # @param self The object pointer
1802 # @param Obj for whom set statement is got
1803 # @retval True Successfully find
1804 # @retval False Not able to find
1806 def __GetSetStatements(self
, Obj
):
1807 while self
.__GetSetStatement
(Obj
):
1810 ## __GetSetStatement() method
1814 # @param self The object pointer
1815 # @param Obj for whom set statement is got
1816 # @retval True Successfully find
1817 # @retval False Not able to find
1819 def __GetSetStatement(self
, Obj
):
1820 if self
.__IsKeyword
("SET"):
1821 PcdPair
= self
.__GetNextPcdName
()
1823 if not self
.__IsToken
( "="):
1824 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
1826 Value
= self
.__GetExpression
()
1827 Value
= self
.__EvaluateConditional
(Value
, self
.CurrentLineNumber
, 'eval', True)
1830 Obj
.SetVarDict
[PcdPair
] = Value
1831 self
.Profile
.PcdDict
[PcdPair
] = Value
1832 FileLineTuple
= GetRealFileLine(self
.FileName
, self
.CurrentLineNumber
)
1833 self
.Profile
.PcdFileLineDict
[PcdPair
] = FileLineTuple
1838 ## __CalcRegionExpr(self)
1840 # Calculate expression for offset or size of a region
1842 # @return: None if invalid expression
1843 # Calculated number if successfully
1845 def __CalcRegionExpr(self
):
1846 StartPos
= self
.GetFileBufferPos()
1849 while not self
.__EndOfFile
():
1850 CurCh
= self
.__CurrentChar
()
1856 if CurCh
in '|\r\n' and PairCount
== 0:
1862 ValueExpression(Expr
,
1863 self
.__CollectMacroPcd
()
1866 self
.SetFileBufferPos(StartPos
)
1869 ## __GetRegionLayout() method
1871 # Get region layout for FD
1873 # @param self The object pointer
1874 # @param Fd for whom region is got
1875 # @retval True Successfully find
1876 # @retval False Not able to find
1878 def __GetRegionLayout(self
, Fd
):
1879 Offset
= self
.__CalcRegionExpr
()
1883 RegionObj
= Region
.Region()
1884 RegionObj
.Offset
= Offset
1885 Fd
.RegionList
.append(RegionObj
)
1887 if not self
.__IsToken
( "|"):
1888 raise Warning("expected '|'", self
.FileName
, self
.CurrentLineNumber
)
1890 Size
= self
.__CalcRegionExpr
()
1892 raise Warning("expected Region Size", self
.FileName
, self
.CurrentLineNumber
)
1893 RegionObj
.Size
= Size
1895 if not self
.__GetNextWord
():
1898 if not self
.__Token
in ("SET", "FV", "FILE", "DATA", "CAPSULE", "INF"):
1900 # If next token is a word which is not a valid FV type, it might be part of [PcdOffset[|PcdSize]]
1901 # Or it might be next region's offset described by an expression which starts with a PCD.
1902 # PcdOffset[|PcdSize] or OffsetPcdExpression|Size
1905 IsRegionPcd
= (RegionSizeGuidPattern
.match(self
.__CurrentLine
()[self
.CurrentOffsetWithinLine
:]) or
1906 RegionOffsetPcdPattern
.match(self
.__CurrentLine
()[self
.CurrentOffsetWithinLine
:]))
1908 RegionObj
.PcdOffset
= self
.__GetNextPcdName
()
1909 self
.Profile
.PcdDict
[RegionObj
.PcdOffset
] = "0x%08X" % (RegionObj
.Offset
+ long(Fd
.BaseAddress
, 0))
1910 self
.__PcdDict
['%s.%s' % (RegionObj
.PcdOffset
[1], RegionObj
.PcdOffset
[0])] = "0x%x" % RegionObj
.Offset
1911 FileLineTuple
= GetRealFileLine(self
.FileName
, self
.CurrentLineNumber
)
1912 self
.Profile
.PcdFileLineDict
[RegionObj
.PcdOffset
] = FileLineTuple
1913 if self
.__IsToken
( "|"):
1914 RegionObj
.PcdSize
= self
.__GetNextPcdName
()
1915 self
.Profile
.PcdDict
[RegionObj
.PcdSize
] = "0x%08X" % RegionObj
.Size
1916 self
.__PcdDict
['%s.%s' % (RegionObj
.PcdSize
[1], RegionObj
.PcdSize
[0])] = "0x%x" % RegionObj
.Size
1917 FileLineTuple
= GetRealFileLine(self
.FileName
, self
.CurrentLineNumber
)
1918 self
.Profile
.PcdFileLineDict
[RegionObj
.PcdSize
] = FileLineTuple
1920 if not self
.__GetNextWord
():
1923 if self
.__Token
== "SET":
1925 self
.__GetSetStatements
( RegionObj
)
1926 if not self
.__GetNextWord
():
1929 elif self
.__Token
== "FV":
1931 self
.__GetRegionFvType
( RegionObj
)
1933 elif self
.__Token
== "CAPSULE":
1935 self
.__GetRegionCapType
( RegionObj
)
1937 elif self
.__Token
== "FILE":
1939 self
.__GetRegionFileType
(RegionObj
)
1941 elif self
.__Token
== "INF":
1943 RegionObj
.RegionType
= "INF"
1944 while self
.__IsKeyword
("INF"):
1946 ffsInf
= self
.__ParseInfStatement
()
1949 RegionObj
.RegionDataList
.append(ffsInf
)
1951 elif self
.__Token
== "DATA":
1953 self
.__GetRegionDataType
(RegionObj
)
1956 if self
.__GetRegionLayout
(Fd
):
1958 raise Warning("A valid region type was not found. "
1959 "Valid types are [SET, FV, CAPSULE, FILE, DATA, INF]. This error occurred",
1960 self
.FileName
, self
.CurrentLineNumber
)
1964 ## __GetRegionFvType() method
1966 # Get region fv data for region
1968 # @param self The object pointer
1969 # @param RegionObj for whom region data is got
1971 def __GetRegionFvType(self
, RegionObj
):
1973 if not self
.__IsKeyword
( "FV"):
1974 raise Warning("expected Keyword 'FV'", self
.FileName
, self
.CurrentLineNumber
)
1976 if not self
.__IsToken
( "="):
1977 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
1979 if not self
.__GetNextToken
():
1980 raise Warning("expected FV name", self
.FileName
, self
.CurrentLineNumber
)
1982 RegionObj
.RegionType
= "FV"
1983 RegionObj
.RegionDataList
.append((self
.__Token
).upper())
1985 while self
.__IsKeyword
( "FV"):
1987 if not self
.__IsToken
( "="):
1988 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
1990 if not self
.__GetNextToken
():
1991 raise Warning("expected FV name", self
.FileName
, self
.CurrentLineNumber
)
1993 RegionObj
.RegionDataList
.append((self
.__Token
).upper())
1995 ## __GetRegionCapType() method
1997 # Get region capsule data for region
1999 # @param self The object pointer
2000 # @param RegionObj for whom region data is got
2002 def __GetRegionCapType(self
, RegionObj
):
2004 if not self
.__IsKeyword
("CAPSULE"):
2005 raise Warning("expected Keyword 'CAPSULE'", self
.FileName
, self
.CurrentLineNumber
)
2007 if not self
.__IsToken
("="):
2008 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2010 if not self
.__GetNextToken
():
2011 raise Warning("expected CAPSULE name", self
.FileName
, self
.CurrentLineNumber
)
2013 RegionObj
.RegionType
= "CAPSULE"
2014 RegionObj
.RegionDataList
.append(self
.__Token
)
2016 while self
.__IsKeyword
("CAPSULE"):
2018 if not self
.__IsToken
("="):
2019 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2021 if not self
.__GetNextToken
():
2022 raise Warning("expected CAPSULE name", self
.FileName
, self
.CurrentLineNumber
)
2024 RegionObj
.RegionDataList
.append(self
.__Token
)
2026 ## __GetRegionFileType() method
2028 # Get region file data for region
2030 # @param self The object pointer
2031 # @param RegionObj for whom region data is got
2033 def __GetRegionFileType(self
, RegionObj
):
2035 if not self
.__IsKeyword
( "FILE"):
2036 raise Warning("expected Keyword 'FILE'", self
.FileName
, self
.CurrentLineNumber
)
2038 if not self
.__IsToken
( "="):
2039 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2041 if not self
.__GetNextToken
():
2042 raise Warning("expected File name", self
.FileName
, self
.CurrentLineNumber
)
2044 RegionObj
.RegionType
= "FILE"
2045 RegionObj
.RegionDataList
.append( self
.__Token
)
2047 while self
.__IsKeyword
( "FILE"):
2049 if not self
.__IsToken
( "="):
2050 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2052 if not self
.__GetNextToken
():
2053 raise Warning("expected FILE name", self
.FileName
, self
.CurrentLineNumber
)
2055 RegionObj
.RegionDataList
.append(self
.__Token
)
2057 ## __GetRegionDataType() method
2059 # Get region array data for region
2061 # @param self The object pointer
2062 # @param RegionObj for whom region data is got
2064 def __GetRegionDataType(self
, RegionObj
):
2066 if not self
.__IsKeyword
( "DATA"):
2067 raise Warning("expected Region Data type", self
.FileName
, self
.CurrentLineNumber
)
2069 if not self
.__IsToken
( "="):
2070 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2072 if not self
.__IsToken
( "{"):
2073 raise Warning("expected '{'", self
.FileName
, self
.CurrentLineNumber
)
2075 if not self
.__GetNextHexNumber
():
2076 raise Warning("expected Hex byte", self
.FileName
, self
.CurrentLineNumber
)
2078 if len(self
.__Token
) > 18:
2079 raise Warning("Hex string can't be converted to a valid UINT64 value", self
.FileName
, self
.CurrentLineNumber
)
2081 # convert hex string value to byte hex string array
2082 AllString
= self
.__Token
2083 AllStrLen
= len (AllString
)
2085 while AllStrLen
> 4:
2086 DataString
= DataString
+ "0x" + AllString
[AllStrLen
- 2: AllStrLen
] + ","
2087 AllStrLen
= AllStrLen
- 2
2088 DataString
= DataString
+ AllString
[:AllStrLen
] + ","
2091 if len (self
.__Token
) <= 4:
2092 while self
.__IsToken
(","):
2093 if not self
.__GetNextHexNumber
():
2094 raise Warning("Invalid Hex number", self
.FileName
, self
.CurrentLineNumber
)
2095 if len(self
.__Token
) > 4:
2096 raise Warning("Hex byte(must be 2 digits) too long", self
.FileName
, self
.CurrentLineNumber
)
2097 DataString
+= self
.__Token
2100 if not self
.__IsToken
( "}"):
2101 raise Warning("expected '}'", self
.FileName
, self
.CurrentLineNumber
)
2103 DataString
= DataString
.rstrip(",")
2104 RegionObj
.RegionType
= "DATA"
2105 RegionObj
.RegionDataList
.append( DataString
)
2107 while self
.__IsKeyword
( "DATA"):
2109 if not self
.__IsToken
( "="):
2110 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2112 if not self
.__IsToken
( "{"):
2113 raise Warning("expected '{'", self
.FileName
, self
.CurrentLineNumber
)
2115 if not self
.__GetNextHexNumber
():
2116 raise Warning("expected Hex byte", self
.FileName
, self
.CurrentLineNumber
)
2118 if len(self
.__Token
) > 18:
2119 raise Warning("Hex string can't be converted to a valid UINT64 value", self
.FileName
, self
.CurrentLineNumber
)
2121 # convert hex string value to byte hex string array
2122 AllString
= self
.__Token
2123 AllStrLen
= len (AllString
)
2125 while AllStrLen
> 4:
2126 DataString
= DataString
+ "0x" + AllString
[AllStrLen
- 2: AllStrLen
] + ","
2127 AllStrLen
= AllStrLen
- 2
2128 DataString
= DataString
+ AllString
[:AllStrLen
] + ","
2131 if len (self
.__Token
) <= 4:
2132 while self
.__IsToken
(","):
2133 if not self
.__GetNextHexNumber
():
2134 raise Warning("Invalid Hex number", self
.FileName
, self
.CurrentLineNumber
)
2135 if len(self
.__Token
) > 4:
2136 raise Warning("Hex byte(must be 2 digits) too long", self
.FileName
, self
.CurrentLineNumber
)
2137 DataString
+= self
.__Token
2140 if not self
.__IsToken
( "}"):
2141 raise Warning("expected '}'", self
.FileName
, self
.CurrentLineNumber
)
2143 DataString
= DataString
.rstrip(",")
2144 RegionObj
.RegionDataList
.append( DataString
)
2148 # Get FV section contents and store its data into FV dictionary of self.Profile
2150 # @param self The object pointer
2151 # @retval True Successfully find a FV
2152 # @retval False Not able to find a FV
2155 if not self
.__GetNextToken
():
2158 S
= self
.__Token
.upper()
2159 if S
.startswith("[") and not S
.startswith("[FV."):
2160 self
.SectionParser(S
)
2165 if not self
.__IsToken
("[FV.", True):
2166 FileLineTuple
= GetRealFileLine(self
.FileName
, self
.CurrentLineNumber
)
2167 #print 'Parsing String: %s in File %s, At line: %d, Offset Within Line: %d' \
2168 # % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine :], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine)
2169 raise Warning("Unknown Keyword '%s'" % self
.__Token
, self
.FileName
, self
.CurrentLineNumber
)
2171 FvName
= self
.__GetUiName
()
2172 self
.CurrentFvName
= FvName
.upper()
2174 if not self
.__IsToken
( "]"):
2175 raise Warning("expected ']'", self
.FileName
, self
.CurrentLineNumber
)
2178 FvObj
.UiFvName
= self
.CurrentFvName
2179 self
.Profile
.FvDict
[self
.CurrentFvName
] = FvObj
2181 Status
= self
.__GetCreateFile
(FvObj
)
2183 raise Warning("FV name error", self
.FileName
, self
.CurrentLineNumber
)
2185 self
.__GetDefineStatements
(FvObj
)
2187 self
.__GetAddressStatements
(FvObj
)
2189 FvObj
.FvExtEntryTypeValue
= []
2190 FvObj
.FvExtEntryType
= []
2191 FvObj
.FvExtEntryData
= []
2193 self
.__GetSetStatements
(FvObj
)
2195 if not (self
.__GetBlockStatement
(FvObj
) or self
.__GetFvBaseAddress
(FvObj
) or
2196 self
.__GetFvForceRebase
(FvObj
) or self
.__GetFvAlignment
(FvObj
) or
2197 self
.__GetFvAttributes
(FvObj
) or self
.__GetFvNameGuid
(FvObj
) or
2198 self
.__GetFvExtEntryStatement
(FvObj
) or self
.__GetFvNameString
(FvObj
)):
2201 if FvObj
.FvNameString
== 'TRUE' and not FvObj
.FvNameGuid
:
2202 raise Warning("FvNameString found but FvNameGuid was not found", self
.FileName
, self
.CurrentLineNumber
)
2204 self
.__GetAprioriSection
(FvObj
, FvObj
.DefineVarDict
.copy())
2205 self
.__GetAprioriSection
(FvObj
, FvObj
.DefineVarDict
.copy())
2208 isInf
= self
.__GetInfStatement
(FvObj
, MacroDict
= FvObj
.DefineVarDict
.copy())
2209 isFile
= self
.__GetFileStatement
(FvObj
, MacroDict
= FvObj
.DefineVarDict
.copy())
2210 if not isInf
and not isFile
:
2215 ## __GetFvAlignment() method
2217 # Get alignment for FV
2219 # @param self The object pointer
2220 # @param Obj for whom alignment is got
2221 # @retval True Successfully find a alignment statement
2222 # @retval False Not able to find a alignment statement
2224 def __GetFvAlignment(self
, Obj
):
2226 if not self
.__IsKeyword
( "FvAlignment"):
2229 if not self
.__IsToken
( "="):
2230 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2232 if not self
.__GetNextToken
():
2233 raise Warning("expected alignment value", self
.FileName
, self
.CurrentLineNumber
)
2235 if self
.__Token
.upper() not in ("1", "2", "4", "8", "16", "32", "64", "128", "256", "512", \
2236 "1K", "2K", "4K", "8K", "16K", "32K", "64K", "128K", "256K", "512K", \
2237 "1M", "2M", "4M", "8M", "16M", "32M", "64M", "128M", "256M", "512M", \
2239 raise Warning("Unknown alignment value '%s'" % self
.__Token
, self
.FileName
, self
.CurrentLineNumber
)
2240 Obj
.FvAlignment
= self
.__Token
2243 ## __GetFvBaseAddress() method
2245 # Get BaseAddress for FV
2247 # @param self The object pointer
2248 # @param Obj for whom FvBaseAddress is got
2249 # @retval True Successfully find a FvBaseAddress statement
2250 # @retval False Not able to find a FvBaseAddress statement
2252 def __GetFvBaseAddress(self
, Obj
):
2254 if not self
.__IsKeyword
("FvBaseAddress"):
2257 if not self
.__IsToken
( "="):
2258 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2260 if not self
.__GetNextToken
():
2261 raise Warning("expected FV base address value", self
.FileName
, self
.CurrentLineNumber
)
2263 IsValidBaseAddrValue
= re
.compile('^0[x|X][0-9a-fA-F]+')
2265 if not IsValidBaseAddrValue
.match(self
.__Token
.upper()):
2266 raise Warning("Unknown FV base address value '%s'" % self
.__Token
, self
.FileName
, self
.CurrentLineNumber
)
2267 Obj
.FvBaseAddress
= self
.__Token
2270 ## __GetFvForceRebase() method
2272 # Get FvForceRebase for FV
2274 # @param self The object pointer
2275 # @param Obj for whom FvForceRebase is got
2276 # @retval True Successfully find a FvForceRebase statement
2277 # @retval False Not able to find a FvForceRebase statement
2279 def __GetFvForceRebase(self
, Obj
):
2281 if not self
.__IsKeyword
("FvForceRebase"):
2284 if not self
.__IsToken
( "="):
2285 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2287 if not self
.__GetNextToken
():
2288 raise Warning("expected FvForceRebase value", self
.FileName
, self
.CurrentLineNumber
)
2290 if self
.__Token
.upper() not in ["TRUE", "FALSE", "0", "0X0", "0X00", "1", "0X1", "0X01"]:
2291 raise Warning("Unknown FvForceRebase value '%s'" % self
.__Token
, self
.FileName
, self
.CurrentLineNumber
)
2293 if self
.__Token
.upper() in ["TRUE", "1", "0X1", "0X01"]:
2294 Obj
.FvForceRebase
= True
2295 elif self
.__Token
.upper() in ["FALSE", "0", "0X0", "0X00"]:
2296 Obj
.FvForceRebase
= False
2298 Obj
.FvForceRebase
= None
2303 ## __GetFvAttributes() method
2305 # Get attributes for FV
2307 # @param self The object pointer
2308 # @param Obj for whom attribute is got
2311 def __GetFvAttributes(self
, FvObj
):
2313 while self
.__GetNextWord
():
2316 if name
not in ("ERASE_POLARITY", "MEMORY_MAPPED", \
2317 "STICKY_WRITE", "LOCK_CAP", "LOCK_STATUS", "WRITE_ENABLED_CAP", \
2318 "WRITE_DISABLED_CAP", "WRITE_STATUS", "READ_ENABLED_CAP", \
2319 "READ_DISABLED_CAP", "READ_STATUS", "READ_LOCK_CAP", \
2320 "READ_LOCK_STATUS", "WRITE_LOCK_CAP", "WRITE_LOCK_STATUS", \
2321 "WRITE_POLICY_RELIABLE", "WEAK_ALIGNMENT", "FvUsedSizeEnable"):
2325 if not self
.__IsToken
( "="):
2326 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2328 if not self
.__GetNextToken
() or self
.__Token
.upper() not in ("TRUE", "FALSE", "1", "0"):
2329 raise Warning("expected TRUE/FALSE (1/0)", self
.FileName
, self
.CurrentLineNumber
)
2331 FvObj
.FvAttributeDict
[name
] = self
.__Token
2335 ## __GetFvNameGuid() method
2337 # Get FV GUID for FV
2339 # @param self The object pointer
2340 # @param Obj for whom GUID is got
2343 def __GetFvNameGuid(self
, FvObj
):
2345 if not self
.__IsKeyword
( "FvNameGuid"):
2348 if not self
.__IsToken
( "="):
2349 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2351 if not self
.__GetNextGuid
():
2352 raise Warning("expected FV GUID value", self
.FileName
, self
.CurrentLineNumber
)
2354 FvObj
.FvNameGuid
= self
.__Token
2358 def __GetFvNameString(self
, FvObj
):
2360 if not self
.__IsKeyword
( "FvNameString"):
2363 if not self
.__IsToken
( "="):
2364 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2366 if not self
.__GetNextToken
() or self
.__Token
not in ('TRUE', 'FALSE'):
2367 raise Warning("expected TRUE or FALSE for FvNameString", self
.FileName
, self
.CurrentLineNumber
)
2369 FvObj
.FvNameString
= self
.__Token
2373 def __GetFvExtEntryStatement(self
, FvObj
):
2375 if not (self
.__IsKeyword
( "FV_EXT_ENTRY") or self
.__IsKeyword
( "FV_EXT_ENTRY_TYPE")):
2378 if not self
.__IsKeyword
("TYPE"):
2379 raise Warning("expected 'TYPE'", self
.FileName
, self
.CurrentLineNumber
)
2381 if not self
.__IsToken
( "="):
2382 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2384 if not self
.__GetNextHexNumber
() and not self
.__GetNextDecimalNumber
():
2385 raise Warning("expected Hex FV extension entry type value At Line ", self
.FileName
, self
.CurrentLineNumber
)
2387 FvObj
.FvExtEntryTypeValue
+= [self
.__Token
]
2389 if not self
.__IsToken
( "{"):
2390 raise Warning("expected '{'", self
.FileName
, self
.CurrentLineNumber
)
2392 if not self
.__IsKeyword
("FILE") and not self
.__IsKeyword
("DATA"):
2393 raise Warning("expected 'FILE' or 'DATA'", self
.FileName
, self
.CurrentLineNumber
)
2395 FvObj
.FvExtEntryType
+= [self
.__Token
]
2397 if self
.__Token
== 'DATA':
2399 if not self
.__IsToken
( "="):
2400 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2402 if not self
.__IsToken
( "{"):
2403 raise Warning("expected '{'", self
.FileName
, self
.CurrentLineNumber
)
2405 if not self
.__GetNextHexNumber
():
2406 raise Warning("expected Hex byte", self
.FileName
, self
.CurrentLineNumber
)
2408 if len(self
.__Token
) > 4:
2409 raise Warning("Hex byte(must be 2 digits) too long", self
.FileName
, self
.CurrentLineNumber
)
2411 DataString
= self
.__Token
2414 while self
.__IsToken
(","):
2415 if not self
.__GetNextHexNumber
():
2416 raise Warning("Invalid Hex number", self
.FileName
, self
.CurrentLineNumber
)
2417 if len(self
.__Token
) > 4:
2418 raise Warning("Hex byte(must be 2 digits) too long", self
.FileName
, self
.CurrentLineNumber
)
2419 DataString
+= self
.__Token
2422 if not self
.__IsToken
( "}"):
2423 raise Warning("expected '}'", self
.FileName
, self
.CurrentLineNumber
)
2425 if not self
.__IsToken
( "}"):
2426 raise Warning("expected '}'", self
.FileName
, self
.CurrentLineNumber
)
2428 DataString
= DataString
.rstrip(",")
2429 FvObj
.FvExtEntryData
+= [DataString
]
2431 if self
.__Token
== 'FILE':
2433 if not self
.__IsToken
( "="):
2434 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2436 if not self
.__GetNextToken
():
2437 raise Warning("expected FV Extension Entry file path At Line ", self
.FileName
, self
.CurrentLineNumber
)
2439 FvObj
.FvExtEntryData
+= [self
.__Token
]
2441 if not self
.__IsToken
( "}"):
2442 raise Warning("expected '}'", self
.FileName
, self
.CurrentLineNumber
)
2446 ## __GetAprioriSection() method
2448 # Get token statements
2450 # @param self The object pointer
2451 # @param FvObj for whom apriori is got
2452 # @param MacroDict dictionary used to replace macro
2453 # @retval True Successfully find apriori statement
2454 # @retval False Not able to find apriori statement
2456 def __GetAprioriSection(self
, FvObj
, MacroDict
= {}):
2458 if not self
.__IsKeyword
( "APRIORI"):
2461 if not self
.__IsKeyword
("PEI") and not self
.__IsKeyword
("DXE"):
2462 raise Warning("expected Apriori file type", self
.FileName
, self
.CurrentLineNumber
)
2463 AprType
= self
.__Token
2465 if not self
.__IsToken
( "{"):
2466 raise Warning("expected '{'", self
.FileName
, self
.CurrentLineNumber
)
2468 AprSectionObj
= AprioriSection
.AprioriSection()
2469 AprSectionObj
.AprioriType
= AprType
2471 self
.__GetDefineStatements
(AprSectionObj
)
2472 MacroDict
.update(AprSectionObj
.DefineVarDict
)
2475 IsInf
= self
.__GetInfStatement
( AprSectionObj
, MacroDict
= MacroDict
)
2476 IsFile
= self
.__GetFileStatement
( AprSectionObj
)
2477 if not IsInf
and not IsFile
:
2480 if not self
.__IsToken
( "}"):
2481 raise Warning("expected '}'", self
.FileName
, self
.CurrentLineNumber
)
2483 FvObj
.AprioriSectionList
.append(AprSectionObj
)
2486 def __ParseInfStatement(self
):
2487 if not self
.__IsKeyword
("INF"):
2490 ffsInf
= FfsInfStatement
.FfsInfStatement()
2491 self
.__GetInfOptions
(ffsInf
)
2493 if not self
.__GetNextToken
():
2494 raise Warning("expected INF file path", self
.FileName
, self
.CurrentLineNumber
)
2495 ffsInf
.InfFileName
= self
.__Token
2496 if not ffsInf
.InfFileName
.endswith('.inf'):
2497 raise Warning("expected .inf file path", self
.FileName
, self
.CurrentLineNumber
)
2499 ffsInf
.CurrentLineNum
= self
.CurrentLineNumber
2500 ffsInf
.CurrentLineContent
= self
.__CurrentLine
()
2502 #Replace $(SAPCE) with real space
2503 ffsInf
.InfFileName
= ffsInf
.InfFileName
.replace('$(SPACE)', ' ')
2505 if ffsInf
.InfFileName
.replace('$(WORKSPACE)', '').find('$') == -1:
2506 #do case sensitive check for file path
2507 ErrorCode
, ErrorInfo
= PathClass(NormPath(ffsInf
.InfFileName
), GenFdsGlobalVariable
.WorkSpaceDir
).Validate()
2509 EdkLogger
.error("GenFds", ErrorCode
, ExtraData
=ErrorInfo
)
2511 if not ffsInf
.InfFileName
in self
.Profile
.InfList
:
2512 self
.Profile
.InfList
.append(ffsInf
.InfFileName
)
2513 FileLineTuple
= GetRealFileLine(self
.FileName
, self
.CurrentLineNumber
)
2514 self
.Profile
.InfFileLineList
.append(FileLineTuple
)
2516 if ffsInf
.UseArch
not in self
.Profile
.InfDict
:
2517 self
.Profile
.InfDict
[ffsInf
.UseArch
] = [ffsInf
.InfFileName
]
2519 self
.Profile
.InfDict
[ffsInf
.UseArch
].append(ffsInf
.InfFileName
)
2521 self
.Profile
.InfDict
['ArchTBD'].append(ffsInf
.InfFileName
)
2523 if self
.__IsToken
('|'):
2524 if self
.__IsKeyword
('RELOCS_STRIPPED'):
2525 ffsInf
.KeepReloc
= False
2526 elif self
.__IsKeyword
('RELOCS_RETAINED'):
2527 ffsInf
.KeepReloc
= True
2529 raise Warning("Unknown reloc strip flag '%s'" % self
.__Token
, self
.FileName
, self
.CurrentLineNumber
)
2532 ## __GetInfStatement() method
2534 # Get INF statements
2536 # @param self The object pointer
2537 # @param Obj for whom inf statement is got
2538 # @param MacroDict dictionary used to replace macro
2539 # @retval True Successfully find inf statement
2540 # @retval False Not able to find inf statement
2542 def __GetInfStatement(self
, Obj
, ForCapsule
=False, MacroDict
={}):
2543 ffsInf
= self
.__ParseInfStatement
()
2548 capsuleFfs
= CapsuleData
.CapsuleFfs()
2549 capsuleFfs
.Ffs
= ffsInf
2550 Obj
.CapsuleDataList
.append(capsuleFfs
)
2552 Obj
.FfsList
.append(ffsInf
)
2555 ## __GetInfOptions() method
2557 # Get options for INF
2559 # @param self The object pointer
2560 # @param FfsInfObj for whom option is got
2562 def __GetInfOptions(self
, FfsInfObj
):
2563 if self
.__IsKeyword
("FILE_GUID"):
2564 if not self
.__IsToken
("="):
2565 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2566 if not self
.__GetNextGuid
():
2567 raise Warning("expected GUID value", self
.FileName
, self
.CurrentLineNumber
)
2568 FfsInfObj
.OverrideGuid
= self
.__Token
2570 if self
.__IsKeyword
( "RuleOverride"):
2571 if not self
.__IsToken
( "="):
2572 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2573 if not self
.__GetNextToken
():
2574 raise Warning("expected Rule name", self
.FileName
, self
.CurrentLineNumber
)
2575 FfsInfObj
.Rule
= self
.__Token
2577 if self
.__IsKeyword
( "VERSION"):
2578 if not self
.__IsToken
( "="):
2579 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2580 if not self
.__GetNextToken
():
2581 raise Warning("expected Version", self
.FileName
, self
.CurrentLineNumber
)
2583 if self
.__GetStringData
():
2584 FfsInfObj
.Version
= self
.__Token
2586 if self
.__IsKeyword
( "UI"):
2587 if not self
.__IsToken
( "="):
2588 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2589 if not self
.__GetNextToken
():
2590 raise Warning("expected UI name", self
.FileName
, self
.CurrentLineNumber
)
2592 if self
.__GetStringData
():
2593 FfsInfObj
.Ui
= self
.__Token
2595 if self
.__IsKeyword
( "USE"):
2596 if not self
.__IsToken
( "="):
2597 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2598 if not self
.__GetNextToken
():
2599 raise Warning("expected ARCH name", self
.FileName
, self
.CurrentLineNumber
)
2600 FfsInfObj
.UseArch
= self
.__Token
2603 if self
.__GetNextToken
():
2604 p
= re
.compile(r
'([a-zA-Z0-9\-]+|\$\(TARGET\)|\*)_([a-zA-Z0-9\-]+|\$\(TOOL_CHAIN_TAG\)|\*)_([a-zA-Z0-9\-]+|\$\(ARCH\))')
2605 if p
.match(self
.__Token
) and p
.match(self
.__Token
).span()[1] == len(self
.__Token
):
2606 FfsInfObj
.KeyStringList
.append(self
.__Token
)
2607 if not self
.__IsToken
(","):
2613 while self
.__GetNextToken
():
2614 if not p
.match(self
.__Token
):
2615 raise Warning("expected KeyString \"Target_Tag_Arch\"", self
.FileName
, self
.CurrentLineNumber
)
2616 FfsInfObj
.KeyStringList
.append(self
.__Token
)
2618 if not self
.__IsToken
(","):
2621 ## __GetFileStatement() method
2623 # Get FILE statements
2625 # @param self The object pointer
2626 # @param Obj for whom FILE statement is got
2627 # @param MacroDict dictionary used to replace macro
2628 # @retval True Successfully find FILE statement
2629 # @retval False Not able to find FILE statement
2631 def __GetFileStatement(self
, Obj
, ForCapsule
= False, MacroDict
= {}):
2633 if not self
.__IsKeyword
( "FILE"):
2636 if not self
.__GetNextWord
():
2637 raise Warning("expected FFS type", self
.FileName
, self
.CurrentLineNumber
)
2639 if ForCapsule
and self
.__Token
== 'DATA':
2644 FfsFileObj
= FfsFileStatement
.FileStatement()
2645 FfsFileObj
.FvFileType
= self
.__Token
2647 if not self
.__IsToken
( "="):
2648 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2650 if not self
.__GetNextGuid
():
2651 if not self
.__GetNextWord
():
2652 raise Warning("expected File GUID", self
.FileName
, self
.CurrentLineNumber
)
2653 if self
.__Token
== 'PCD':
2654 if not self
.__IsToken
( "("):
2655 raise Warning("expected '('", self
.FileName
, self
.CurrentLineNumber
)
2656 PcdPair
= self
.__GetNextPcdName
()
2657 if not self
.__IsToken
( ")"):
2658 raise Warning("expected ')'", self
.FileName
, self
.CurrentLineNumber
)
2659 self
.__Token
= 'PCD('+PcdPair
[1]+'.'+PcdPair
[0]+')'
2661 FfsFileObj
.NameGuid
= self
.__Token
2663 self
.__GetFilePart
( FfsFileObj
, MacroDict
.copy())
2666 capsuleFfs
= CapsuleData
.CapsuleFfs()
2667 capsuleFfs
.Ffs
= FfsFileObj
2668 Obj
.CapsuleDataList
.append(capsuleFfs
)
2670 Obj
.FfsList
.append(FfsFileObj
)
2674 ## __FileCouldHaveRelocFlag() method
2676 # Check whether reloc strip flag can be set for a file type.
2678 # @param self The object pointer
2679 # @param FileType The file type to check with
2680 # @retval True This type could have relocation strip flag
2681 # @retval False No way to have it
2684 def __FileCouldHaveRelocFlag (self
, FileType
):
2685 if FileType
in ('SEC', 'PEI_CORE', 'PEIM', 'PEI_DXE_COMBO'):
2690 ## __SectionCouldHaveRelocFlag() method
2692 # Check whether reloc strip flag can be set for a section type.
2694 # @param self The object pointer
2695 # @param SectionType The section type to check with
2696 # @retval True This type could have relocation strip flag
2697 # @retval False No way to have it
2700 def __SectionCouldHaveRelocFlag (self
, SectionType
):
2701 if SectionType
in ('TE', 'PE32'):
2706 ## __GetFilePart() method
2708 # Get components for FILE statement
2710 # @param self The object pointer
2711 # @param FfsFileObj for whom component is got
2712 # @param MacroDict dictionary used to replace macro
2714 def __GetFilePart(self
, FfsFileObj
, MacroDict
= {}):
2716 self
.__GetFileOpts
( FfsFileObj
)
2718 if not self
.__IsToken
("{"):
2719 if self
.__IsKeyword
('RELOCS_STRIPPED') or self
.__IsKeyword
('RELOCS_RETAINED'):
2720 if self
.__FileCouldHaveRelocFlag
(FfsFileObj
.FvFileType
):
2721 if self
.__Token
== 'RELOCS_STRIPPED':
2722 FfsFileObj
.KeepReloc
= False
2724 FfsFileObj
.KeepReloc
= True
2726 raise Warning("File type %s could not have reloc strip flag%d" % (FfsFileObj
.FvFileType
, self
.CurrentLineNumber
), self
.FileName
, self
.CurrentLineNumber
)
2728 if not self
.__IsToken
("{"):
2729 raise Warning("expected '{'", self
.FileName
, self
.CurrentLineNumber
)
2731 if not self
.__GetNextToken
():
2732 raise Warning("expected File name or section data", self
.FileName
, self
.CurrentLineNumber
)
2734 if self
.__Token
== "FV":
2735 if not self
.__IsToken
( "="):
2736 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2737 if not self
.__GetNextToken
():
2738 raise Warning("expected FV name", self
.FileName
, self
.CurrentLineNumber
)
2739 FfsFileObj
.FvName
= self
.__Token
2741 elif self
.__Token
== "FD":
2742 if not self
.__IsToken
( "="):
2743 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2744 if not self
.__GetNextToken
():
2745 raise Warning("expected FD name", self
.FileName
, self
.CurrentLineNumber
)
2746 FfsFileObj
.FdName
= self
.__Token
2748 elif self
.__Token
in ("DEFINE", "APRIORI", "SECTION"):
2750 self
.__GetSectionData
( FfsFileObj
, MacroDict
)
2752 elif hasattr(FfsFileObj
, 'FvFileType') and FfsFileObj
.FvFileType
== 'RAW':
2754 self
.__GetRAWData
(FfsFileObj
, MacroDict
)
2757 FfsFileObj
.CurrentLineNum
= self
.CurrentLineNumber
2758 FfsFileObj
.CurrentLineContent
= self
.__CurrentLine
()
2759 FfsFileObj
.FileName
= self
.__Token
.replace('$(SPACE)', ' ')
2760 self
.__VerifyFile
(FfsFileObj
.FileName
)
2762 if not self
.__IsToken
( "}"):
2763 raise Warning("expected '}'", self
.FileName
, self
.CurrentLineNumber
)
2765 ## __GetRAWData() method
2767 # Get RAW data for FILE statement
2769 # @param self The object pointer
2770 # @param FfsFileObj for whom section is got
2771 # @param MacroDict dictionary used to replace macro
2773 def __GetRAWData(self
, FfsFileObj
, MacroDict
= {}):
2774 FfsFileObj
.FileName
= []
2775 FfsFileObj
.SubAlignment
= []
2778 if self
.__GetAlignment
():
2779 if self
.__Token
not in ("Auto", "8", "16", "32", "64", "128", "512", "1K", "4K", "32K" ,"64K", "128K",
2780 "256K", "512K", "1M", "2M", "4M", "8M", "16M"):
2781 raise Warning("Incorrect alignment '%s'" % self
.__Token
, self
.FileName
, self
.CurrentLineNumber
)
2782 #For FFS, Auto is default option same to ""
2783 if not self
.__Token
== "Auto":
2784 AlignValue
= self
.__Token
2785 if not self
.__GetNextToken
():
2786 raise Warning("expected Filename value", self
.FileName
, self
.CurrentLineNumber
)
2788 FileName
= self
.__Token
.replace('$(SPACE)', ' ')
2791 raise Warning("expected Filename value", self
.FileName
, self
.CurrentLineNumber
)
2793 self
.__VerifyFile
(FileName
)
2794 File
= PathClass(NormPath(FileName
), GenFdsGlobalVariable
.WorkSpaceDir
)
2795 FfsFileObj
.FileName
.append(File
.Path
)
2796 FfsFileObj
.SubAlignment
.append(AlignValue
)
2798 if self
.__IsToken
( "}"):
2802 if len(FfsFileObj
.SubAlignment
) == 1:
2803 FfsFileObj
.SubAlignment
= FfsFileObj
.SubAlignment
[0]
2804 if len(FfsFileObj
.FileName
) == 1:
2805 FfsFileObj
.FileName
= FfsFileObj
.FileName
[0]
2807 ## __GetFileOpts() method
2809 # Get options for FILE statement
2811 # @param self The object pointer
2812 # @param FfsFileObj for whom options is got
2814 def __GetFileOpts(self
, FfsFileObj
):
2816 if self
.__GetNextToken
():
2817 Pattern
= re
.compile(r
'([a-zA-Z0-9\-]+|\$\(TARGET\)|\*)_([a-zA-Z0-9\-]+|\$\(TOOL_CHAIN_TAG\)|\*)_([a-zA-Z0-9\-]+|\$\(ARCH\)|\*)')
2818 if Pattern
.match(self
.__Token
):
2819 FfsFileObj
.KeyStringList
.append(self
.__Token
)
2820 if self
.__IsToken
(","):
2821 while self
.__GetNextToken
():
2822 if not Pattern
.match(self
.__Token
):
2823 raise Warning("expected KeyString \"Target_Tag_Arch\"", self
.FileName
, self
.CurrentLineNumber
)
2824 FfsFileObj
.KeyStringList
.append(self
.__Token
)
2826 if not self
.__IsToken
(","):
2832 if self
.__IsKeyword
( "FIXED", True):
2833 FfsFileObj
.Fixed
= True
2835 if self
.__IsKeyword
( "CHECKSUM", True):
2836 FfsFileObj
.CheckSum
= True
2838 if self
.__GetAlignment
():
2839 if self
.__Token
not in ("Auto", "8", "16", "32", "64", "128", "512", "1K", "4K", "32K" ,"64K", "128K",
2840 "256K", "512K", "1M", "2M", "4M", "8M", "16M"):
2841 raise Warning("Incorrect alignment '%s'" % self
.__Token
, self
.FileName
, self
.CurrentLineNumber
)
2842 #For FFS, Auto is default option same to ""
2843 if not self
.__Token
== "Auto":
2844 FfsFileObj
.Alignment
= self
.__Token
2846 ## __GetAlignment() method
2848 # Return the alignment value
2850 # @param self The object pointer
2851 # @retval True Successfully find alignment
2852 # @retval False Not able to find alignment
2854 def __GetAlignment(self
):
2855 if self
.__IsKeyword
( "Align", True):
2856 if not self
.__IsToken
( "="):
2857 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2859 if not self
.__GetNextToken
():
2860 raise Warning("expected alignment value", self
.FileName
, self
.CurrentLineNumber
)
2865 ## __GetFilePart() method
2867 # Get section data for FILE statement
2869 # @param self The object pointer
2870 # @param FfsFileObj for whom section is got
2871 # @param MacroDict dictionary used to replace macro
2873 def __GetSectionData(self
, FfsFileObj
, MacroDict
= {}):
2875 Dict
.update(MacroDict
)
2877 self
.__GetDefineStatements
(FfsFileObj
)
2879 Dict
.update(FfsFileObj
.DefineVarDict
)
2880 self
.__GetAprioriSection
(FfsFileObj
, Dict
.copy())
2881 self
.__GetAprioriSection
(FfsFileObj
, Dict
.copy())
2884 IsLeafSection
= self
.__GetLeafSection
(FfsFileObj
, Dict
)
2885 IsEncapSection
= self
.__GetEncapsulationSec
(FfsFileObj
)
2886 if not IsLeafSection
and not IsEncapSection
:
2889 ## __GetLeafSection() method
2891 # Get leaf section for Obj
2893 # @param self The object pointer
2894 # @param Obj for whom leaf section is got
2895 # @param MacroDict dictionary used to replace macro
2896 # @retval True Successfully find section statement
2897 # @retval False Not able to find section statement
2899 def __GetLeafSection(self
, Obj
, MacroDict
= {}):
2901 OldPos
= self
.GetFileBufferPos()
2903 if not self
.__IsKeyword
( "SECTION"):
2904 if len(Obj
.SectionList
) == 0:
2905 raise Warning("expected SECTION", self
.FileName
, self
.CurrentLineNumber
)
2910 if self
.__GetAlignment
():
2911 if self
.__Token
not in ("Auto", "8", "16", "32", "64", "128", "512", "1K", "4K", "32K" ,"64K", "128K",
2912 "256K", "512K", "1M", "2M", "4M", "8M", "16M"):
2913 raise Warning("Incorrect alignment '%s'" % self
.__Token
, self
.FileName
, self
.CurrentLineNumber
)
2914 AlignValue
= self
.__Token
2917 if self
.__IsKeyword
( "BUILD_NUM"):
2918 if not self
.__IsToken
( "="):
2919 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2921 if not self
.__GetNextToken
():
2922 raise Warning("expected Build number value", self
.FileName
, self
.CurrentLineNumber
)
2924 BuildNum
= self
.__Token
2926 if self
.__IsKeyword
( "VERSION"):
2927 if AlignValue
== 'Auto':
2928 raise Warning("Auto alignment can only be used in PE32 or TE section ", self
.FileName
, self
.CurrentLineNumber
)
2929 if not self
.__IsToken
( "="):
2930 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2931 if not self
.__GetNextToken
():
2932 raise Warning("expected version", self
.FileName
, self
.CurrentLineNumber
)
2933 VerSectionObj
= VerSection
.VerSection()
2934 VerSectionObj
.Alignment
= AlignValue
2935 VerSectionObj
.BuildNum
= BuildNum
2936 if self
.__GetStringData
():
2937 VerSectionObj
.StringData
= self
.__Token
2939 VerSectionObj
.FileName
= self
.__Token
2940 Obj
.SectionList
.append(VerSectionObj
)
2942 elif self
.__IsKeyword
( "UI"):
2943 if AlignValue
== 'Auto':
2944 raise Warning("Auto alignment can only be used in PE32 or TE section ", self
.FileName
, self
.CurrentLineNumber
)
2945 if not self
.__IsToken
( "="):
2946 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2947 if not self
.__GetNextToken
():
2948 raise Warning("expected UI", self
.FileName
, self
.CurrentLineNumber
)
2949 UiSectionObj
= UiSection
.UiSection()
2950 UiSectionObj
.Alignment
= AlignValue
2951 if self
.__GetStringData
():
2952 UiSectionObj
.StringData
= self
.__Token
2954 UiSectionObj
.FileName
= self
.__Token
2955 Obj
.SectionList
.append(UiSectionObj
)
2957 elif self
.__IsKeyword
( "FV_IMAGE"):
2958 if AlignValue
== 'Auto':
2959 raise Warning("Auto alignment can only be used in PE32 or TE section ", self
.FileName
, self
.CurrentLineNumber
)
2960 if not self
.__IsToken
( "="):
2961 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2962 if not self
.__GetNextToken
():
2963 raise Warning("expected FV name or FV file path", self
.FileName
, self
.CurrentLineNumber
)
2965 FvName
= self
.__Token
2968 if self
.__IsToken
( "{"):
2970 FvObj
.UiFvName
= FvName
.upper()
2971 self
.__GetDefineStatements
(FvObj
)
2972 MacroDict
.update(FvObj
.DefineVarDict
)
2973 self
.__GetBlockStatement
(FvObj
)
2974 self
.__GetSetStatements
(FvObj
)
2975 self
.__GetFvAlignment
(FvObj
)
2976 self
.__GetFvAttributes
(FvObj
)
2977 self
.__GetAprioriSection
(FvObj
, MacroDict
.copy())
2978 self
.__GetAprioriSection
(FvObj
, MacroDict
.copy())
2981 IsInf
= self
.__GetInfStatement
(FvObj
, MacroDict
.copy())
2982 IsFile
= self
.__GetFileStatement
(FvObj
, MacroDict
.copy())
2983 if not IsInf
and not IsFile
:
2986 if not self
.__IsToken
( "}"):
2987 raise Warning("expected '}'", self
.FileName
, self
.CurrentLineNumber
)
2989 FvImageSectionObj
= FvImageSection
.FvImageSection()
2990 FvImageSectionObj
.Alignment
= AlignValue
2992 FvImageSectionObj
.Fv
= FvObj
2993 FvImageSectionObj
.FvName
= None
2995 FvImageSectionObj
.FvName
= FvName
.upper()
2996 FvImageSectionObj
.FvFileName
= FvName
2998 Obj
.SectionList
.append(FvImageSectionObj
)
3000 elif self
.__IsKeyword
("PEI_DEPEX_EXP") or self
.__IsKeyword
("DXE_DEPEX_EXP") or self
.__IsKeyword
("SMM_DEPEX_EXP"):
3001 if AlignValue
== 'Auto':
3002 raise Warning("Auto alignment can only be used in PE32 or TE section ", self
.FileName
, self
.CurrentLineNumber
)
3003 DepexSectionObj
= DepexSection
.DepexSection()
3004 DepexSectionObj
.Alignment
= AlignValue
3005 DepexSectionObj
.DepexType
= self
.__Token
3007 if not self
.__IsToken
( "="):
3008 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
3009 if not self
.__IsToken
( "{"):
3010 raise Warning("expected '{'", self
.FileName
, self
.CurrentLineNumber
)
3011 if not self
.__SkipToToken
( "}"):
3012 raise Warning("expected Depex expression ending '}'", self
.FileName
, self
.CurrentLineNumber
)
3014 DepexSectionObj
.Expression
= self
.__SkippedChars
.rstrip('}')
3015 Obj
.SectionList
.append(DepexSectionObj
)
3018 if not self
.__GetNextWord
():
3019 raise Warning("expected section type", self
.FileName
, self
.CurrentLineNumber
)
3021 # Encapsulation section appear, UndoToken and return
3022 if self
.__Token
== "COMPRESS" or self
.__Token
== "GUIDED":
3023 self
.SetFileBufferPos(OldPos
)
3026 if self
.__Token
not in ("COMPAT16", "PE32", "PIC", "TE", "FV_IMAGE", "RAW", "DXE_DEPEX",\
3027 "UI", "VERSION", "PEI_DEPEX", "SUBTYPE_GUID", "SMM_DEPEX"):
3028 raise Warning("Unknown section type '%s'" % self
.__Token
, self
.FileName
, self
.CurrentLineNumber
)
3029 if AlignValue
== 'Auto'and (not self
.__Token
== 'PE32') and (not self
.__Token
== 'TE'):
3030 raise Warning("Auto alignment can only be used in PE32 or TE section ", self
.FileName
, self
.CurrentLineNumber
)
3033 DataSectionObj
= DataSection
.DataSection()
3034 DataSectionObj
.Alignment
= AlignValue
3035 DataSectionObj
.SecType
= self
.__Token
3037 if self
.__IsKeyword
('RELOCS_STRIPPED') or self
.__IsKeyword
('RELOCS_RETAINED'):
3038 if self
.__FileCouldHaveRelocFlag
(Obj
.FvFileType
) and self
.__SectionCouldHaveRelocFlag
(DataSectionObj
.SecType
):
3039 if self
.__Token
== 'RELOCS_STRIPPED':
3040 DataSectionObj
.KeepReloc
= False
3042 DataSectionObj
.KeepReloc
= True
3044 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
)
3046 if self
.__IsToken
("="):
3047 if not self
.__GetNextToken
():
3048 raise Warning("expected section file path", self
.FileName
, self
.CurrentLineNumber
)
3049 DataSectionObj
.SectFileName
= self
.__Token
3050 self
.__VerifyFile
(DataSectionObj
.SectFileName
)
3052 if not self
.__GetCglSection
(DataSectionObj
):
3055 Obj
.SectionList
.append(DataSectionObj
)
3061 # Check if file exists or not:
3062 # If current phase if GenFds, the file must exist;
3063 # If current phase is AutoGen and the file is not in $(OUTPUT_DIRECTORY), the file must exist
3064 # @param FileName: File path to be verified.
3066 def __VerifyFile(self
, FileName
):
3067 if FileName
.replace('$(WORKSPACE)', '').find('$') != -1:
3069 if not GlobalData
.gAutoGenPhase
or not self
.__GetMacroValue
("OUTPUT_DIRECTORY") in FileName
:
3070 ErrorCode
, ErrorInfo
= PathClass(NormPath(FileName
), GenFdsGlobalVariable
.WorkSpaceDir
).Validate()
3072 EdkLogger
.error("GenFds", ErrorCode
, ExtraData
=ErrorInfo
)
3074 ## __GetCglSection() method
3076 # Get compressed or GUIDed section for Obj
3078 # @param self The object pointer
3079 # @param Obj for whom leaf section is got
3080 # @param AlignValue alignment value for complex section
3081 # @retval True Successfully find section statement
3082 # @retval False Not able to find section statement
3084 def __GetCglSection(self
, Obj
, AlignValue
= None):
3086 if self
.__IsKeyword
( "COMPRESS"):
3088 if self
.__IsKeyword
("PI_STD") or self
.__IsKeyword
("PI_NONE"):
3091 if not self
.__IsToken
("{"):
3092 raise Warning("expected '{'", self
.FileName
, self
.CurrentLineNumber
)
3094 CompressSectionObj
= CompressSection
.CompressSection()
3095 CompressSectionObj
.Alignment
= AlignValue
3096 CompressSectionObj
.CompType
= type
3097 # Recursive sections...
3099 IsLeafSection
= self
.__GetLeafSection
(CompressSectionObj
)
3100 IsEncapSection
= self
.__GetEncapsulationSec
(CompressSectionObj
)
3101 if not IsLeafSection
and not IsEncapSection
:
3105 if not self
.__IsToken
( "}"):
3106 raise Warning("expected '}'", self
.FileName
, self
.CurrentLineNumber
)
3107 Obj
.SectionList
.append(CompressSectionObj
)
3110 # raise Warning("Compress type not known")
3114 elif self
.__IsKeyword
( "GUIDED"):
3116 if self
.__GetNextGuid
():
3117 GuidValue
= self
.__Token
3119 AttribDict
= self
.__GetGuidAttrib
()
3120 if not self
.__IsToken
("{"):
3121 raise Warning("expected '{'", self
.FileName
, self
.CurrentLineNumber
)
3122 GuidSectionObj
= GuidSection
.GuidSection()
3123 GuidSectionObj
.Alignment
= AlignValue
3124 GuidSectionObj
.NameGuid
= GuidValue
3125 GuidSectionObj
.SectionType
= "GUIDED"
3126 GuidSectionObj
.ProcessRequired
= AttribDict
["PROCESSING_REQUIRED"]
3127 GuidSectionObj
.AuthStatusValid
= AttribDict
["AUTH_STATUS_VALID"]
3128 GuidSectionObj
.ExtraHeaderSize
= AttribDict
["EXTRA_HEADER_SIZE"]
3129 # Recursive sections...
3131 IsLeafSection
= self
.__GetLeafSection
(GuidSectionObj
)
3132 IsEncapSection
= self
.__GetEncapsulationSec
(GuidSectionObj
)
3133 if not IsLeafSection
and not IsEncapSection
:
3136 if not self
.__IsToken
( "}"):
3137 raise Warning("expected '}'", self
.FileName
, self
.CurrentLineNumber
)
3138 Obj
.SectionList
.append(GuidSectionObj
)
3144 ## __GetGuidAttri() method
3146 # Get attributes for GUID section
3148 # @param self The object pointer
3149 # @retval AttribDict Dictionary of key-value pair of section attributes
3151 def __GetGuidAttrib(self
):
3154 AttribDict
["PROCESSING_REQUIRED"] = "NONE"
3155 AttribDict
["AUTH_STATUS_VALID"] = "NONE"
3156 AttribDict
["EXTRA_HEADER_SIZE"] = -1
3157 while self
.__IsKeyword
("PROCESSING_REQUIRED") or self
.__IsKeyword
("AUTH_STATUS_VALID") \
3158 or self
.__IsKeyword
("EXTRA_HEADER_SIZE"):
3159 AttribKey
= self
.__Token
3161 if not self
.__IsToken
("="):
3162 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
3164 if not self
.__GetNextToken
():
3165 raise Warning("expected TRUE(1)/FALSE(0)/Number", self
.FileName
, self
.CurrentLineNumber
)
3166 elif AttribKey
== "EXTRA_HEADER_SIZE":
3168 if self
.__Token
[0:2].upper() == "0X":
3171 AttribDict
[AttribKey
] = int(self
.__Token
, Base
)
3174 raise Warning("expected Number", self
.FileName
, self
.CurrentLineNumber
)
3175 elif self
.__Token
.upper() not in ("TRUE", "FALSE", "1", "0"):
3176 raise Warning("expected TRUE/FALSE (1/0)", self
.FileName
, self
.CurrentLineNumber
)
3177 AttribDict
[AttribKey
] = self
.__Token
3181 ## __GetEncapsulationSec() method
3183 # Get encapsulation section for FILE
3185 # @param self The object pointer
3186 # @param FfsFile for whom section is got
3187 # @retval True Successfully find section statement
3188 # @retval False Not able to find section statement
3190 def __GetEncapsulationSec(self
, FfsFileObj
):
3192 OldPos
= self
.GetFileBufferPos()
3193 if not self
.__IsKeyword
( "SECTION"):
3194 if len(FfsFileObj
.SectionList
) == 0:
3195 raise Warning("expected SECTION", self
.FileName
, self
.CurrentLineNumber
)
3200 if self
.__GetAlignment
():
3201 if self
.__Token
not in ("8", "16", "32", "64", "128", "512", "1K", "4K", "32K" ,"64K", "128K",
3202 "256K", "512K", "1M", "2M", "4M", "8M", "16M"):
3203 raise Warning("Incorrect alignment '%s'" % self
.__Token
, self
.FileName
, self
.CurrentLineNumber
)
3204 AlignValue
= self
.__Token
3206 if not self
.__GetCglSection
(FfsFileObj
, AlignValue
):
3207 self
.SetFileBufferPos(OldPos
)
3213 if not self
.__GetNextToken
():
3215 S
= self
.__Token
.upper()
3216 if S
.startswith("[") and not S
.startswith("[FMPPAYLOAD."):
3217 self
.SectionParser(S
)
3222 self
.__SkipToToken
("[FMPPAYLOAD.", True)
3223 FmpUiName
= self
.__GetUiName
().upper()
3224 if FmpUiName
in self
.Profile
.FmpPayloadDict
:
3225 raise Warning("Duplicated FMP UI name found: %s" % FmpUiName
, self
.FileName
, self
.CurrentLineNumber
)
3227 FmpData
= CapsuleData
.CapsulePayload()
3228 FmpData
.UiName
= FmpUiName
3230 if not self
.__IsToken
( "]"):
3231 raise Warning("expected ']'", self
.FileName
, self
.CurrentLineNumber
)
3233 if not self
.__GetNextToken
():
3234 raise Warning("The FMP payload section is empty!", self
.FileName
, self
.CurrentLineNumber
)
3235 FmpKeyList
= ['IMAGE_HEADER_INIT_VERSION', 'IMAGE_TYPE_ID', 'IMAGE_INDEX', 'HARDWARE_INSTANCE', 'CERTIFICATE_GUID', 'MONOTONIC_COUNT']
3236 while self
.__Token
in FmpKeyList
:
3238 FmpKeyList
.remove(Name
)
3239 if not self
.__IsToken
("="):
3240 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
3241 if Name
== 'IMAGE_TYPE_ID':
3242 if not self
.__GetNextGuid
():
3243 raise Warning("expected GUID value for IMAGE_TYPE_ID.", self
.FileName
, self
.CurrentLineNumber
)
3244 FmpData
.ImageTypeId
= self
.__Token
3245 elif Name
== 'CERTIFICATE_GUID':
3246 if not self
.__GetNextGuid
():
3247 raise Warning("expected GUID value for CERTIFICATE_GUID.", self
.FileName
, self
.CurrentLineNumber
)
3248 FmpData
.Certificate_Guid
= self
.__Token
3249 if uuid
.UUID(FmpData
.Certificate_Guid
) != EFI_CERT_TYPE_RSA2048_SHA256_GUID
and uuid
.UUID(FmpData
.Certificate_Guid
) != EFI_CERT_TYPE_PKCS7_GUID
:
3250 raise Warning("Only support EFI_CERT_TYPE_RSA2048_SHA256_GUID or EFI_CERT_TYPE_PKCS7_GUID for CERTIFICATE_GUID.", self
.FileName
, self
.CurrentLineNumber
)
3252 if not self
.__GetNextToken
():
3253 raise Warning("expected value of %s" % Name
, self
.FileName
, self
.CurrentLineNumber
)
3254 Value
= self
.__Token
3255 if Name
== 'IMAGE_HEADER_INIT_VERSION':
3256 if self
.__Verify
(Name
, Value
, 'UINT8'):
3257 FmpData
.Version
= Value
3258 elif Name
== 'IMAGE_INDEX':
3259 if self
.__Verify
(Name
, Value
, 'UINT8'):
3260 FmpData
.ImageIndex
= Value
3261 elif Name
== 'HARDWARE_INSTANCE':
3262 if self
.__Verify
(Name
, Value
, 'UINT8'):
3263 FmpData
.HardwareInstance
= Value
3264 elif Name
== 'MONOTONIC_COUNT':
3265 if self
.__Verify
(Name
, Value
, 'UINT64'):
3266 FmpData
.MonotonicCount
= Value
3267 if FmpData
.MonotonicCount
.upper().startswith('0X'):
3268 FmpData
.MonotonicCount
= (long)(FmpData
.MonotonicCount
, 16)
3270 FmpData
.MonotonicCount
= (long)(FmpData
.MonotonicCount
)
3271 if not self
.__GetNextToken
():
3276 if (FmpData
.MonotonicCount
and not FmpData
.Certificate_Guid
) or (not FmpData
.MonotonicCount
and FmpData
.Certificate_Guid
):
3277 EdkLogger
.error("FdfParser", FORMAT_INVALID
, "CERTIFICATE_GUID and MONOTONIC_COUNT must be work as a pair.")
3279 # Only the IMAGE_TYPE_ID is required item
3280 if FmpKeyList
and 'IMAGE_TYPE_ID' in FmpKeyList
:
3281 raise Warning("Missing keywords IMAGE_TYPE_ID in FMP payload section.", self
.FileName
, self
.CurrentLineNumber
)
3282 # get the Image file and Vendor code file
3283 self
.__GetFMPCapsuleData
(FmpData
)
3284 if not FmpData
.ImageFile
:
3285 raise Warning("Missing image file in FMP payload section.", self
.FileName
, self
.CurrentLineNumber
)
3286 # check whether more than one Vendor code file
3287 if len(FmpData
.VendorCodeFile
) > 1:
3288 raise Warning("At most one Image file and one Vendor code file are allowed in FMP payload section.", self
.FileName
, self
.CurrentLineNumber
)
3289 self
.Profile
.FmpPayloadDict
[FmpUiName
] = FmpData
3292 ## __GetCapsule() method
3294 # Get capsule section contents and store its data into capsule list of self.Profile
3296 # @param self The object pointer
3297 # @retval True Successfully find a capsule
3298 # @retval False Not able to find a capsule
3300 def __GetCapsule(self
):
3302 if not self
.__GetNextToken
():
3305 S
= self
.__Token
.upper()
3306 if S
.startswith("[") and not S
.startswith("[CAPSULE."):
3307 self
.SectionParser(S
)
3312 if not self
.__IsToken
("[CAPSULE.", True):
3313 FileLineTuple
= GetRealFileLine(self
.FileName
, self
.CurrentLineNumber
)
3314 #print 'Parsing String: %s in File %s, At line: %d, Offset Within Line: %d' \
3315 # % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine :], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine)
3316 raise Warning("expected [Capsule.]", self
.FileName
, self
.CurrentLineNumber
)
3318 CapsuleObj
= Capsule
.Capsule()
3320 CapsuleName
= self
.__GetUiName
()
3322 raise Warning("expected capsule name", self
.FileName
, self
.CurrentLineNumber
)
3324 CapsuleObj
.UiCapsuleName
= CapsuleName
.upper()
3326 if not self
.__IsToken
( "]"):
3327 raise Warning("expected ']'", self
.FileName
, self
.CurrentLineNumber
)
3329 if self
.__IsKeyword
("CREATE_FILE"):
3330 if not self
.__IsToken
( "="):
3331 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
3333 if not self
.__GetNextToken
():
3334 raise Warning("expected file name", self
.FileName
, self
.CurrentLineNumber
)
3336 CapsuleObj
.CreateFile
= self
.__Token
3338 self
.__GetCapsuleStatements
(CapsuleObj
)
3339 self
.Profile
.CapsuleDict
[CapsuleObj
.UiCapsuleName
] = CapsuleObj
3342 ## __GetCapsuleStatements() method
3344 # Get statements for capsule
3346 # @param self The object pointer
3347 # @param Obj for whom statements are got
3349 def __GetCapsuleStatements(self
, Obj
):
3350 self
.__GetCapsuleTokens
(Obj
)
3351 self
.__GetDefineStatements
(Obj
)
3352 self
.__GetSetStatements
(Obj
)
3353 self
.__GetCapsuleData
(Obj
)
3355 ## __GetCapsuleTokens() method
3357 # Get token statements for capsule
3359 # @param self The object pointer
3360 # @param Obj for whom token statements are got
3362 def __GetCapsuleTokens(self
, Obj
):
3363 if not self
.__GetNextToken
():
3365 while self
.__Token
in ("CAPSULE_GUID", "CAPSULE_HEADER_SIZE", "CAPSULE_FLAGS", "OEM_CAPSULE_FLAGS", "CAPSULE_HEADER_INIT_VERSION"):
3366 Name
= self
.__Token
.strip()
3367 if not self
.__IsToken
("="):
3368 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
3369 if not self
.__GetNextToken
():
3370 raise Warning("expected value", self
.FileName
, self
.CurrentLineNumber
)
3371 if Name
== 'CAPSULE_FLAGS':
3372 if not self
.__Token
in ("PersistAcrossReset", "PopulateSystemTable", "InitiateReset"):
3373 raise Warning("expected PersistAcrossReset, PopulateSystemTable, or InitiateReset", self
.FileName
, self
.CurrentLineNumber
)
3374 Value
= self
.__Token
.strip()
3375 while self
.__IsToken
(","):
3377 if not self
.__GetNextToken
():
3378 raise Warning("expected value", self
.FileName
, self
.CurrentLineNumber
)
3379 if not self
.__Token
in ("PersistAcrossReset", "PopulateSystemTable", "InitiateReset"):
3380 raise Warning("expected PersistAcrossReset, PopulateSystemTable, or InitiateReset", self
.FileName
, self
.CurrentLineNumber
)
3381 Value
+= self
.__Token
.strip()
3382 elif Name
== 'OEM_CAPSULE_FLAGS':
3383 Value
= self
.__Token
.strip()
3384 if not Value
.upper().startswith('0X'):
3385 raise Warning("expected hex value between 0x0000 and 0xFFFF", self
.FileName
, self
.CurrentLineNumber
)
3387 Value
= int(Value
, 0)
3389 raise Warning("expected hex value between 0x0000 and 0xFFFF", self
.FileName
, self
.CurrentLineNumber
)
3390 if not 0x0000 <= Value
<= 0xFFFF:
3391 raise Warning("expected hex value between 0x0000 and 0xFFFF", self
.FileName
, self
.CurrentLineNumber
)
3392 Value
= self
.__Token
.strip()
3394 Value
= self
.__Token
.strip()
3395 Obj
.TokensDict
[Name
] = Value
3396 if not self
.__GetNextToken
():
3400 ## __GetCapsuleData() method
3402 # Get capsule data for capsule
3404 # @param self The object pointer
3405 # @param Obj for whom capsule data are got
3407 def __GetCapsuleData(self
, Obj
):
3410 IsInf
= self
.__GetInfStatement
(Obj
, True)
3411 IsFile
= self
.__GetFileStatement
(Obj
, True)
3412 IsFv
= self
.__GetFvStatement
(Obj
)
3413 IsFd
= self
.__GetFdStatement
(Obj
)
3414 IsAnyFile
= self
.__GetAnyFileStatement
(Obj
)
3415 IsAfile
= self
.__GetAfileStatement
(Obj
)
3416 IsFmp
= self
.__GetFmpStatement
(Obj
)
3417 if not (IsInf
or IsFile
or IsFv
or IsFd
or IsAnyFile
or IsAfile
or IsFmp
):
3420 ## __GetFMPCapsuleData() method
3422 # Get capsule data for FMP capsule
3424 # @param self The object pointer
3425 # @param Obj for whom capsule data are got
3427 def __GetFMPCapsuleData(self
, Obj
):
3430 IsFv
= self
.__GetFvStatement
(Obj
, True)
3431 IsFd
= self
.__GetFdStatement
(Obj
, True)
3432 IsAnyFile
= self
.__GetAnyFileStatement
(Obj
, True)
3433 if not (IsFv
or IsFd
or IsAnyFile
):
3436 ## __GetFvStatement() method
3438 # Get FV for capsule
3440 # @param self The object pointer
3441 # @param CapsuleObj for whom FV is got
3442 # @retval True Successfully find a FV statement
3443 # @retval False Not able to find a FV statement
3445 def __GetFvStatement(self
, CapsuleObj
, FMPCapsule
= False):
3447 if not self
.__IsKeyword
("FV"):
3450 if not self
.__IsToken
("="):
3451 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
3453 if not self
.__GetNextToken
():
3454 raise Warning("expected FV name", self
.FileName
, self
.CurrentLineNumber
)
3456 if self
.__Token
.upper() not in self
.Profile
.FvDict
.keys():
3457 raise Warning("FV name does not exist", self
.FileName
, self
.CurrentLineNumber
)
3459 CapsuleFv
= CapsuleData
.CapsuleFv()
3460 CapsuleFv
.FvName
= self
.__Token
3462 if not CapsuleObj
.ImageFile
:
3463 CapsuleObj
.ImageFile
.append(CapsuleFv
)
3465 CapsuleObj
.VendorCodeFile
.append(CapsuleFv
)
3467 CapsuleObj
.CapsuleDataList
.append(CapsuleFv
)
3470 ## __GetFdStatement() method
3472 # Get FD for capsule
3474 # @param self The object pointer
3475 # @param CapsuleObj for whom FD is got
3476 # @retval True Successfully find a FD statement
3477 # @retval False Not able to find a FD statement
3479 def __GetFdStatement(self
, CapsuleObj
, FMPCapsule
= False):
3481 if not self
.__IsKeyword
("FD"):
3484 if not self
.__IsToken
("="):
3485 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
3487 if not self
.__GetNextToken
():
3488 raise Warning("expected FD name", self
.FileName
, self
.CurrentLineNumber
)
3490 if self
.__Token
.upper() not in self
.Profile
.FdDict
.keys():
3491 raise Warning("FD name does not exist", self
.FileName
, self
.CurrentLineNumber
)
3493 CapsuleFd
= CapsuleData
.CapsuleFd()
3494 CapsuleFd
.FdName
= self
.__Token
3496 if not CapsuleObj
.ImageFile
:
3497 CapsuleObj
.ImageFile
.append(CapsuleFd
)
3499 CapsuleObj
.VendorCodeFile
.append(CapsuleFd
)
3501 CapsuleObj
.CapsuleDataList
.append(CapsuleFd
)
3504 def __GetFmpStatement(self
, CapsuleObj
):
3505 if not self
.__IsKeyword
("FMP_PAYLOAD"):
3506 if not self
.__IsKeyword
("FMP"):
3509 if not self
.__IsKeyword
("PAYLOAD"):
3513 if not self
.__IsToken
("="):
3514 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
3516 if not self
.__GetNextToken
():
3517 raise Warning("expected payload name after FMP_PAYLOAD =", self
.FileName
, self
.CurrentLineNumber
)
3518 Payload
= self
.__Token
.upper()
3519 if Payload
not in self
.Profile
.FmpPayloadDict
:
3520 raise Warning("This FMP Payload does not exist: %s" % self
.__Token
, self
.FileName
, self
.CurrentLineNumber
)
3521 CapsuleObj
.FmpPayloadList
.append(self
.Profile
.FmpPayloadDict
[Payload
])
3524 def __ParseRawFileStatement(self
):
3525 if not self
.__IsKeyword
("FILE"):
3528 if not self
.__IsKeyword
("DATA"):
3532 if not self
.__IsToken
("="):
3533 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
3535 if not self
.__GetNextToken
():
3536 raise Warning("expected File name", self
.FileName
, self
.CurrentLineNumber
)
3538 AnyFileName
= self
.__Token
3539 self
.__VerifyFile
(AnyFileName
)
3541 if not os
.path
.isabs(AnyFileName
):
3542 AnyFileName
= mws
.join(GenFdsGlobalVariable
.WorkSpaceDir
, AnyFileName
)
3546 ## __GetAnyFileStatement() method
3548 # Get AnyFile for capsule
3550 # @param self The object pointer
3551 # @param CapsuleObj for whom AnyFile is got
3552 # @retval True Successfully find a Anyfile statement
3553 # @retval False Not able to find a AnyFile statement
3555 def __GetAnyFileStatement(self
, CapsuleObj
, FMPCapsule
= False):
3556 AnyFileName
= self
.__ParseRawFileStatement
()
3560 CapsuleAnyFile
= CapsuleData
.CapsuleAnyFile()
3561 CapsuleAnyFile
.FileName
= AnyFileName
3563 if not CapsuleObj
.ImageFile
:
3564 CapsuleObj
.ImageFile
.append(CapsuleAnyFile
)
3566 CapsuleObj
.VendorCodeFile
.append(CapsuleAnyFile
)
3568 CapsuleObj
.CapsuleDataList
.append(CapsuleAnyFile
)
3571 ## __GetAfileStatement() method
3573 # Get Afile for capsule
3575 # @param self The object pointer
3576 # @param CapsuleObj for whom Afile is got
3577 # @retval True Successfully find a Afile statement
3578 # @retval False Not able to find a Afile statement
3580 def __GetAfileStatement(self
, CapsuleObj
):
3582 if not self
.__IsKeyword
("APPEND"):
3585 if not self
.__IsToken
("="):
3586 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
3588 if not self
.__GetNextToken
():
3589 raise Warning("expected Afile name", self
.FileName
, self
.CurrentLineNumber
)
3591 AfileName
= self
.__Token
3592 AfileBaseName
= os
.path
.basename(AfileName
)
3594 if os
.path
.splitext(AfileBaseName
)[1] not in [".bin",".BIN",".Bin",".dat",".DAT",".Dat",".data",".DATA",".Data"]:
3595 raise Warning('invalid binary file type, should be one of "bin","BIN","Bin","dat","DAT","Dat","data","DATA","Data"', \
3596 self
.FileName
, self
.CurrentLineNumber
)
3598 if not os
.path
.isabs(AfileName
):
3599 AfileName
= GenFdsGlobalVariable
.ReplaceWorkspaceMacro(AfileName
)
3600 self
.__VerifyFile
(AfileName
)
3602 if not os
.path
.exists(AfileName
):
3603 raise Warning('%s does not exist' % AfileName
, self
.FileName
, self
.CurrentLineNumber
)
3607 CapsuleAfile
= CapsuleData
.CapsuleAfile()
3608 CapsuleAfile
.FileName
= AfileName
3609 CapsuleObj
.CapsuleDataList
.append(CapsuleAfile
)
3612 ## __GetRule() method
3614 # Get Rule section contents and store its data into rule list of self.Profile
3616 # @param self The object pointer
3617 # @retval True Successfully find a Rule
3618 # @retval False Not able to find a Rule
3620 def __GetRule(self
):
3622 if not self
.__GetNextToken
():
3625 S
= self
.__Token
.upper()
3626 if S
.startswith("[") and not S
.startswith("[RULE."):
3627 self
.SectionParser(S
)
3631 if not self
.__IsToken
("[Rule.", True):
3632 FileLineTuple
= GetRealFileLine(self
.FileName
, self
.CurrentLineNumber
)
3633 #print 'Parsing String: %s in File %s, At line: %d, Offset Within Line: %d' \
3634 # % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine :], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine)
3635 raise Warning("expected [Rule.]", self
.FileName
, self
.CurrentLineNumber
)
3637 if not self
.__SkipToToken
("."):
3638 raise Warning("expected '.'", self
.FileName
, self
.CurrentLineNumber
)
3640 Arch
= self
.__SkippedChars
.rstrip(".")
3641 if Arch
.upper() not in ("IA32", "X64", "IPF", "EBC", "ARM", "AARCH64", "COMMON"):
3642 raise Warning("Unknown Arch '%s'" % Arch
, self
.FileName
, self
.CurrentLineNumber
)
3644 ModuleType
= self
.__GetModuleType
()
3647 if self
.__IsToken
("."):
3648 if not self
.__GetNextWord
():
3649 raise Warning("expected template name", self
.FileName
, self
.CurrentLineNumber
)
3650 TemplateName
= self
.__Token
3652 if not self
.__IsToken
( "]"):
3653 raise Warning("expected ']'", self
.FileName
, self
.CurrentLineNumber
)
3655 RuleObj
= self
.__GetRuleFileStatements
()
3656 RuleObj
.Arch
= Arch
.upper()
3657 RuleObj
.ModuleType
= ModuleType
3658 RuleObj
.TemplateName
= TemplateName
3659 if TemplateName
== '' :
3660 self
.Profile
.RuleDict
['RULE' + \
3664 ModuleType
.upper() ] = RuleObj
3666 self
.Profile
.RuleDict
['RULE' + \
3670 ModuleType
.upper() + \
3672 TemplateName
.upper() ] = RuleObj
3673 # self.Profile.RuleList.append(rule)
3676 ## __GetModuleType() method
3678 # Return the module type
3680 # @param self The object pointer
3681 # @retval string module type
3683 def __GetModuleType(self
):
3685 if not self
.__GetNextWord
():
3686 raise Warning("expected Module type", self
.FileName
, self
.CurrentLineNumber
)
3687 if self
.__Token
.upper() not in ("SEC", "PEI_CORE", "PEIM", "DXE_CORE", \
3688 "DXE_DRIVER", "DXE_SAL_DRIVER", \
3689 "DXE_SMM_DRIVER", "DXE_RUNTIME_DRIVER", \
3690 "UEFI_DRIVER", "UEFI_APPLICATION", "USER_DEFINED", "DEFAULT", "BASE", \
3691 "SECURITY_CORE", "COMBINED_PEIM_DRIVER", "PIC_PEIM", "RELOCATABLE_PEIM", \
3692 "PE32_PEIM", "BS_DRIVER", "RT_DRIVER", "SAL_RT_DRIVER", "APPLICATION", "ACPITABLE", "SMM_CORE", "MM_STANDALONE", "MM_CORE_STANDALONE"):
3693 raise Warning("Unknown Module type '%s'" % self
.__Token
, self
.FileName
, self
.CurrentLineNumber
)
3696 ## __GetFileExtension() method
3698 # Return the file extension
3700 # @param self The object pointer
3701 # @retval string file name extension
3703 def __GetFileExtension(self
):
3704 if not self
.__IsToken
("."):
3705 raise Warning("expected '.'", self
.FileName
, self
.CurrentLineNumber
)
3708 if self
.__GetNextToken
():
3709 Pattern
= re
.compile(r
'([a-zA-Z][a-zA-Z0-9]*)')
3710 if Pattern
.match(self
.__Token
):
3714 raise Warning("Unknown file extension '%s'" % self
.__Token
, self
.FileName
, self
.CurrentLineNumber
)
3717 raise Warning("expected file extension", self
.FileName
, self
.CurrentLineNumber
)
3719 ## __GetRuleFileStatement() method
3723 # @param self The object pointer
3724 # @retval Rule Rule object
3726 def __GetRuleFileStatements(self
):
3728 if not self
.__IsKeyword
("FILE"):
3729 raise Warning("expected FILE", self
.FileName
, self
.CurrentLineNumber
)
3731 if not self
.__GetNextWord
():
3732 raise Warning("expected FFS type", self
.FileName
, self
.CurrentLineNumber
)
3734 Type
= self
.__Token
.strip().upper()
3735 if Type
not in ("RAW", "FREEFORM", "SEC", "PEI_CORE", "PEIM",\
3736 "PEI_DXE_COMBO", "DRIVER", "DXE_CORE", "APPLICATION", "FV_IMAGE", "SMM", "SMM_CORE", "MM_STANDALONE", "MM_CORE_STANDALONE"):
3737 raise Warning("Unknown FV type '%s'" % self
.__Token
, self
.FileName
, self
.CurrentLineNumber
)
3739 if not self
.__IsToken
("="):
3740 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
3742 if not self
.__IsKeyword
("$(NAMED_GUID)"):
3743 if not self
.__GetNextWord
():
3744 raise Warning("expected $(NAMED_GUID)", self
.FileName
, self
.CurrentLineNumber
)
3745 if self
.__Token
== 'PCD':
3746 if not self
.__IsToken
( "("):
3747 raise Warning("expected '('", self
.FileName
, self
.CurrentLineNumber
)
3748 PcdPair
= self
.__GetNextPcdName
()
3749 if not self
.__IsToken
( ")"):
3750 raise Warning("expected ')'", self
.FileName
, self
.CurrentLineNumber
)
3751 self
.__Token
= 'PCD('+PcdPair
[1]+'.'+PcdPair
[0]+')'
3753 NameGuid
= self
.__Token
3756 if self
.__IsKeyword
('RELOCS_STRIPPED') or self
.__IsKeyword
('RELOCS_RETAINED'):
3757 if self
.__FileCouldHaveRelocFlag
(Type
):
3758 if self
.__Token
== 'RELOCS_STRIPPED':
3763 raise Warning("File type %s could not have reloc strip flag%d" % (Type
, self
.CurrentLineNumber
), self
.FileName
, self
.CurrentLineNumber
)
3766 if self
.__GetNextToken
():
3767 Pattern
= re
.compile(r
'([a-zA-Z0-9\-]+|\$\(TARGET\)|\*)_([a-zA-Z0-9\-]+|\$\(TOOL_CHAIN_TAG\)|\*)_([a-zA-Z0-9\-]+|\$\(ARCH\)|\*)')
3768 if Pattern
.match(self
.__Token
):
3769 KeyStringList
.append(self
.__Token
)
3770 if self
.__IsToken
(","):
3771 while self
.__GetNextToken
():
3772 if not Pattern
.match(self
.__Token
):
3773 raise Warning("expected KeyString \"Target_Tag_Arch\"", self
.FileName
, self
.CurrentLineNumber
)
3774 KeyStringList
.append(self
.__Token
)
3776 if not self
.__IsToken
(","):
3784 if self
.__IsKeyword
("Fixed", True):
3788 if self
.__IsKeyword
("CheckSum", True):
3792 if self
.__GetAlignment
():
3793 if self
.__Token
not in ("Auto", "8", "16", "32", "64", "128", "512", "1K", "4K", "32K" ,"64K", "128K",
3794 "256K", "512K", "1M", "2M", "4M", "8M", "16M"):
3795 raise Warning("Incorrect alignment '%s'" % self
.__Token
, self
.FileName
, self
.CurrentLineNumber
)
3796 #For FFS, Auto is default option same to ""
3797 if not self
.__Token
== "Auto":
3798 AlignValue
= self
.__Token
3800 if self
.__IsToken
("{"):
3801 # Complex file rule expected
3802 Rule
= RuleComplexFile
.RuleComplexFile()
3803 Rule
.FvFileType
= Type
3804 Rule
.NameGuid
= NameGuid
3805 Rule
.Alignment
= AlignValue
3806 Rule
.CheckSum
= CheckSum
3808 Rule
.KeyStringList
= KeyStringList
3809 if KeepReloc
!= None:
3810 Rule
.KeepReloc
= KeepReloc
3813 IsEncapsulate
= self
.__GetRuleEncapsulationSection
(Rule
)
3814 IsLeaf
= self
.__GetEfiSection
(Rule
)
3815 if not IsEncapsulate
and not IsLeaf
:
3818 if not self
.__IsToken
("}"):
3819 raise Warning("expected '}'", self
.FileName
, self
.CurrentLineNumber
)
3824 # Simple file rule expected
3825 if not self
.__GetNextWord
():
3826 raise Warning("expected leaf section type", self
.FileName
, self
.CurrentLineNumber
)
3828 SectionName
= self
.__Token
3830 if SectionName
not in ("COMPAT16", "PE32", "PIC", "TE", "FV_IMAGE", "RAW", "DXE_DEPEX",\
3831 "UI", "PEI_DEPEX", "VERSION", "SUBTYPE_GUID", "SMM_DEPEX"):
3832 raise Warning("Unknown leaf section name '%s'" % SectionName
, self
.FileName
, self
.CurrentLineNumber
)
3835 if self
.__IsKeyword
("Fixed", True):
3838 if self
.__IsKeyword
("CheckSum", True):
3842 if self
.__GetAlignment
():
3843 if self
.__Token
not in ("Auto", "8", "16", "32", "64", "128", "512", "1K", "4K", "32K" ,"64K", "128K",
3844 "256K", "512K", "1M", "2M", "4M", "8M", "16M"):
3845 raise Warning("Incorrect alignment '%s'" % self
.__Token
, self
.FileName
, self
.CurrentLineNumber
)
3846 if self
.__Token
== 'Auto' and (not SectionName
== 'PE32') and (not SectionName
== 'TE'):
3847 raise Warning("Auto alignment can only be used in PE32 or TE section ", self
.FileName
, self
.CurrentLineNumber
)
3848 SectAlignment
= self
.__Token
3851 if self
.__IsToken
('|'):
3852 Ext
= self
.__GetFileExtension
()
3853 elif not self
.__GetNextToken
():
3854 raise Warning("expected File name", self
.FileName
, self
.CurrentLineNumber
)
3856 Rule
= RuleSimpleFile
.RuleSimpleFile()
3857 Rule
.SectionType
= SectionName
3858 Rule
.FvFileType
= Type
3859 Rule
.NameGuid
= NameGuid
3860 Rule
.Alignment
= AlignValue
3861 Rule
.SectAlignment
= SectAlignment
3862 Rule
.CheckSum
= CheckSum
3864 Rule
.KeyStringList
= KeyStringList
3865 if KeepReloc
!= None:
3866 Rule
.KeepReloc
= KeepReloc
3867 Rule
.FileExtension
= Ext
3868 Rule
.FileName
= self
.__Token
3871 ## __GetEfiSection() method
3873 # Get section list for Rule
3875 # @param self The object pointer
3876 # @param Obj for whom section is got
3877 # @retval True Successfully find section statement
3878 # @retval False Not able to find section statement
3880 def __GetEfiSection(self
, Obj
):
3882 OldPos
= self
.GetFileBufferPos()
3883 if not self
.__GetNextWord
():
3885 SectionName
= self
.__Token
3887 if SectionName
not in ("COMPAT16", "PE32", "PIC", "TE", "FV_IMAGE", "RAW", "DXE_DEPEX",\
3888 "UI", "VERSION", "PEI_DEPEX", "GUID", "SMM_DEPEX"):
3892 if SectionName
== "FV_IMAGE":
3893 FvImageSectionObj
= FvImageSection
.FvImageSection()
3894 if self
.__IsKeyword
("FV_IMAGE"):
3896 if self
.__IsToken
( "{"):
3898 self
.__GetDefineStatements
(FvObj
)
3899 self
.__GetBlockStatement
(FvObj
)
3900 self
.__GetSetStatements
(FvObj
)
3901 self
.__GetFvAlignment
(FvObj
)
3902 self
.__GetFvAttributes
(FvObj
)
3903 self
.__GetAprioriSection
(FvObj
)
3904 self
.__GetAprioriSection
(FvObj
)
3907 IsInf
= self
.__GetInfStatement
(FvObj
)
3908 IsFile
= self
.__GetFileStatement
(FvObj
)
3909 if not IsInf
and not IsFile
:
3912 if not self
.__IsToken
( "}"):
3913 raise Warning("expected '}'", self
.FileName
, self
.CurrentLineNumber
)
3914 FvImageSectionObj
.Fv
= FvObj
3915 FvImageSectionObj
.FvName
= None
3918 if not self
.__IsKeyword
("FV"):
3919 raise Warning("expected 'FV'", self
.FileName
, self
.CurrentLineNumber
)
3920 FvImageSectionObj
.FvFileType
= self
.__Token
3922 if self
.__GetAlignment
():
3923 if self
.__Token
not in ("8", "16", "32", "64", "128", "512", "1K", "4K", "32K" ,"64K", "128K",
3924 "256K", "512K", "1M", "2M", "4M", "8M", "16M"):
3925 raise Warning("Incorrect alignment '%s'" % self
.__Token
, self
.FileName
, self
.CurrentLineNumber
)
3926 FvImageSectionObj
.Alignment
= self
.__Token
3928 if self
.__IsToken
('|'):
3929 FvImageSectionObj
.FvFileExtension
= self
.__GetFileExtension
()
3930 elif self
.__GetNextToken
():
3931 if self
.__Token
not in ("}", "COMPAT16", "PE32", "PIC", "TE", "FV_IMAGE", "RAW", "DXE_DEPEX",\
3932 "UI", "VERSION", "PEI_DEPEX", "GUID", "SMM_DEPEX"):
3933 FvImageSectionObj
.FvFileName
= self
.__Token
3937 raise Warning("expected FV file name", self
.FileName
, self
.CurrentLineNumber
)
3939 Obj
.SectionList
.append(FvImageSectionObj
)
3942 EfiSectionObj
= EfiSection
.EfiSection()
3943 EfiSectionObj
.SectionType
= SectionName
3945 if not self
.__GetNextToken
():
3946 raise Warning("expected file type", self
.FileName
, self
.CurrentLineNumber
)
3948 if self
.__Token
== "STRING":
3949 if not self
.__RuleSectionCouldHaveString
(EfiSectionObj
.SectionType
):
3950 raise Warning("%s section could NOT have string data%d" % (EfiSectionObj
.SectionType
, self
.CurrentLineNumber
), self
.FileName
, self
.CurrentLineNumber
)
3952 if not self
.__IsToken
('='):
3953 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
3955 if not self
.__GetNextToken
():
3956 raise Warning("expected Quoted String", self
.FileName
, self
.CurrentLineNumber
)
3958 if self
.__GetStringData
():
3959 EfiSectionObj
.StringData
= self
.__Token
3961 if self
.__IsKeyword
("BUILD_NUM"):
3962 if not self
.__RuleSectionCouldHaveBuildNum
(EfiSectionObj
.SectionType
):
3963 raise Warning("%s section could NOT have BUILD_NUM%d" % (EfiSectionObj
.SectionType
, self
.CurrentLineNumber
), self
.FileName
, self
.CurrentLineNumber
)
3965 if not self
.__IsToken
("="):
3966 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
3967 if not self
.__GetNextToken
():
3968 raise Warning("expected Build number", self
.FileName
, self
.CurrentLineNumber
)
3969 EfiSectionObj
.BuildNum
= self
.__Token
3972 EfiSectionObj
.FileType
= self
.__Token
3973 self
.__CheckRuleSectionFileType
(EfiSectionObj
.SectionType
, EfiSectionObj
.FileType
)
3975 if self
.__IsKeyword
("Optional"):
3976 if not self
.__RuleSectionCouldBeOptional
(EfiSectionObj
.SectionType
):
3977 raise Warning("%s section could NOT be optional%d" % (EfiSectionObj
.SectionType
, self
.CurrentLineNumber
), self
.FileName
, self
.CurrentLineNumber
)
3978 EfiSectionObj
.Optional
= True
3980 if self
.__IsKeyword
("BUILD_NUM"):
3981 if not self
.__RuleSectionCouldHaveBuildNum
(EfiSectionObj
.SectionType
):
3982 raise Warning("%s section could NOT have BUILD_NUM%d" % (EfiSectionObj
.SectionType
, self
.CurrentLineNumber
), self
.FileName
, self
.CurrentLineNumber
)
3984 if not self
.__IsToken
("="):
3985 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
3986 if not self
.__GetNextToken
():
3987 raise Warning("expected Build number", self
.FileName
, self
.CurrentLineNumber
)
3988 EfiSectionObj
.BuildNum
= self
.__Token
3990 if self
.__GetAlignment
():
3991 if self
.__Token
not in ("Auto", "8", "16", "32", "64", "128", "512", "1K", "4K", "32K" ,"64K", "128K",
3992 "256K", "512K", "1M", "2M", "4M", "8M", "16M"):
3993 raise Warning("Incorrect alignment '%s'" % self
.__Token
, self
.FileName
, self
.CurrentLineNumber
)
3994 if self
.__Token
== 'Auto' and (not SectionName
== 'PE32') and (not SectionName
== 'TE'):
3995 raise Warning("Auto alignment can only be used in PE32 or TE section ", self
.FileName
, self
.CurrentLineNumber
)
3996 EfiSectionObj
.Alignment
= self
.__Token
3998 if self
.__IsKeyword
('RELOCS_STRIPPED') or self
.__IsKeyword
('RELOCS_RETAINED'):
3999 if self
.__SectionCouldHaveRelocFlag
(EfiSectionObj
.SectionType
):
4000 if self
.__Token
== 'RELOCS_STRIPPED':
4001 EfiSectionObj
.KeepReloc
= False
4003 EfiSectionObj
.KeepReloc
= True
4004 if Obj
.KeepReloc
!= None and Obj
.KeepReloc
!= EfiSectionObj
.KeepReloc
:
4005 raise Warning("Section type %s has reloc strip flag conflict with Rule" % EfiSectionObj
.SectionType
, self
.FileName
, self
.CurrentLineNumber
)
4007 raise Warning("Section type %s could not have reloc strip flag" % EfiSectionObj
.SectionType
, self
.FileName
, self
.CurrentLineNumber
)
4010 if self
.__IsToken
('|'):
4011 EfiSectionObj
.FileExtension
= self
.__GetFileExtension
()
4012 elif self
.__GetNextToken
():
4013 if self
.__Token
not in ("}", "COMPAT16", "PE32", "PIC", "TE", "FV_IMAGE", "RAW", "DXE_DEPEX",\
4014 "UI", "VERSION", "PEI_DEPEX", "GUID", "SMM_DEPEX"):
4016 if self
.__Token
.startswith('PCD'):
4018 self
.__GetNextWord
()
4020 if self
.__Token
== 'PCD':
4021 if not self
.__IsToken
( "("):
4022 raise Warning("expected '('", self
.FileName
, self
.CurrentLineNumber
)
4023 PcdPair
= self
.__GetNextPcdName
()
4024 if not self
.__IsToken
( ")"):
4025 raise Warning("expected ')'", self
.FileName
, self
.CurrentLineNumber
)
4026 self
.__Token
= 'PCD('+PcdPair
[1]+'.'+PcdPair
[0]+')'
4028 EfiSectionObj
.FileName
= self
.__Token
4033 raise Warning("expected section file name", self
.FileName
, self
.CurrentLineNumber
)
4035 Obj
.SectionList
.append(EfiSectionObj
)
4038 ## __RuleSectionCouldBeOptional() method
4040 # Get whether a section could be optional
4042 # @param self The object pointer
4043 # @param SectionType The section type to check
4044 # @retval True section could be optional
4045 # @retval False section never optional
4047 def __RuleSectionCouldBeOptional(self
, SectionType
):
4048 if SectionType
in ("DXE_DEPEX", "UI", "VERSION", "PEI_DEPEX", "RAW", "SMM_DEPEX"):
4053 ## __RuleSectionCouldHaveBuildNum() method
4055 # Get whether a section could have build number information
4057 # @param self The object pointer
4058 # @param SectionType The section type to check
4059 # @retval True section could have build number information
4060 # @retval False section never have build number information
4062 def __RuleSectionCouldHaveBuildNum(self
, SectionType
):
4063 if SectionType
in ("VERSION"):
4068 ## __RuleSectionCouldHaveString() method
4070 # Get whether a section could have string
4072 # @param self The object pointer
4073 # @param SectionType The section type to check
4074 # @retval True section could have string
4075 # @retval False section never have string
4077 def __RuleSectionCouldHaveString(self
, SectionType
):
4078 if SectionType
in ("UI", "VERSION"):
4083 ## __CheckRuleSectionFileType() method
4085 # Get whether a section matches a file type
4087 # @param self The object pointer
4088 # @param SectionType The section type to check
4089 # @param FileType The file type to check
4091 def __CheckRuleSectionFileType(self
, SectionType
, FileType
):
4092 if SectionType
== "COMPAT16":
4093 if FileType
not in ("COMPAT16", "SEC_COMPAT16"):
4094 raise Warning("Incorrect section file type '%s'" % FileType
, self
.FileName
, self
.CurrentLineNumber
)
4095 elif SectionType
== "PE32":
4096 if FileType
not in ("PE32", "SEC_PE32"):
4097 raise Warning("Incorrect section file type '%s'" % FileType
, self
.FileName
, self
.CurrentLineNumber
)
4098 elif SectionType
== "PIC":
4099 if FileType
not in ("PIC", "PIC"):
4100 raise Warning("Incorrect section file type '%s'" % FileType
, self
.FileName
, self
.CurrentLineNumber
)
4101 elif SectionType
== "TE":
4102 if FileType
not in ("TE", "SEC_TE"):
4103 raise Warning("Incorrect section file type '%s'" % FileType
, self
.FileName
, self
.CurrentLineNumber
)
4104 elif SectionType
== "RAW":
4105 if FileType
not in ("BIN", "SEC_BIN", "RAW", "ASL", "ACPI"):
4106 raise Warning("Incorrect section file type '%s'" % FileType
, self
.FileName
, self
.CurrentLineNumber
)
4107 elif SectionType
== "DXE_DEPEX" or SectionType
== "SMM_DEPEX":
4108 if FileType
not in ("DXE_DEPEX", "SEC_DXE_DEPEX", "SMM_DEPEX"):
4109 raise Warning("Incorrect section file type '%s'" % FileType
, self
.FileName
, self
.CurrentLineNumber
)
4110 elif SectionType
== "UI":
4111 if FileType
not in ("UI", "SEC_UI"):
4112 raise Warning("Incorrect section file type '%s'" % FileType
, self
.FileName
, self
.CurrentLineNumber
)
4113 elif SectionType
== "VERSION":
4114 if FileType
not in ("VERSION", "SEC_VERSION"):
4115 raise Warning("Incorrect section file type '%s'" % FileType
, self
.FileName
, self
.CurrentLineNumber
)
4116 elif SectionType
== "PEI_DEPEX":
4117 if FileType
not in ("PEI_DEPEX", "SEC_PEI_DEPEX"):
4118 raise Warning("Incorrect section file type '%s'" % FileType
, self
.FileName
, self
.CurrentLineNumber
)
4119 elif SectionType
== "GUID":
4120 if FileType
not in ("PE32", "SEC_GUID"):
4121 raise Warning("Incorrect section file type '%s'" % FileType
, self
.FileName
, self
.CurrentLineNumber
)
4123 ## __GetRuleEncapsulationSection() method
4125 # Get encapsulation section for Rule
4127 # @param self The object pointer
4128 # @param Rule for whom section is got
4129 # @retval True Successfully find section statement
4130 # @retval False Not able to find section statement
4132 def __GetRuleEncapsulationSection(self
, Rule
):
4134 if self
.__IsKeyword
( "COMPRESS"):
4136 if self
.__IsKeyword
("PI_STD") or self
.__IsKeyword
("PI_NONE"):
4139 if not self
.__IsToken
("{"):
4140 raise Warning("expected '{'", self
.FileName
, self
.CurrentLineNumber
)
4142 CompressSectionObj
= CompressSection
.CompressSection()
4144 CompressSectionObj
.CompType
= Type
4145 # Recursive sections...
4147 IsEncapsulate
= self
.__GetRuleEncapsulationSection
(CompressSectionObj
)
4148 IsLeaf
= self
.__GetEfiSection
(CompressSectionObj
)
4149 if not IsEncapsulate
and not IsLeaf
:
4152 if not self
.__IsToken
( "}"):
4153 raise Warning("expected '}'", self
.FileName
, self
.CurrentLineNumber
)
4154 Rule
.SectionList
.append(CompressSectionObj
)
4158 elif self
.__IsKeyword
( "GUIDED"):
4160 if self
.__GetNextGuid
():
4161 GuidValue
= self
.__Token
4163 if self
.__IsKeyword
( "$(NAMED_GUID)"):
4164 GuidValue
= self
.__Token
4166 AttribDict
= self
.__GetGuidAttrib
()
4168 if not self
.__IsToken
("{"):
4169 raise Warning("expected '{'", self
.FileName
, self
.CurrentLineNumber
)
4170 GuidSectionObj
= GuidSection
.GuidSection()
4171 GuidSectionObj
.NameGuid
= GuidValue
4172 GuidSectionObj
.SectionType
= "GUIDED"
4173 GuidSectionObj
.ProcessRequired
= AttribDict
["PROCESSING_REQUIRED"]
4174 GuidSectionObj
.AuthStatusValid
= AttribDict
["AUTH_STATUS_VALID"]
4175 GuidSectionObj
.ExtraHeaderSize
= AttribDict
["EXTRA_HEADER_SIZE"]
4179 IsEncapsulate
= self
.__GetRuleEncapsulationSection
(GuidSectionObj
)
4180 IsLeaf
= self
.__GetEfiSection
(GuidSectionObj
)
4181 if not IsEncapsulate
and not IsLeaf
:
4184 if not self
.__IsToken
( "}"):
4185 raise Warning("expected '}'", self
.FileName
, self
.CurrentLineNumber
)
4186 Rule
.SectionList
.append(GuidSectionObj
)
4192 ## __GetVtf() method
4194 # Get VTF section contents and store its data into VTF list of self.Profile
4196 # @param self The object pointer
4197 # @retval True Successfully find a VTF
4198 # @retval False Not able to find a VTF
4202 if not self
.__GetNextToken
():
4205 S
= self
.__Token
.upper()
4206 if S
.startswith("[") and not S
.startswith("[VTF."):
4207 self
.SectionParser(S
)
4212 if not self
.__IsToken
("[VTF.", True):
4213 FileLineTuple
= GetRealFileLine(self
.FileName
, self
.CurrentLineNumber
)
4214 #print 'Parsing String: %s in File %s, At line: %d, Offset Within Line: %d' \
4215 # % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine :], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine)
4216 raise Warning("expected [VTF.]", self
.FileName
, self
.CurrentLineNumber
)
4218 if not self
.__SkipToToken
("."):
4219 raise Warning("expected '.'", self
.FileName
, self
.CurrentLineNumber
)
4221 Arch
= self
.__SkippedChars
.rstrip(".").upper()
4222 if Arch
not in ("IA32", "X64", "IPF", "ARM", "AARCH64"):
4223 raise Warning("Unknown Arch '%s'" % Arch
, self
.FileName
, self
.CurrentLineNumber
)
4225 if not self
.__GetNextWord
():
4226 raise Warning("expected VTF name", self
.FileName
, self
.CurrentLineNumber
)
4227 Name
= self
.__Token
.upper()
4230 VtfObj
.UiName
= Name
4231 VtfObj
.KeyArch
= Arch
4233 if self
.__IsToken
(","):
4234 if not self
.__GetNextWord
():
4235 raise Warning("expected Arch list", self
.FileName
, self
.CurrentLineNumber
)
4236 if self
.__Token
.upper() not in ("IA32", "X64", "IPF", "ARM", "AARCH64"):
4237 raise Warning("Unknown Arch '%s'" % self
.__Token
, self
.FileName
, self
.CurrentLineNumber
)
4238 VtfObj
.ArchList
= self
.__Token
.upper()
4240 if not self
.__IsToken
( "]"):
4241 raise Warning("expected ']'", self
.FileName
, self
.CurrentLineNumber
)
4243 if self
.__IsKeyword
("IA32_RST_BIN"):
4244 if not self
.__IsToken
("="):
4245 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
4247 if not self
.__GetNextToken
():
4248 raise Warning("expected Reset file", self
.FileName
, self
.CurrentLineNumber
)
4250 VtfObj
.ResetBin
= self
.__Token
4251 if VtfObj
.ResetBin
.replace('$(WORKSPACE)', '').find('$') == -1:
4252 #check for file path
4253 ErrorCode
, ErrorInfo
= PathClass(NormPath(VtfObj
.ResetBin
), GenFdsGlobalVariable
.WorkSpaceDir
).Validate()
4255 EdkLogger
.error("GenFds", ErrorCode
, ExtraData
=ErrorInfo
)
4257 while self
.__GetComponentStatement
(VtfObj
):
4260 self
.Profile
.VtfList
.append(VtfObj
)
4263 ## __GetComponentStatement() method
4265 # Get components in VTF
4267 # @param self The object pointer
4268 # @param VtfObj for whom component is got
4269 # @retval True Successfully find a component
4270 # @retval False Not able to find a component
4272 def __GetComponentStatement(self
, VtfObj
):
4274 if not self
.__IsKeyword
("COMP_NAME"):
4277 if not self
.__IsToken
("="):
4278 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
4280 if not self
.__GetNextWord
():
4281 raise Warning("expected Component Name", self
.FileName
, self
.CurrentLineNumber
)
4283 CompStatementObj
= ComponentStatement
.ComponentStatement()
4284 CompStatementObj
.CompName
= self
.__Token
4286 if not self
.__IsKeyword
("COMP_LOC"):
4287 raise Warning("expected COMP_LOC", self
.FileName
, self
.CurrentLineNumber
)
4289 if not self
.__IsToken
("="):
4290 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
4292 CompStatementObj
.CompLoc
= ""
4293 if self
.__GetNextWord
():
4294 CompStatementObj
.CompLoc
= self
.__Token
4295 if self
.__IsToken
('|'):
4296 if not self
.__GetNextWord
():
4297 raise Warning("Expected Region Name", self
.FileName
, self
.CurrentLineNumber
)
4299 if self
.__Token
not in ("F", "N", "S"): #, "H", "L", "PH", "PL"): not support
4300 raise Warning("Unknown location type '%s'" % self
.__Token
, self
.FileName
, self
.CurrentLineNumber
)
4302 CompStatementObj
.FilePos
= self
.__Token
4304 self
.CurrentLineNumber
+= 1
4305 self
.CurrentOffsetWithinLine
= 0
4307 if not self
.__IsKeyword
("COMP_TYPE"):
4308 raise Warning("expected COMP_TYPE", self
.FileName
, self
.CurrentLineNumber
)
4310 if not self
.__IsToken
("="):
4311 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
4313 if not self
.__GetNextToken
():
4314 raise Warning("expected Component type", self
.FileName
, self
.CurrentLineNumber
)
4315 if self
.__Token
not in ("FIT", "PAL_B", "PAL_A", "OEM"):
4316 if not self
.__Token
.startswith("0x") or len(self
.__Token
) < 3 or len(self
.__Token
) > 4 or \
4317 not self
.__HexDigit
(self
.__Token
[2]) or not self
.__HexDigit
(self
.__Token
[-1]):
4318 raise Warning("Unknown location type '%s'" % self
.__Token
, self
.FileName
, self
.CurrentLineNumber
)
4319 CompStatementObj
.CompType
= self
.__Token
4321 if not self
.__IsKeyword
("COMP_VER"):
4322 raise Warning("expected COMP_VER", self
.FileName
, self
.CurrentLineNumber
)
4324 if not self
.__IsToken
("="):
4325 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
4327 if not self
.__GetNextToken
():
4328 raise Warning("expected Component version", self
.FileName
, self
.CurrentLineNumber
)
4330 Pattern
= re
.compile('-$|[0-9a-fA-F]{1,2}\.[0-9a-fA-F]{1,2}$', re
.DOTALL
)
4331 if Pattern
.match(self
.__Token
) == None:
4332 raise Warning("Unknown version format '%s'" % self
.__Token
, self
.FileName
, self
.CurrentLineNumber
)
4333 CompStatementObj
.CompVer
= self
.__Token
4335 if not self
.__IsKeyword
("COMP_CS"):
4336 raise Warning("expected COMP_CS", self
.FileName
, self
.CurrentLineNumber
)
4338 if not self
.__IsToken
("="):
4339 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
4341 if not self
.__GetNextToken
():
4342 raise Warning("expected Component CS", self
.FileName
, self
.CurrentLineNumber
)
4343 if self
.__Token
not in ("1", "0"):
4344 raise Warning("Unknown Component CS '%s'" % self
.__Token
, self
.FileName
, self
.CurrentLineNumber
)
4345 CompStatementObj
.CompCs
= self
.__Token
4348 if not self
.__IsKeyword
("COMP_BIN"):
4349 raise Warning("expected COMP_BIN", self
.FileName
, self
.CurrentLineNumber
)
4351 if not self
.__IsToken
("="):
4352 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
4354 if not self
.__GetNextToken
():
4355 raise Warning("expected Component file", self
.FileName
, self
.CurrentLineNumber
)
4357 CompStatementObj
.CompBin
= self
.__Token
4358 if CompStatementObj
.CompBin
!= '-' and CompStatementObj
.CompBin
.replace('$(WORKSPACE)', '').find('$') == -1:
4359 #check for file path
4360 ErrorCode
, ErrorInfo
= PathClass(NormPath(CompStatementObj
.CompBin
), GenFdsGlobalVariable
.WorkSpaceDir
).Validate()
4362 EdkLogger
.error("GenFds", ErrorCode
, ExtraData
=ErrorInfo
)
4364 if not self
.__IsKeyword
("COMP_SYM"):
4365 raise Warning("expected COMP_SYM", self
.FileName
, self
.CurrentLineNumber
)
4367 if not self
.__IsToken
("="):
4368 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
4370 if not self
.__GetNextToken
():
4371 raise Warning("expected Component symbol file", self
.FileName
, self
.CurrentLineNumber
)
4373 CompStatementObj
.CompSym
= self
.__Token
4374 if CompStatementObj
.CompSym
!= '-' and CompStatementObj
.CompSym
.replace('$(WORKSPACE)', '').find('$') == -1:
4375 #check for file path
4376 ErrorCode
, ErrorInfo
= PathClass(NormPath(CompStatementObj
.CompSym
), GenFdsGlobalVariable
.WorkSpaceDir
).Validate()
4378 EdkLogger
.error("GenFds", ErrorCode
, ExtraData
=ErrorInfo
)
4380 if not self
.__IsKeyword
("COMP_SIZE"):
4381 raise Warning("expected COMP_SIZE", self
.FileName
, self
.CurrentLineNumber
)
4383 if not self
.__IsToken
("="):
4384 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
4386 if self
.__IsToken
("-"):
4387 CompStatementObj
.CompSize
= self
.__Token
4388 elif self
.__GetNextDecimalNumber
():
4389 CompStatementObj
.CompSize
= self
.__Token
4390 elif self
.__GetNextHexNumber
():
4391 CompStatementObj
.CompSize
= self
.__Token
4393 raise Warning("Unknown size '%s'" % self
.__Token
, self
.FileName
, self
.CurrentLineNumber
)
4395 VtfObj
.ComponentStatementList
.append(CompStatementObj
)
4398 ## __GetOptionRom() method
4400 # Get OptionROM section contents and store its data into OptionROM list of self.Profile
4402 # @param self The object pointer
4403 # @retval True Successfully find a OptionROM
4404 # @retval False Not able to find a OptionROM
4406 def __GetOptionRom(self
):
4408 if not self
.__GetNextToken
():
4411 S
= self
.__Token
.upper()
4412 if S
.startswith("[") and not S
.startswith("[OPTIONROM."):
4413 self
.SectionParser(S
)
4418 if not self
.__IsToken
("[OptionRom.", True):
4419 raise Warning("Unknown Keyword '%s'" % self
.__Token
, self
.FileName
, self
.CurrentLineNumber
)
4421 OptRomName
= self
.__GetUiName
()
4423 if not self
.__IsToken
( "]"):
4424 raise Warning("expected ']'", self
.FileName
, self
.CurrentLineNumber
)
4426 OptRomObj
= OptionRom
.OPTIONROM()
4427 OptRomObj
.DriverName
= OptRomName
4428 self
.Profile
.OptRomDict
[OptRomName
] = OptRomObj
4431 isInf
= self
.__GetOptRomInfStatement
(OptRomObj
)
4432 isFile
= self
.__GetOptRomFileStatement
(OptRomObj
)
4433 if not isInf
and not isFile
:
4438 ## __GetOptRomInfStatement() method
4440 # Get INF statements
4442 # @param self The object pointer
4443 # @param Obj for whom inf statement is got
4444 # @retval True Successfully find inf statement
4445 # @retval False Not able to find inf statement
4447 def __GetOptRomInfStatement(self
, Obj
):
4449 if not self
.__IsKeyword
( "INF"):
4452 ffsInf
= OptRomInfStatement
.OptRomInfStatement()
4453 self
.__GetInfOptions
( ffsInf
)
4455 if not self
.__GetNextToken
():
4456 raise Warning("expected INF file path", self
.FileName
, self
.CurrentLineNumber
)
4457 ffsInf
.InfFileName
= self
.__Token
4458 if ffsInf
.InfFileName
.replace('$(WORKSPACE)', '').find('$') == -1:
4459 #check for file path
4460 ErrorCode
, ErrorInfo
= PathClass(NormPath(ffsInf
.InfFileName
), GenFdsGlobalVariable
.WorkSpaceDir
).Validate()
4462 EdkLogger
.error("GenFds", ErrorCode
, ExtraData
=ErrorInfo
)
4464 if not ffsInf
.InfFileName
in self
.Profile
.InfList
:
4465 self
.Profile
.InfList
.append(ffsInf
.InfFileName
)
4466 FileLineTuple
= GetRealFileLine(self
.FileName
, self
.CurrentLineNumber
)
4467 self
.Profile
.InfFileLineList
.append(FileLineTuple
)
4469 if ffsInf
.UseArch
not in self
.Profile
.InfDict
:
4470 self
.Profile
.InfDict
[ffsInf
.UseArch
] = [ffsInf
.InfFileName
]
4472 self
.Profile
.InfDict
[ffsInf
.UseArch
].append(ffsInf
.InfFileName
)
4474 self
.Profile
.InfDict
['ArchTBD'].append(ffsInf
.InfFileName
)
4477 self
.__GetOptRomOverrides
(ffsInf
)
4479 Obj
.FfsList
.append(ffsInf
)
4482 ## __GetOptRomOverrides() method
4484 # Get overrides for OptROM INF & FILE
4486 # @param self The object pointer
4487 # @param FfsInfObj for whom overrides is got
4489 def __GetOptRomOverrides(self
, Obj
):
4490 if self
.__IsToken
('{'):
4491 Overrides
= OptionRom
.OverrideAttribs()
4493 if self
.__IsKeyword
( "PCI_VENDOR_ID"):
4494 if not self
.__IsToken
( "="):
4495 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
4496 if not self
.__GetNextHexNumber
():
4497 raise Warning("expected Hex vendor id", self
.FileName
, self
.CurrentLineNumber
)
4498 Overrides
.PciVendorId
= self
.__Token
4501 if self
.__IsKeyword
( "PCI_CLASS_CODE"):
4502 if not self
.__IsToken
( "="):
4503 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
4504 if not self
.__GetNextHexNumber
():
4505 raise Warning("expected Hex class code", self
.FileName
, self
.CurrentLineNumber
)
4506 Overrides
.PciClassCode
= self
.__Token
4509 if self
.__IsKeyword
( "PCI_DEVICE_ID"):
4510 if not self
.__IsToken
( "="):
4511 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
4512 if not self
.__GetNextHexNumber
():
4513 raise Warning("expected Hex device id", self
.FileName
, self
.CurrentLineNumber
)
4515 Overrides
.PciDeviceId
= self
.__Token
4518 if self
.__IsKeyword
( "PCI_REVISION"):
4519 if not self
.__IsToken
( "="):
4520 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
4521 if not self
.__GetNextHexNumber
():
4522 raise Warning("expected Hex revision", self
.FileName
, self
.CurrentLineNumber
)
4523 Overrides
.PciRevision
= self
.__Token
4526 if self
.__IsKeyword
( "PCI_COMPRESS"):
4527 if not self
.__IsToken
( "="):
4528 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
4529 if not self
.__GetNextToken
():
4530 raise Warning("expected TRUE/FALSE for compress", self
.FileName
, self
.CurrentLineNumber
)
4531 Overrides
.NeedCompress
= self
.__Token
.upper() == 'TRUE'
4534 if self
.__IsToken
( "}"):
4537 EdkLogger
.error("FdfParser", FORMAT_INVALID
, File
=self
.FileName
, Line
=self
.CurrentLineNumber
)
4539 Obj
.OverrideAttribs
= Overrides
4541 ## __GetOptRomFileStatement() method
4543 # Get FILE statements
4545 # @param self The object pointer
4546 # @param Obj for whom FILE statement is got
4547 # @retval True Successfully find FILE statement
4548 # @retval False Not able to find FILE statement
4550 def __GetOptRomFileStatement(self
, Obj
):
4552 if not self
.__IsKeyword
( "FILE"):
4555 FfsFileObj
= OptRomFileStatement
.OptRomFileStatement()
4557 if not self
.__IsKeyword
("EFI") and not self
.__IsKeyword
("BIN"):
4558 raise Warning("expected Binary type (EFI/BIN)", self
.FileName
, self
.CurrentLineNumber
)
4559 FfsFileObj
.FileType
= self
.__Token
4561 if not self
.__GetNextToken
():
4562 raise Warning("expected File path", self
.FileName
, self
.CurrentLineNumber
)
4563 FfsFileObj
.FileName
= self
.__Token
4564 if FfsFileObj
.FileName
.replace('$(WORKSPACE)', '').find('$') == -1:
4565 #check for file path
4566 ErrorCode
, ErrorInfo
= PathClass(NormPath(FfsFileObj
.FileName
), GenFdsGlobalVariable
.WorkSpaceDir
).Validate()
4568 EdkLogger
.error("GenFds", ErrorCode
, ExtraData
=ErrorInfo
)
4570 if FfsFileObj
.FileType
== 'EFI':
4571 self
.__GetOptRomOverrides
(FfsFileObj
)
4573 Obj
.FfsList
.append(FfsFileObj
)
4577 ## __GetCapInFd() method
4579 # Get Cap list contained in FD
4581 # @param self The object pointer
4582 # @param FdName FD name
4583 # @retval CapList List of Capsule in FD
4585 def __GetCapInFd (self
, FdName
):
4588 if FdName
.upper() in self
.Profile
.FdDict
.keys():
4589 FdObj
= self
.Profile
.FdDict
[FdName
.upper()]
4590 for elementRegion
in FdObj
.RegionList
:
4591 if elementRegion
.RegionType
== 'CAPSULE':
4592 for elementRegionData
in elementRegion
.RegionDataList
:
4593 if elementRegionData
.endswith(".cap"):
4595 if elementRegionData
!= None and elementRegionData
.upper() not in CapList
:
4596 CapList
.append(elementRegionData
.upper())
4599 ## __GetReferencedFdCapTuple() method
4601 # Get FV and FD list referenced by a capsule image
4603 # @param self The object pointer
4604 # @param CapObj Capsule section to be searched
4605 # @param RefFdList referenced FD by section
4606 # @param RefFvList referenced FV by section
4608 def __GetReferencedFdCapTuple(self
, CapObj
, RefFdList
= [], RefFvList
= []):
4610 for CapsuleDataObj
in CapObj
.CapsuleDataList
:
4611 if hasattr(CapsuleDataObj
, 'FvName') and CapsuleDataObj
.FvName
!= None and CapsuleDataObj
.FvName
.upper() not in RefFvList
:
4612 RefFvList
.append (CapsuleDataObj
.FvName
.upper())
4613 elif hasattr(CapsuleDataObj
, 'FdName') and CapsuleDataObj
.FdName
!= None and CapsuleDataObj
.FdName
.upper() not in RefFdList
:
4614 RefFdList
.append (CapsuleDataObj
.FdName
.upper())
4615 elif CapsuleDataObj
.Ffs
!= None:
4616 if isinstance(CapsuleDataObj
.Ffs
, FfsFileStatement
.FileStatement
):
4617 if CapsuleDataObj
.Ffs
.FvName
!= None and CapsuleDataObj
.Ffs
.FvName
.upper() not in RefFvList
:
4618 RefFvList
.append(CapsuleDataObj
.Ffs
.FvName
.upper())
4619 elif CapsuleDataObj
.Ffs
.FdName
!= None and CapsuleDataObj
.Ffs
.FdName
.upper() not in RefFdList
:
4620 RefFdList
.append(CapsuleDataObj
.Ffs
.FdName
.upper())
4622 self
.__GetReferencedFdFvTupleFromSection
(CapsuleDataObj
.Ffs
, RefFdList
, RefFvList
)
4624 ## __GetFvInFd() method
4626 # Get FV list contained in FD
4628 # @param self The object pointer
4629 # @param FdName FD name
4630 # @retval FvList list of FV in FD
4632 def __GetFvInFd (self
, FdName
):
4635 if FdName
.upper() in self
.Profile
.FdDict
.keys():
4636 FdObj
= self
.Profile
.FdDict
[FdName
.upper()]
4637 for elementRegion
in FdObj
.RegionList
:
4638 if elementRegion
.RegionType
== 'FV':
4639 for elementRegionData
in elementRegion
.RegionDataList
:
4640 if elementRegionData
.endswith(".fv"):
4642 if elementRegionData
!= None and elementRegionData
.upper() not in FvList
:
4643 FvList
.append(elementRegionData
.upper())
4646 ## __GetReferencedFdFvTuple() method
4648 # Get FD and FV list referenced by a FFS file
4650 # @param self The object pointer
4651 # @param FfsFile contains sections to be searched
4652 # @param RefFdList referenced FD by section
4653 # @param RefFvList referenced FV by section
4655 def __GetReferencedFdFvTuple(self
, FvObj
, RefFdList
= [], RefFvList
= []):
4657 for FfsObj
in FvObj
.FfsList
:
4658 if isinstance(FfsObj
, FfsFileStatement
.FileStatement
):
4659 if FfsObj
.FvName
!= None and FfsObj
.FvName
.upper() not in RefFvList
:
4660 RefFvList
.append(FfsObj
.FvName
.upper())
4661 elif FfsObj
.FdName
!= None and FfsObj
.FdName
.upper() not in RefFdList
:
4662 RefFdList
.append(FfsObj
.FdName
.upper())
4664 self
.__GetReferencedFdFvTupleFromSection
(FfsObj
, RefFdList
, RefFvList
)
4666 ## __GetReferencedFdFvTupleFromSection() method
4668 # Get FD and FV list referenced by a FFS section
4670 # @param self The object pointer
4671 # @param FfsFile contains sections to be searched
4672 # @param FdList referenced FD by section
4673 # @param FvList referenced FV by section
4675 def __GetReferencedFdFvTupleFromSection(self
, FfsFile
, FdList
= [], FvList
= []):
4678 SectionStack
.extend(FfsFile
.SectionList
)
4679 while SectionStack
!= []:
4680 SectionObj
= SectionStack
.pop()
4681 if isinstance(SectionObj
, FvImageSection
.FvImageSection
):
4682 if SectionObj
.FvName
!= None and SectionObj
.FvName
.upper() not in FvList
:
4683 FvList
.append(SectionObj
.FvName
.upper())
4684 if SectionObj
.Fv
!= None and SectionObj
.Fv
.UiFvName
!= None and SectionObj
.Fv
.UiFvName
.upper() not in FvList
:
4685 FvList
.append(SectionObj
.Fv
.UiFvName
.upper())
4686 self
.__GetReferencedFdFvTuple
(SectionObj
.Fv
, FdList
, FvList
)
4688 if isinstance(SectionObj
, CompressSection
.CompressSection
) or isinstance(SectionObj
, GuidSection
.GuidSection
):
4689 SectionStack
.extend(SectionObj
.SectionList
)
4691 ## CycleReferenceCheck() method
4693 # Check whether cycle reference exists in FDF
4695 # @param self The object pointer
4696 # @retval True cycle reference exists
4697 # @retval False Not exists cycle reference
4699 def CycleReferenceCheck(self
):
4701 # Check the cycle between FV and FD image
4703 MaxLength
= len (self
.Profile
.FvDict
)
4704 for FvName
in self
.Profile
.FvDict
.keys():
4705 LogStr
= "\nCycle Reference Checking for FV: %s\n" % FvName
4707 RefFvStack
.append(FvName
)
4711 while RefFvStack
!= [] and Index
< MaxLength
:
4713 FvNameFromStack
= RefFvStack
.pop()
4714 if FvNameFromStack
.upper() in self
.Profile
.FvDict
.keys():
4715 FvObj
= self
.Profile
.FvDict
[FvNameFromStack
.upper()]
4721 self
.__GetReferencedFdFvTuple
(FvObj
, RefFdList
, RefFvList
)
4723 for RefFdName
in RefFdList
:
4724 if RefFdName
in FdAnalyzedList
:
4727 LogStr
+= "FV %s contains FD %s\n" % (FvNameFromStack
, RefFdName
)
4728 FvInFdList
= self
.__GetFvInFd
(RefFdName
)
4729 if FvInFdList
!= []:
4730 for FvNameInFd
in FvInFdList
:
4731 LogStr
+= "FD %s contains FV %s\n" % (RefFdName
,FvNameInFd
)
4732 if FvNameInFd
not in RefFvStack
:
4733 RefFvStack
.append(FvNameInFd
)
4735 if FvName
in RefFvStack
or FvNameFromStack
in RefFvStack
:
4736 EdkLogger
.info(LogStr
)
4738 FdAnalyzedList
.append(RefFdName
)
4740 for RefFvName
in RefFvList
:
4741 LogStr
+= "FV %s contains FV %s\n" % (FvNameFromStack
, RefFvName
)
4742 if RefFvName
not in RefFvStack
:
4743 RefFvStack
.append(RefFvName
)
4745 if FvName
in RefFvStack
or FvNameFromStack
in RefFvStack
:
4746 EdkLogger
.info(LogStr
)
4750 # Check the cycle between Capsule and FD image
4752 MaxLength
= len (self
.Profile
.CapsuleDict
)
4753 for CapName
in self
.Profile
.CapsuleDict
.keys():
4755 # Capsule image to be checked.
4757 LogStr
= "\n\n\nCycle Reference Checking for Capsule: %s\n" % CapName
4759 RefCapStack
.append(CapName
)
4764 while RefCapStack
!= [] and Index
< MaxLength
:
4766 CapNameFromStack
= RefCapStack
.pop()
4767 if CapNameFromStack
.upper() in self
.Profile
.CapsuleDict
.keys():
4768 CapObj
= self
.Profile
.CapsuleDict
[CapNameFromStack
.upper()]
4774 self
.__GetReferencedFdCapTuple
(CapObj
, RefFdList
, RefFvList
)
4778 while FvListLength
< len (RefFvList
) or FdListLength
< len (RefFdList
):
4779 for RefFdName
in RefFdList
:
4780 if RefFdName
in FdAnalyzedList
:
4783 LogStr
+= "Capsule %s contains FD %s\n" % (CapNameFromStack
, RefFdName
)
4784 CapInFdList
= self
.__GetCapInFd
(RefFdName
)
4785 if CapInFdList
!= []:
4786 for CapNameInFd
in CapInFdList
:
4787 LogStr
+= "FD %s contains Capsule %s\n" % (RefFdName
,CapNameInFd
)
4788 if CapNameInFd
not in RefCapStack
:
4789 RefCapStack
.append(CapNameInFd
)
4791 if CapName
in RefCapStack
or CapNameFromStack
in RefCapStack
:
4792 EdkLogger
.info(LogStr
)
4795 FvInFdList
= self
.__GetFvInFd
(RefFdName
)
4796 if FvInFdList
!= []:
4797 for FvNameInFd
in FvInFdList
:
4798 LogStr
+= "FD %s contains FV %s\n" % (RefFdName
,FvNameInFd
)
4799 if FvNameInFd
not in RefFvList
:
4800 RefFvList
.append(FvNameInFd
)
4802 FdAnalyzedList
.append(RefFdName
)
4804 # the number of the parsed FV and FD image
4806 FvListLength
= len (RefFvList
)
4807 FdListLength
= len (RefFdList
)
4808 for RefFvName
in RefFvList
:
4809 if RefFvName
in FvAnalyzedList
:
4811 LogStr
+= "Capsule %s contains FV %s\n" % (CapNameFromStack
, RefFvName
)
4812 if RefFvName
.upper() in self
.Profile
.FvDict
.keys():
4813 FvObj
= self
.Profile
.FvDict
[RefFvName
.upper()]
4816 self
.__GetReferencedFdFvTuple
(FvObj
, RefFdList
, RefFvList
)
4817 FvAnalyzedList
.append(RefFvName
)
4821 def GetAllIncludedFile (self
):
4822 global AllIncludeFileList
4823 return AllIncludeFileList
4825 if __name__
== "__main__":
4828 test_file
= sys
.argv
[1]
4829 except IndexError, v
:
4830 print "Usage: %s filename" % sys
.argv
[0]
4833 parser
= FdfParser(test_file
)
4836 parser
.CycleReferenceCheck()