4 # Copyright (c) 2007 - 2016, 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
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()
174 EdkLogger
.error("FdfParser", FILE_OPEN_FAILURE
, ExtraData
=FileName
)
176 self
.InsertStartLineNumber
= None
177 self
.InsertAdjust
= 0
178 self
.IncludeFileList
= []
179 self
.Level
= 1 # first level include file
181 def GetTotalLines(self
):
182 TotalLines
= self
.InsertAdjust
+ len(self
.FileLinesList
)
184 for Profile
in self
.IncludeFileList
:
185 TotalLines
+= Profile
.GetTotalLines()
189 def IsLineInFile(self
, Line
):
190 if Line
>= self
.InsertStartLineNumber
and Line
< self
.InsertStartLineNumber
+ self
.GetTotalLines():
195 def GetLineInFile(self
, Line
):
196 if not self
.IsLineInFile (Line
):
197 return (self
.FileName
, -1)
199 InsertedLines
= self
.InsertStartLineNumber
201 for Profile
in self
.IncludeFileList
:
202 if Profile
.IsLineInFile(Line
):
203 return Profile
.GetLineInFile(Line
)
204 elif Line
>= Profile
.InsertStartLineNumber
:
205 InsertedLines
+= Profile
.GetTotalLines()
207 return (self
.FileName
, Line
- InsertedLines
+ 1)
211 ## The FDF content class that used to record file data when parsing FDF
213 # May raise Exception when opening file.
218 # @param self The object pointer
219 # @param FileName The file that to be parsed
221 def __init__(self
, FileName
):
222 self
.FileLinesList
= []
224 fsock
= open(FileName
, "rb", 0)
226 self
.FileLinesList
= fsock
.readlines()
231 EdkLogger
.error("FdfParser", FILE_OPEN_FAILURE
, ExtraData
=FileName
)
236 self
.InfDict
= {'ArchTBD':[]}
237 # ECC will use this Dict and List information
238 self
.PcdFileLineDict
= {}
239 self
.InfFileLineList
= []
242 self
.FdNameNotSet
= False
244 self
.CapsuleDict
= {}
248 self
.FmpPayloadDict
= {}
250 ## The syntax parser for FDF
252 # PreprocessFile method should be called prior to ParseFile
253 # CycleReferenceCheck method can detect cycles in FDF contents
255 # GetNext*** procedures mean these procedures will get next token first, then make judgement.
256 # Get*** procedures mean these procedures will make judgement on current token only.
261 # @param self The object pointer
262 # @param FileName The file that to be parsed
264 def __init__(self
, FileName
):
265 self
.Profile
= FileProfile(FileName
)
266 self
.FileName
= FileName
267 self
.CurrentLineNumber
= 1
268 self
.CurrentOffsetWithinLine
= 0
269 self
.CurrentFdName
= None
270 self
.CurrentFvName
= None
272 self
.__SkippedChars
= ""
273 GlobalData
.gFdfParser
= self
275 # Used to section info
276 self
.__CurSection
= []
277 # Key: [section name, UI name, arch]
278 # Value: {MACRO_NAME : MACRO_VALUE}
279 self
.__MacroDict
= tdict(True, 3)
282 self
.__WipeOffArea
= []
283 if GenFdsGlobalVariable
.WorkSpaceDir
== '':
284 GenFdsGlobalVariable
.WorkSpaceDir
= os
.getenv("WORKSPACE")
286 ## __IsWhiteSpace() method
288 # Whether char at current FileBufferPos is whitespace
290 # @param self The object pointer
291 # @param Char The char to test
292 # @retval True The char is a kind of white space
293 # @retval False The char is NOT a kind of white space
295 def __IsWhiteSpace(self
, Char
):
296 if Char
in (T_CHAR_NULL
, T_CHAR_CR
, T_CHAR_SPACE
, T_CHAR_TAB
, T_CHAR_LF
):
301 ## __SkipWhiteSpace() method
303 # Skip white spaces from current char, return number of chars skipped
305 # @param self The object pointer
306 # @retval Count The number of chars skipped
308 def __SkipWhiteSpace(self
):
310 while not self
.__EndOfFile
():
312 if self
.__CurrentChar
() in (T_CHAR_NULL
, T_CHAR_CR
, T_CHAR_LF
, T_CHAR_SPACE
, T_CHAR_TAB
):
313 self
.__SkippedChars
+= str(self
.__CurrentChar
())
320 ## __EndOfFile() method
322 # Judge current buffer pos is at file end
324 # @param self The object pointer
325 # @retval True Current File buffer position is at file end
326 # @retval False Current File buffer position is NOT at file end
328 def __EndOfFile(self
):
329 NumberOfLines
= len(self
.Profile
.FileLinesList
)
330 SizeOfLastLine
= len(self
.Profile
.FileLinesList
[-1])
331 if self
.CurrentLineNumber
== NumberOfLines
and self
.CurrentOffsetWithinLine
>= SizeOfLastLine
- 1:
333 elif self
.CurrentLineNumber
> NumberOfLines
:
338 ## __EndOfLine() method
340 # Judge current buffer pos is at line end
342 # @param self The object pointer
343 # @retval True Current File buffer position is at line end
344 # @retval False Current File buffer position is NOT at line end
346 def __EndOfLine(self
):
347 if self
.CurrentLineNumber
> len(self
.Profile
.FileLinesList
):
349 SizeOfCurrentLine
= len(self
.Profile
.FileLinesList
[self
.CurrentLineNumber
- 1])
350 if self
.CurrentOffsetWithinLine
>= SizeOfCurrentLine
:
357 # Reset file data buffer to the initial state
359 # @param self The object pointer
360 # @param DestLine Optional new destination line number.
361 # @param DestOffset Optional new destination offset.
363 def Rewind(self
, DestLine
= 1, DestOffset
= 0):
364 self
.CurrentLineNumber
= DestLine
365 self
.CurrentOffsetWithinLine
= DestOffset
367 ## __UndoOneChar() method
369 # Go back one char in the file buffer
371 # @param self The object pointer
372 # @retval True Successfully go back one char
373 # @retval False Not able to go back one char as file beginning reached
375 def __UndoOneChar(self
):
377 if self
.CurrentLineNumber
== 1 and self
.CurrentOffsetWithinLine
== 0:
379 elif self
.CurrentOffsetWithinLine
== 0:
380 self
.CurrentLineNumber
-= 1
381 self
.CurrentOffsetWithinLine
= len(self
.__CurrentLine
()) - 1
383 self
.CurrentOffsetWithinLine
-= 1
386 ## __GetOneChar() method
388 # Move forward one char in the file buffer
390 # @param self The object pointer
392 def __GetOneChar(self
):
393 if self
.CurrentOffsetWithinLine
== len(self
.Profile
.FileLinesList
[self
.CurrentLineNumber
- 1]) - 1:
394 self
.CurrentLineNumber
+= 1
395 self
.CurrentOffsetWithinLine
= 0
397 self
.CurrentOffsetWithinLine
+= 1
399 ## __CurrentChar() method
401 # Get the char pointed to by the file buffer pointer
403 # @param self The object pointer
404 # @retval Char Current char
406 def __CurrentChar(self
):
407 return self
.Profile
.FileLinesList
[self
.CurrentLineNumber
- 1][self
.CurrentOffsetWithinLine
]
409 ## __NextChar() method
411 # Get the one char pass the char pointed to by the file buffer pointer
413 # @param self The object pointer
414 # @retval Char Next char
416 def __NextChar(self
):
417 if self
.CurrentOffsetWithinLine
== len(self
.Profile
.FileLinesList
[self
.CurrentLineNumber
- 1]) - 1:
418 return self
.Profile
.FileLinesList
[self
.CurrentLineNumber
][0]
420 return self
.Profile
.FileLinesList
[self
.CurrentLineNumber
- 1][self
.CurrentOffsetWithinLine
+ 1]
422 ## __SetCurrentCharValue() method
424 # Modify the value of current char
426 # @param self The object pointer
427 # @param Value The new value of current char
429 def __SetCurrentCharValue(self
, Value
):
430 self
.Profile
.FileLinesList
[self
.CurrentLineNumber
- 1][self
.CurrentOffsetWithinLine
] = Value
432 ## __CurrentLine() method
434 # Get the list that contains current line contents
436 # @param self The object pointer
437 # @retval List current line contents
439 def __CurrentLine(self
):
440 return self
.Profile
.FileLinesList
[self
.CurrentLineNumber
- 1]
442 def __StringToList(self
):
443 self
.Profile
.FileLinesList
= [list(s
) for s
in self
.Profile
.FileLinesList
]
444 self
.Profile
.FileLinesList
[-1].append(' ')
446 def __ReplaceFragment(self
, StartPos
, EndPos
, Value
= ' '):
447 if StartPos
[0] == EndPos
[0]:
449 while Offset
<= EndPos
[1]:
450 self
.Profile
.FileLinesList
[StartPos
[0]][Offset
] = Value
455 while self
.Profile
.FileLinesList
[StartPos
[0]][Offset
] not in ('\r', '\n'):
456 self
.Profile
.FileLinesList
[StartPos
[0]][Offset
] = Value
460 while Line
< EndPos
[0]:
462 while self
.Profile
.FileLinesList
[Line
][Offset
] not in ('\r', '\n'):
463 self
.Profile
.FileLinesList
[Line
][Offset
] = Value
468 while Offset
<= EndPos
[1]:
469 self
.Profile
.FileLinesList
[EndPos
[0]][Offset
] = Value
473 def __GetMacroName(self
):
474 if not self
.__GetNextToken
():
475 raise Warning("expected Macro name", self
.FileName
, self
.CurrentLineNumber
)
476 MacroName
= self
.__Token
478 if MacroName
.startswith('!'):
480 MacroName
= MacroName
[1:].strip()
482 if not MacroName
.startswith('$(') or not MacroName
.endswith(')'):
483 raise Warning("Macro name expected(Please use '$(%(Token)s)' if '%(Token)s' is a macro.)" % {"Token" : MacroName
},
484 self
.FileName
, self
.CurrentLineNumber
)
485 MacroName
= MacroName
[2:-1]
486 return MacroName
, NotFlag
488 def __SetMacroValue(self
, Macro
, Value
):
489 if not self
.__CurSection
:
493 if not self
.__MacroDict
[self
.__CurSection
[0], self
.__CurSection
[1], self
.__CurSection
[2]]:
494 self
.__MacroDict
[self
.__CurSection
[0], self
.__CurSection
[1], self
.__CurSection
[2]] = MacroDict
496 MacroDict
= self
.__MacroDict
[self
.__CurSection
[0], self
.__CurSection
[1], self
.__CurSection
[2]]
497 MacroDict
[Macro
] = Value
499 def __GetMacroValue(self
, Macro
):
501 if Macro
in GlobalData
.gCommandLineDefines
:
502 return GlobalData
.gCommandLineDefines
[Macro
]
503 if Macro
in GlobalData
.gGlobalDefines
:
504 return GlobalData
.gGlobalDefines
[Macro
]
506 if self
.__CurSection
:
507 MacroDict
= self
.__MacroDict
[
508 self
.__CurSection
[0],
509 self
.__CurSection
[1],
512 if MacroDict
and Macro
in MacroDict
:
513 return MacroDict
[Macro
]
516 if Macro
in GlobalData
.gPlatformDefines
:
517 return GlobalData
.gPlatformDefines
[Macro
]
520 def __SectionHeaderParser(self
, Section
):
522 # [FD.UiName]: use dummy instead if UI name is optional
525 # [Rule]: don't take rule section into account, macro is not allowed in this section
526 # [VTF.arch.UiName, arch]
527 # [OptionRom.DriverName]
528 self
.__CurSection
= []
529 Section
= Section
.strip()[1:-1].upper().replace(' ', '').strip('.')
530 ItemList
= Section
.split('.')
532 if Item
== '' or Item
== 'RULE':
535 if Item
== 'DEFINES':
536 self
.__CurSection
= ['COMMON', 'COMMON', 'COMMON']
537 elif Item
== 'VTF' and len(ItemList
) == 3:
539 Pos
= UiName
.find(',')
541 UiName
= UiName
[:Pos
]
542 self
.__CurSection
= ['VTF', UiName
, ItemList
[1]]
543 elif len(ItemList
) > 1:
544 self
.__CurSection
= [ItemList
[0], ItemList
[1], 'COMMON']
545 elif len(ItemList
) > 0:
546 self
.__CurSection
= [ItemList
[0], 'DUMMY', 'COMMON']
548 ## PreprocessFile() method
550 # Preprocess file contents, replace comments with spaces.
551 # In the end, rewind the file buffer pointer to the beginning
552 # BUGBUG: No !include statement processing contained in this procedure
553 # !include statement should be expanded at the same FileLinesList[CurrentLineNumber - 1]
555 # @param self The object pointer
557 def PreprocessFile(self
):
561 DoubleSlashComment
= False
563 # HashComment in quoted string " " is ignored.
566 while not self
.__EndOfFile
():
568 if self
.__CurrentChar
() == T_CHAR_DOUBLE_QUOTE
and not InComment
:
569 InString
= not InString
570 # meet new line, then no longer in a comment for // and '#'
571 if self
.__CurrentChar
() == T_CHAR_LF
:
572 self
.CurrentLineNumber
+= 1
573 self
.CurrentOffsetWithinLine
= 0
574 if InComment
and DoubleSlashComment
:
576 DoubleSlashComment
= False
577 if InComment
and HashComment
:
580 # check for */ comment end
581 elif InComment
and not DoubleSlashComment
and not HashComment
and self
.__CurrentChar
() == T_CHAR_STAR
and self
.__NextChar
() == T_CHAR_SLASH
:
582 self
.__SetCurrentCharValue
(T_CHAR_SPACE
)
584 self
.__SetCurrentCharValue
(T_CHAR_SPACE
)
587 # set comments to spaces
589 self
.__SetCurrentCharValue
(T_CHAR_SPACE
)
591 # check for // comment
592 elif self
.__CurrentChar
() == T_CHAR_SLASH
and self
.__NextChar
() == T_CHAR_SLASH
and not self
.__EndOfLine
():
594 DoubleSlashComment
= True
595 # check for '#' comment
596 elif self
.__CurrentChar
() == T_CHAR_HASH
and not self
.__EndOfLine
() and not InString
:
599 # check for /* comment start
600 elif self
.__CurrentChar
() == T_CHAR_SLASH
and self
.__NextChar
() == T_CHAR_STAR
:
601 self
.__SetCurrentCharValue
( T_CHAR_SPACE
)
603 self
.__SetCurrentCharValue
( T_CHAR_SPACE
)
609 # restore from ListOfList to ListOfString
610 self
.Profile
.FileLinesList
= ["".join(list) for list in self
.Profile
.FileLinesList
]
613 ## PreprocessIncludeFile() method
615 # Preprocess file contents, replace !include statements with file contents.
616 # In the end, rewind the file buffer pointer to the beginning
618 # @param self The object pointer
620 def PreprocessIncludeFile(self
):
621 # nested include support
623 while self
.__GetNextToken
():
625 if self
.__Token
== '!include':
627 IncludeLine
= self
.CurrentLineNumber
628 IncludeOffset
= self
.CurrentOffsetWithinLine
- len('!include')
629 if not self
.__GetNextToken
():
630 raise Warning("expected include file name", self
.FileName
, self
.CurrentLineNumber
)
631 IncFileName
= self
.__Token
633 for Macro
in ['WORKSPACE', 'ECP_SOURCE', 'EFI_SOURCE', 'EDK_SOURCE']:
634 MacroVal
= self
.__GetMacroValue
(Macro
)
636 __IncludeMacros
[Macro
] = MacroVal
639 IncludedFile
= NormPath(ReplaceMacro(IncFileName
, __IncludeMacros
, RaiseError
=True))
641 raise Warning("only these system environment variables are permitted to start the path of the included file: "
642 "$(WORKSPACE), $(ECP_SOURCE), $(EFI_SOURCE), $(EDK_SOURCE)",
643 self
.FileName
, self
.CurrentLineNumber
)
645 # First search the include file under the same directory as FDF file
647 IncludedFile1
= PathClass(IncludedFile
, os
.path
.dirname(self
.FileName
))
648 ErrorCode
= IncludedFile1
.Validate()[0]
651 # Then search the include file under the same directory as DSC file
654 if GenFdsGlobalVariable
.ActivePlatform
:
655 PlatformDir
= GenFdsGlobalVariable
.ActivePlatform
.Dir
656 elif GlobalData
.gActivePlatform
:
657 PlatformDir
= GlobalData
.gActivePlatform
.MetaFile
.Dir
658 IncludedFile1
= PathClass(IncludedFile
, PlatformDir
)
659 ErrorCode
= IncludedFile1
.Validate()[0]
662 # Also search file under the WORKSPACE directory
664 IncludedFile1
= PathClass(IncludedFile
, GlobalData
.gWorkspace
)
665 ErrorCode
= IncludedFile1
.Validate()[0]
667 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
),
668 self
.FileName
, self
.CurrentLineNumber
)
670 if not IsValidInclude (IncludedFile1
.Path
, self
.CurrentLineNumber
):
671 raise Warning("The include file {0} is causing a include loop.\n".format (IncludedFile1
.Path
), self
.FileName
, self
.CurrentLineNumber
)
673 IncFileProfile
= IncludeFileProfile(IncludedFile1
.Path
)
675 CurrentLine
= self
.CurrentLineNumber
676 CurrentOffset
= self
.CurrentOffsetWithinLine
677 # list index of the insertion, note that line number is 'CurrentLine + 1'
678 InsertAtLine
= CurrentLine
679 ParentProfile
= GetParentAtLine (CurrentLine
)
680 if ParentProfile
!= None:
681 ParentProfile
.IncludeFileList
.insert(0, IncFileProfile
)
682 IncFileProfile
.Level
= ParentProfile
.Level
+ 1
683 IncFileProfile
.InsertStartLineNumber
= InsertAtLine
+ 1
684 # deal with remaining portions after "!include filename", if exists.
685 if self
.__GetNextToken
():
686 if self
.CurrentLineNumber
== CurrentLine
:
687 RemainingLine
= self
.__CurrentLine
()[CurrentOffset
:]
688 self
.Profile
.FileLinesList
.insert(self
.CurrentLineNumber
, RemainingLine
)
689 IncFileProfile
.InsertAdjust
+= 1
690 self
.CurrentLineNumber
+= 1
691 self
.CurrentOffsetWithinLine
= 0
693 for Line
in IncFileProfile
.FileLinesList
:
694 self
.Profile
.FileLinesList
.insert(InsertAtLine
, Line
)
695 self
.CurrentLineNumber
+= 1
698 # reversely sorted to better determine error in file
699 AllIncludeFileList
.insert(0, IncFileProfile
)
701 # comment out the processed include file statement
702 TempList
= list(self
.Profile
.FileLinesList
[IncludeLine
- 1])
703 TempList
.insert(IncludeOffset
, '#')
704 self
.Profile
.FileLinesList
[IncludeLine
- 1] = ''.join(TempList
)
705 if Processed
: # Nested and back-to-back support
706 self
.Rewind(DestLine
= IncFileProfile
.InsertStartLineNumber
- 1)
711 def __GetIfListCurrentItemStat(self
, IfList
):
721 ## PreprocessConditionalStatement() method
723 # Preprocess conditional statement.
724 # In the end, rewind the file buffer pointer to the beginning
726 # @param self The object pointer
728 def PreprocessConditionalStatement(self
):
729 # IfList is a stack of if branches with elements of list [Pos, CondSatisfied, BranchDetermined]
733 while self
.__GetNextToken
():
734 # Determine section name and the location dependent macro
735 if self
.__GetIfListCurrentItemStat
(IfList
):
736 if self
.__Token
.startswith('['):
737 Header
= self
.__Token
738 if not self
.__Token
.endswith(']'):
739 self
.__SkipToToken
(']')
740 Header
+= self
.__SkippedChars
741 if Header
.find('$(') != -1:
742 raise Warning("macro cannot be used in section header", self
.FileName
, self
.CurrentLineNumber
)
743 self
.__SectionHeaderParser
(Header
)
745 # Replace macros except in RULE section or out of section
746 elif self
.__CurSection
and ReplacedLine
!= self
.CurrentLineNumber
:
747 ReplacedLine
= self
.CurrentLineNumber
749 CurLine
= self
.Profile
.FileLinesList
[ReplacedLine
- 1]
751 StartPos
= CurLine
.find('$(', PreIndex
)
752 EndPos
= CurLine
.find(')', StartPos
+2)
753 while StartPos
!= -1 and EndPos
!= -1 and self
.__Token
not in ['!ifdef', '!ifndef', '!if', '!elseif']:
754 MacroName
= CurLine
[StartPos
+2 : EndPos
]
755 MacorValue
= self
.__GetMacroValue
(MacroName
)
756 if MacorValue
!= None:
757 CurLine
= CurLine
.replace('$(' + MacroName
+ ')', MacorValue
, 1)
758 if MacorValue
.find('$(') != -1:
761 PreIndex
= StartPos
+ len(MacorValue
)
763 PreIndex
= EndPos
+ 1
764 StartPos
= CurLine
.find('$(', PreIndex
)
765 EndPos
= CurLine
.find(')', StartPos
+2)
766 self
.Profile
.FileLinesList
[ReplacedLine
- 1] = CurLine
769 if self
.__Token
== 'DEFINE':
770 if self
.__GetIfListCurrentItemStat
(IfList
):
771 if not self
.__CurSection
:
772 raise Warning("macro cannot be defined in Rule section or out of section", self
.FileName
, self
.CurrentLineNumber
)
773 DefineLine
= self
.CurrentLineNumber
- 1
774 DefineOffset
= self
.CurrentOffsetWithinLine
- len('DEFINE')
775 if not self
.__GetNextToken
():
776 raise Warning("expected Macro name", self
.FileName
, self
.CurrentLineNumber
)
778 if not self
.__IsToken
( "="):
779 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
781 Value
= self
.__GetExpression
()
782 self
.__SetMacroValue
(Macro
, Value
)
783 self
.__WipeOffArea
.append(((DefineLine
, DefineOffset
), (self
.CurrentLineNumber
- 1, self
.CurrentOffsetWithinLine
- 1)))
784 elif self
.__Token
== 'SET':
785 if not self
.__GetIfListCurrentItemStat
(IfList
):
787 SetLine
= self
.CurrentLineNumber
- 1
788 SetOffset
= self
.CurrentOffsetWithinLine
- len('SET')
789 PcdPair
= self
.__GetNextPcdName
()
790 PcdName
= "%s.%s" % (PcdPair
[1], PcdPair
[0])
791 if not self
.__IsToken
( "="):
792 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
794 Value
= self
.__GetExpression
()
795 Value
= self
.__EvaluateConditional
(Value
, self
.CurrentLineNumber
, 'eval', True)
797 self
.__PcdDict
[PcdName
] = Value
799 self
.Profile
.PcdDict
[PcdPair
] = Value
800 FileLineTuple
= GetRealFileLine(self
.FileName
, self
.CurrentLineNumber
)
801 self
.Profile
.PcdFileLineDict
[PcdPair
] = FileLineTuple
803 self
.__WipeOffArea
.append(((SetLine
, SetOffset
), (self
.CurrentLineNumber
- 1, self
.CurrentOffsetWithinLine
- 1)))
804 elif self
.__Token
in ('!ifdef', '!ifndef', '!if'):
805 IfStartPos
= (self
.CurrentLineNumber
- 1, self
.CurrentOffsetWithinLine
- len(self
.__Token
))
806 IfList
.append([IfStartPos
, None, None])
808 CondLabel
= self
.__Token
809 Expression
= self
.__GetExpression
()
811 if CondLabel
== '!if':
812 ConditionSatisfied
= self
.__EvaluateConditional
(Expression
, IfList
[-1][0][0] + 1, 'eval')
814 ConditionSatisfied
= self
.__EvaluateConditional
(Expression
, IfList
[-1][0][0] + 1, 'in')
815 if CondLabel
== '!ifndef':
816 ConditionSatisfied
= not ConditionSatisfied
818 BranchDetermined
= ConditionSatisfied
819 IfList
[-1] = [IfList
[-1][0], ConditionSatisfied
, BranchDetermined
]
820 if ConditionSatisfied
:
821 self
.__WipeOffArea
.append((IfList
[-1][0], (self
.CurrentLineNumber
- 1, self
.CurrentOffsetWithinLine
- 1)))
822 elif self
.__Token
in ('!elseif', '!else'):
823 ElseStartPos
= (self
.CurrentLineNumber
- 1, self
.CurrentOffsetWithinLine
- len(self
.__Token
))
825 raise Warning("Missing !if statement", self
.FileName
, self
.CurrentLineNumber
)
828 IfList
[-1] = [ElseStartPos
, False, True]
829 self
.__WipeOffArea
.append((ElseStartPos
, (self
.CurrentLineNumber
- 1, self
.CurrentOffsetWithinLine
- 1)))
831 self
.__WipeOffArea
.append((IfList
[-1][0], ElseStartPos
))
832 IfList
[-1] = [ElseStartPos
, True, IfList
[-1][2]]
833 if self
.__Token
== '!elseif':
834 Expression
= self
.__GetExpression
()
835 ConditionSatisfied
= self
.__EvaluateConditional
(Expression
, IfList
[-1][0][0] + 1, 'eval')
836 IfList
[-1] = [IfList
[-1][0], ConditionSatisfied
, IfList
[-1][2]]
840 IfList
[-1][1] = False
843 self
.__WipeOffArea
.append((IfList
[-1][0], (self
.CurrentLineNumber
- 1, self
.CurrentOffsetWithinLine
- 1)))
844 elif self
.__Token
== '!endif':
846 raise Warning("Missing !if statement", self
.FileName
, self
.CurrentLineNumber
)
848 self
.__WipeOffArea
.append(((self
.CurrentLineNumber
- 1, self
.CurrentOffsetWithinLine
- len('!endif')), (self
.CurrentLineNumber
- 1, self
.CurrentOffsetWithinLine
- 1)))
850 self
.__WipeOffArea
.append((IfList
[-1][0], (self
.CurrentLineNumber
- 1, self
.CurrentOffsetWithinLine
- 1)))
853 elif not IfList
: # Don't use PCDs inside conditional directive
854 if self
.CurrentLineNumber
<= RegionLayoutLine
:
855 # Don't try the same line twice
857 SetPcd
= ShortcutPcdPattern
.match(self
.Profile
.FileLinesList
[self
.CurrentLineNumber
- 1])
859 self
.__PcdDict
[SetPcd
.group('name')] = SetPcd
.group('value')
860 RegionLayoutLine
= self
.CurrentLineNumber
862 RegionSize
= RegionSizePattern
.match(self
.Profile
.FileLinesList
[self
.CurrentLineNumber
- 1])
864 RegionLayoutLine
= self
.CurrentLineNumber
866 RegionSizeGuid
= RegionSizeGuidPattern
.match(self
.Profile
.FileLinesList
[self
.CurrentLineNumber
])
867 if not RegionSizeGuid
:
868 RegionLayoutLine
= self
.CurrentLineNumber
+ 1
870 self
.__PcdDict
[RegionSizeGuid
.group('base')] = RegionSize
.group('base')
871 self
.__PcdDict
[RegionSizeGuid
.group('size')] = RegionSize
.group('size')
872 RegionLayoutLine
= self
.CurrentLineNumber
+ 1
875 raise Warning("Missing !endif", self
.FileName
, self
.CurrentLineNumber
)
878 def __CollectMacroPcd(self
):
882 MacroDict
.update(GlobalData
.gPlatformPcds
)
883 MacroDict
.update(self
.__PcdDict
)
886 MacroDict
.update(GlobalData
.gPlatformDefines
)
888 if self
.__CurSection
:
890 ScopeMacro
= self
.__MacroDict
['COMMON', 'COMMON', 'COMMON']
892 MacroDict
.update(ScopeMacro
)
895 ScopeMacro
= self
.__MacroDict
[
896 self
.__CurSection
[0],
897 self
.__CurSection
[1],
901 MacroDict
.update(ScopeMacro
)
903 MacroDict
.update(GlobalData
.gGlobalDefines
)
904 MacroDict
.update(GlobalData
.gCommandLineDefines
)
909 def __EvaluateConditional(self
, Expression
, Line
, Op
= None, Value
= None):
910 FileLineTuple
= GetRealFileLine(self
.FileName
, Line
)
911 MacroPcdDict
= self
.__CollectMacroPcd
()
915 return ValueExpression(Expression
, MacroPcdDict
)(True)
917 return ValueExpression(Expression
, MacroPcdDict
)()
918 except WrnExpression
, Excpt
:
920 # Catch expression evaluation warning here. We need to report
921 # the precise number of line and return the evaluation result
923 EdkLogger
.warn('Parser', "Suspicious expression: %s" % str(Excpt
),
924 File
=self
.FileName
, ExtraData
=self
.__CurrentLine
(),
927 except Exception, Excpt
:
928 if hasattr(Excpt
, 'Pcd'):
929 if Excpt
.Pcd
in GlobalData
.gPlatformOtherPcds
:
930 Info
= GlobalData
.gPlatformOtherPcds
[Excpt
.Pcd
]
931 raise Warning("Cannot use this PCD (%s) in an expression as"
932 " it must be defined in a [PcdsFixedAtBuild] or [PcdsFeatureFlag] section"
933 " of the DSC file (%s), and it is currently defined in this section:"
934 " %s, line #: %d." % (Excpt
.Pcd
, GlobalData
.gPlatformOtherPcds
['DSCFILE'], Info
[0], Info
[1]),
937 raise Warning("PCD (%s) is not defined in DSC file (%s)" % (Excpt
.Pcd
, GlobalData
.gPlatformOtherPcds
['DSCFILE']),
940 raise Warning(str(Excpt
), *FileLineTuple
)
942 if Expression
.startswith('$(') and Expression
[-1] == ')':
943 Expression
= Expression
[2:-1]
944 return Expression
in MacroPcdDict
946 ## __IsToken() method
948 # Check whether input string is found from current char position along
949 # If found, the string value is put into self.__Token
951 # @param self The object pointer
952 # @param String The string to search
953 # @param IgnoreCase Indicate case sensitive/non-sensitive search, default is case sensitive
954 # @retval True Successfully find string, file buffer pointer moved forward
955 # @retval False Not able to find string, file buffer pointer not changed
957 def __IsToken(self
, String
, IgnoreCase
= False):
958 self
.__SkipWhiteSpace
()
960 # Only consider the same line, no multi-line token allowed
961 StartPos
= self
.CurrentOffsetWithinLine
964 index
= self
.__CurrentLine
()[self
.CurrentOffsetWithinLine
: ].upper().find(String
.upper())
966 index
= self
.__CurrentLine
()[self
.CurrentOffsetWithinLine
: ].find(String
)
968 self
.CurrentOffsetWithinLine
+= len(String
)
969 self
.__Token
= self
.__CurrentLine
()[StartPos
: self
.CurrentOffsetWithinLine
]
973 ## __IsKeyword() method
975 # Check whether input keyword is found from current char position along, whole word only!
976 # If found, the string value is put into self.__Token
978 # @param self The object pointer
979 # @param Keyword The string to search
980 # @param IgnoreCase Indicate case sensitive/non-sensitive search, default is case sensitive
981 # @retval True Successfully find string, file buffer pointer moved forward
982 # @retval False Not able to find string, file buffer pointer not changed
984 def __IsKeyword(self
, KeyWord
, IgnoreCase
= False):
985 self
.__SkipWhiteSpace
()
987 # Only consider the same line, no multi-line token allowed
988 StartPos
= self
.CurrentOffsetWithinLine
991 index
= self
.__CurrentLine
()[self
.CurrentOffsetWithinLine
: ].upper().find(KeyWord
.upper())
993 index
= self
.__CurrentLine
()[self
.CurrentOffsetWithinLine
: ].find(KeyWord
)
995 followingChar
= self
.__CurrentLine
()[self
.CurrentOffsetWithinLine
+ len(KeyWord
)]
996 if not str(followingChar
).isspace() and followingChar
not in SEPERATOR_TUPLE
:
998 self
.CurrentOffsetWithinLine
+= len(KeyWord
)
999 self
.__Token
= self
.__CurrentLine
()[StartPos
: self
.CurrentOffsetWithinLine
]
1003 def __GetExpression(self
):
1004 Line
= self
.Profile
.FileLinesList
[self
.CurrentLineNumber
- 1]
1005 Index
= len(Line
) - 1
1006 while Line
[Index
] in ['\r', '\n']:
1008 ExpressionString
= self
.Profile
.FileLinesList
[self
.CurrentLineNumber
- 1][self
.CurrentOffsetWithinLine
:Index
+1]
1009 self
.CurrentOffsetWithinLine
+= len(ExpressionString
)
1010 ExpressionString
= ExpressionString
.strip()
1011 return ExpressionString
1013 ## __GetNextWord() method
1015 # Get next C name from file lines
1016 # If found, the string value is put into self.__Token
1018 # @param self The object pointer
1019 # @retval True Successfully find a C name string, file buffer pointer moved forward
1020 # @retval False Not able to find a C name string, file buffer pointer not changed
1022 def __GetNextWord(self
):
1023 self
.__SkipWhiteSpace
()
1024 if self
.__EndOfFile
():
1027 TempChar
= self
.__CurrentChar
()
1028 StartPos
= self
.CurrentOffsetWithinLine
1029 if (TempChar
>= 'a' and TempChar
<= 'z') or (TempChar
>= 'A' and TempChar
<= 'Z') or TempChar
== '_':
1031 while not self
.__EndOfLine
():
1032 TempChar
= self
.__CurrentChar
()
1033 if (TempChar
>= 'a' and TempChar
<= 'z') or (TempChar
>= 'A' and TempChar
<= 'Z') \
1034 or (TempChar
>= '0' and TempChar
<= '9') or TempChar
== '_' or TempChar
== '-':
1040 self
.__Token
= self
.__CurrentLine
()[StartPos
: self
.CurrentOffsetWithinLine
]
1045 ## __GetNextToken() method
1047 # Get next token unit before a seperator
1048 # If found, the string value is put into self.__Token
1050 # @param self The object pointer
1051 # @retval True Successfully find a token unit, file buffer pointer moved forward
1052 # @retval False Not able to find a token unit, file buffer pointer not changed
1054 def __GetNextToken(self
):
1055 # Skip leading spaces, if exist.
1056 self
.__SkipWhiteSpace
()
1057 if self
.__EndOfFile
():
1059 # Record the token start position, the position of the first non-space char.
1060 StartPos
= self
.CurrentOffsetWithinLine
1061 StartLine
= self
.CurrentLineNumber
1062 while StartLine
== self
.CurrentLineNumber
:
1063 TempChar
= self
.__CurrentChar
()
1064 # Try to find the end char that is not a space and not in seperator tuple.
1065 # That is, when we got a space or any char in the tuple, we got the end of token.
1066 if not str(TempChar
).isspace() and TempChar
not in SEPERATOR_TUPLE
:
1068 # if we happen to meet a seperator as the first char, we must proceed to get it.
1069 # That is, we get a token that is a seperator char. nomally it is the boundary of other tokens.
1070 elif StartPos
== self
.CurrentOffsetWithinLine
and TempChar
in SEPERATOR_TUPLE
:
1078 EndPos
= self
.CurrentOffsetWithinLine
1079 if self
.CurrentLineNumber
!= StartLine
:
1080 EndPos
= len(self
.Profile
.FileLinesList
[StartLine
-1])
1081 self
.__Token
= self
.Profile
.FileLinesList
[StartLine
-1][StartPos
: EndPos
]
1082 if StartPos
!= self
.CurrentOffsetWithinLine
:
1087 def __GetNextOp(self
):
1088 # Skip leading spaces, if exist.
1089 self
.__SkipWhiteSpace
()
1090 if self
.__EndOfFile
():
1092 # Record the token start position, the position of the first non-space char.
1093 StartPos
= self
.CurrentOffsetWithinLine
1094 while not self
.__EndOfLine
():
1095 TempChar
= self
.__CurrentChar
()
1096 # Try to find the end char that is not a space
1097 if not str(TempChar
).isspace():
1104 if StartPos
!= self
.CurrentOffsetWithinLine
:
1105 self
.__Token
= self
.__CurrentLine
()[StartPos
: self
.CurrentOffsetWithinLine
]
1109 ## __GetNextGuid() method
1111 # Get next token unit before a seperator
1112 # If found, the GUID string is put into self.__Token
1114 # @param self The object pointer
1115 # @retval True Successfully find a registry format GUID, file buffer pointer moved forward
1116 # @retval False Not able to find a registry format GUID, file buffer pointer not changed
1118 def __GetNextGuid(self
):
1120 if not self
.__GetNextToken
():
1122 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}')
1123 if p
.match(self
.__Token
) != None:
1129 def __Verify(self
, Name
, Value
, Scope
):
1130 if Scope
in ['UINT64', 'UINT8']:
1133 if Value
.upper().startswith('0X'):
1134 ValueNumber
= int (Value
, 16)
1136 ValueNumber
= int (Value
)
1138 EdkLogger
.error("FdfParser", FORMAT_INVALID
, "The value is not valid dec or hex number for %s." % Name
)
1140 EdkLogger
.error("FdfParser", FORMAT_INVALID
, "The value can't be set to negative value for %s." % Name
)
1141 if Scope
== 'UINT64':
1142 if ValueNumber
>= 0x10000000000000000:
1143 EdkLogger
.error("FdfParser", FORMAT_INVALID
, "Too large value for %s." % Name
)
1144 if Scope
== 'UINT8':
1145 if ValueNumber
>= 0x100:
1146 EdkLogger
.error("FdfParser", FORMAT_INVALID
, "Too large value for %s." % Name
)
1149 ## __UndoToken() method
1151 # Go back one token unit in file buffer
1153 # @param self The object pointer
1155 def __UndoToken(self
):
1156 self
.__UndoOneChar
()
1157 while self
.__CurrentChar
().isspace():
1158 if not self
.__UndoOneChar
():
1163 StartPos
= self
.CurrentOffsetWithinLine
1164 CurrentLine
= self
.CurrentLineNumber
1165 while CurrentLine
== self
.CurrentLineNumber
:
1167 TempChar
= self
.__CurrentChar
()
1168 # Try to find the end char that is not a space and not in seperator tuple.
1169 # That is, when we got a space or any char in the tuple, we got the end of token.
1170 if not str(TempChar
).isspace() and not TempChar
in SEPERATOR_TUPLE
:
1171 if not self
.__UndoOneChar
():
1173 # if we happen to meet a seperator as the first char, we must proceed to get it.
1174 # That is, we get a token that is a seperator char. nomally it is the boundary of other tokens.
1175 elif StartPos
== self
.CurrentOffsetWithinLine
and TempChar
in SEPERATOR_TUPLE
:
1182 ## __HexDigit() method
1184 # Whether char input is a Hex data bit
1186 # @param self The object pointer
1187 # @param TempChar The char to test
1188 # @retval True The char is a Hex data bit
1189 # @retval False The char is NOT a Hex data bit
1191 def __HexDigit(self
, TempChar
):
1192 if (TempChar
>= 'a' and TempChar
<= 'f') or (TempChar
>= 'A' and TempChar
<= 'F') \
1193 or (TempChar
>= '0' and TempChar
<= '9'):
1198 def __IsHex(self
, HexStr
):
1199 if not HexStr
.upper().startswith("0X"):
1201 if len(self
.__Token
) <= 2:
1203 charList
= [c
for c
in HexStr
[2 : ] if not self
.__HexDigit
( c
)]
1204 if len(charList
) == 0:
1208 ## __GetNextHexNumber() method
1210 # Get next HEX data before a seperator
1211 # If found, the HEX data is put into self.__Token
1213 # @param self The object pointer
1214 # @retval True Successfully find a HEX data, file buffer pointer moved forward
1215 # @retval False Not able to find a HEX data, file buffer pointer not changed
1217 def __GetNextHexNumber(self
):
1218 if not self
.__GetNextToken
():
1220 if self
.__IsHex
(self
.__Token
):
1226 ## __GetNextDecimalNumber() method
1228 # Get next decimal data before a seperator
1229 # If found, the decimal data is put into self.__Token
1231 # @param self The object pointer
1232 # @retval True Successfully find a decimal data, file buffer pointer moved forward
1233 # @retval False Not able to find a decimal data, file buffer pointer not changed
1235 def __GetNextDecimalNumber(self
):
1236 if not self
.__GetNextToken
():
1238 if self
.__Token
.isdigit():
1244 ## __GetNextPcdName() method
1246 # Get next PCD token space C name and PCD C name pair before a seperator
1247 # If found, the decimal data is put into self.__Token
1249 # @param self The object pointer
1250 # @retval Tuple PCD C name and PCD token space C name pair
1252 def __GetNextPcdName(self
):
1253 if not self
.__GetNextWord
():
1254 raise Warning("expected format of <PcdTokenSpaceCName>.<PcdCName>", self
.FileName
, self
.CurrentLineNumber
)
1255 pcdTokenSpaceCName
= self
.__Token
1257 if not self
.__IsToken
( "."):
1258 raise Warning("expected format of <PcdTokenSpaceCName>.<PcdCName>", self
.FileName
, self
.CurrentLineNumber
)
1260 if not self
.__GetNextWord
():
1261 raise Warning("expected format of <PcdTokenSpaceCName>.<PcdCName>", self
.FileName
, self
.CurrentLineNumber
)
1262 pcdCName
= self
.__Token
1264 return (pcdCName
, pcdTokenSpaceCName
)
1266 ## __GetStringData() method
1268 # Get string contents quoted in ""
1269 # If found, the decimal data is put into self.__Token
1271 # @param self The object pointer
1272 # @retval True Successfully find a string data, file buffer pointer moved forward
1273 # @retval False Not able to find a string data, file buffer pointer not changed
1275 def __GetStringData(self
):
1276 if self
.__Token
.startswith("\"") or self
.__Token
.startswith("L\""):
1278 self
.__SkipToToken
("\"")
1279 currentLineNumber
= self
.CurrentLineNumber
1281 if not self
.__SkipToToken
("\""):
1282 raise Warning("Missing Quote \" for String", self
.FileName
, self
.CurrentLineNumber
)
1283 if currentLineNumber
!= self
.CurrentLineNumber
:
1284 raise Warning("Missing Quote \" for String", self
.FileName
, self
.CurrentLineNumber
)
1285 self
.__Token
= self
.__SkippedChars
.rstrip('\"')
1288 elif self
.__Token
.startswith("\'") or self
.__Token
.startswith("L\'"):
1290 self
.__SkipToToken
("\'")
1291 currentLineNumber
= self
.CurrentLineNumber
1293 if not self
.__SkipToToken
("\'"):
1294 raise Warning("Missing Quote \' for String", self
.FileName
, self
.CurrentLineNumber
)
1295 if currentLineNumber
!= self
.CurrentLineNumber
:
1296 raise Warning("Missing Quote \' for String", self
.FileName
, self
.CurrentLineNumber
)
1297 self
.__Token
= self
.__SkippedChars
.rstrip('\'')
1303 ## __SkipToToken() method
1305 # Search forward in file buffer for the string
1306 # The skipped chars are put into self.__SkippedChars
1308 # @param self The object pointer
1309 # @param String The string to search
1310 # @param IgnoreCase Indicate case sensitive/non-sensitive search, default is case sensitive
1311 # @retval True Successfully find the string, file buffer pointer moved forward
1312 # @retval False Not able to find the string, file buffer pointer not changed
1314 def __SkipToToken(self
, String
, IgnoreCase
= False):
1315 StartPos
= self
.GetFileBufferPos()
1317 self
.__SkippedChars
= ""
1318 while not self
.__EndOfFile
():
1321 index
= self
.__CurrentLine
()[self
.CurrentOffsetWithinLine
: ].upper().find(String
.upper())
1323 index
= self
.__CurrentLine
()[self
.CurrentOffsetWithinLine
: ].find(String
)
1325 self
.CurrentOffsetWithinLine
+= len(String
)
1326 self
.__SkippedChars
+= String
1328 self
.__SkippedChars
+= str(self
.__CurrentChar
())
1331 self
.SetFileBufferPos( StartPos
)
1332 self
.__SkippedChars
= ""
1335 ## GetFileBufferPos() method
1337 # Return the tuple of current line and offset within the line
1339 # @param self The object pointer
1340 # @retval Tuple Line number and offset pair
1342 def GetFileBufferPos(self
):
1343 return (self
.CurrentLineNumber
, self
.CurrentOffsetWithinLine
)
1345 ## SetFileBufferPos() method
1347 # Restore the file buffer position
1349 # @param self The object pointer
1350 # @param Pos The new file buffer position
1352 def SetFileBufferPos(self
, Pos
):
1353 (self
.CurrentLineNumber
, self
.CurrentOffsetWithinLine
) = Pos
1355 ## Preprocess() method
1357 # Preprocess comment, conditional directive, include directive, replace macro.
1358 # Exception will be raised if syntax error found
1360 # @param self The object pointer
1362 def Preprocess(self
):
1363 self
.__StringToList
()
1364 self
.PreprocessFile()
1365 self
.PreprocessIncludeFile()
1366 self
.__StringToList
()
1367 self
.PreprocessFile()
1368 self
.PreprocessConditionalStatement()
1369 self
.__StringToList
()
1370 for Pos
in self
.__WipeOffArea
:
1371 self
.__ReplaceFragment
(Pos
[0], Pos
[1])
1372 self
.Profile
.FileLinesList
= ["".join(list) for list in self
.Profile
.FileLinesList
]
1374 while self
.__GetDefines
():
1377 ## ParseFile() method
1379 # Parse the file profile buffer to extract fd, fv ... information
1380 # Exception will be raised if syntax error found
1382 # @param self The object pointer
1384 def ParseFile(self
):
1389 # Keep processing sections of the FDF until no new sections or a syntax error is found
1391 while self
.__GetFd
() or self
.__GetFv
() or self
.__GetFmp
() or self
.__GetCapsule
() or self
.__GetVtf
() or self
.__GetRule
() or self
.__GetOptionRom
():
1396 #'\n\tGot Token: \"%s\" from File %s\n' % (self.__Token, FileLineTuple[0]) + \
1397 # At this point, the closest parent would be the included file itself
1398 Profile
= GetParentAtLine(X
.OriginalLineNumber
)
1400 X
.Message
+= ' near line %d, column %d: %s' \
1401 % (X
.LineNumber
, 0, Profile
.FileLinesList
[X
.LineNumber
-1])
1403 FileLineTuple
= GetRealFileLine(self
.FileName
, self
.CurrentLineNumber
)
1404 X
.Message
+= ' near line %d, column %d: %s' \
1405 % (FileLineTuple
[1], self
.CurrentOffsetWithinLine
+ 1, self
.Profile
.FileLinesList
[self
.CurrentLineNumber
- 1][self
.CurrentOffsetWithinLine
:].rstrip('\n').rstrip('\r'))
1408 ## SectionParser() method
1410 # Parse the file section info
1411 # Exception will be raised if syntax error found
1413 # @param self The object pointer
1414 # @param section The section string
1416 def SectionParser(self
, section
):
1418 if not S
.startswith("[DEFINES") and not S
.startswith("[FD.") and not S
.startswith("[FV.") and not S
.startswith("[CAPSULE.") \
1419 and not S
.startswith("[VTF.") and not S
.startswith("[RULE.") and not S
.startswith("[OPTIONROM.") and not S
.startswith('[FMPPAYLOAD.'):
1420 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
)
1422 ## __GetDefines() method
1424 # Get Defines section contents and store its data into AllMacrosList
1426 # @param self The object pointer
1427 # @retval True Successfully find a Defines
1428 # @retval False Not able to find a Defines
1430 def __GetDefines(self
):
1432 if not self
.__GetNextToken
():
1435 S
= self
.__Token
.upper()
1436 if S
.startswith("[") and not S
.startswith("[DEFINES"):
1437 self
.SectionParser(S
)
1442 if not self
.__IsToken
("[DEFINES", True):
1443 FileLineTuple
= GetRealFileLine(self
.FileName
, self
.CurrentLineNumber
)
1444 #print 'Parsing String: %s in File %s, At line: %d, Offset Within Line: %d' \
1445 # % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine :], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine)
1446 raise Warning("expected [DEFINES", self
.FileName
, self
.CurrentLineNumber
)
1448 if not self
.__IsToken
( "]"):
1449 raise Warning("expected ']'", self
.FileName
, self
.CurrentLineNumber
)
1451 while self
.__GetNextWord
():
1452 # handle the SET statement
1453 if self
.__Token
== 'SET':
1455 self
.__GetSetStatement
(None)
1458 Macro
= self
.__Token
1460 if not self
.__IsToken
("="):
1461 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
1462 if not self
.__GetNextToken
() or self
.__Token
.startswith('['):
1463 raise Warning("expected MACRO value", self
.FileName
, self
.CurrentLineNumber
)
1464 Value
= self
.__Token
1470 # Get FD section contents and store its data into FD dictionary of self.Profile
1472 # @param self The object pointer
1473 # @retval True Successfully find a FD
1474 # @retval False Not able to find a FD
1478 if not self
.__GetNextToken
():
1481 S
= self
.__Token
.upper()
1482 if S
.startswith("[") and not S
.startswith("[FD."):
1483 if not S
.startswith("[FV.") and not S
.startswith('[FMPPAYLOAD.') and not S
.startswith("[CAPSULE.") \
1484 and not S
.startswith("[VTF.") and not S
.startswith("[RULE.") and not S
.startswith("[OPTIONROM."):
1485 raise Warning("Unknown section", self
.FileName
, self
.CurrentLineNumber
)
1490 if not self
.__IsToken
("[FD.", True):
1491 FileLineTuple
= GetRealFileLine(self
.FileName
, self
.CurrentLineNumber
)
1492 #print 'Parsing String: %s in File %s, At line: %d, Offset Within Line: %d' \
1493 # % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine :], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine)
1494 raise Warning("expected [FD.]", self
.FileName
, self
.CurrentLineNumber
)
1496 FdName
= self
.__GetUiName
()
1498 if len (self
.Profile
.FdDict
) == 0:
1499 FdName
= GenFdsGlobalVariable
.PlatformName
1500 if FdName
== "" and GlobalData
.gActivePlatform
:
1501 FdName
= GlobalData
.gActivePlatform
.PlatformName
1502 self
.Profile
.FdNameNotSet
= True
1504 raise Warning("expected FdName in [FD.] section", self
.FileName
, self
.CurrentLineNumber
)
1505 self
.CurrentFdName
= FdName
.upper()
1507 if self
.CurrentFdName
in self
.Profile
.FdDict
:
1508 raise Warning("Unexpected the same FD name", self
.FileName
, self
.CurrentLineNumber
)
1510 if not self
.__IsToken
( "]"):
1511 raise Warning("expected ']'", self
.FileName
, self
.CurrentLineNumber
)
1514 FdObj
.FdUiName
= self
.CurrentFdName
1515 self
.Profile
.FdDict
[self
.CurrentFdName
] = FdObj
1517 if len (self
.Profile
.FdDict
) > 1 and self
.Profile
.FdNameNotSet
:
1518 raise Warning("expected all FDs have their name", self
.FileName
, self
.CurrentLineNumber
)
1520 Status
= self
.__GetCreateFile
(FdObj
)
1522 raise Warning("FD name error", self
.FileName
, self
.CurrentLineNumber
)
1524 while self
.__GetTokenStatements
(FdObj
):
1526 for Attr
in ("BaseAddress", "Size", "ErasePolarity"):
1527 if getattr(FdObj
, Attr
) == None:
1528 self
.__GetNextToken
()
1529 raise Warning("Keyword %s missing" % Attr
, self
.FileName
, self
.CurrentLineNumber
)
1531 if not FdObj
.BlockSizeList
:
1532 FdObj
.BlockSizeList
.append((1, FdObj
.Size
, None))
1534 self
.__GetDefineStatements
(FdObj
)
1536 self
.__GetSetStatements
(FdObj
)
1538 if not self
.__GetRegionLayout
(FdObj
):
1539 raise Warning("expected region layout", self
.FileName
, self
.CurrentLineNumber
)
1541 while self
.__GetRegionLayout
(FdObj
):
1545 ## __GetUiName() method
1547 # Return the UI name of a section
1549 # @param self The object pointer
1550 # @retval FdName UI name
1552 def __GetUiName(self
):
1554 if self
.__GetNextWord
():
1559 ## __GetCreateFile() method
1561 # Return the output file name of object
1563 # @param self The object pointer
1564 # @param Obj object whose data will be stored in file
1565 # @retval FdName UI name
1567 def __GetCreateFile(self
, Obj
):
1569 if self
.__IsKeyword
( "CREATE_FILE"):
1570 if not self
.__IsToken
( "="):
1571 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
1573 if not self
.__GetNextToken
():
1574 raise Warning("expected file name", self
.FileName
, self
.CurrentLineNumber
)
1576 FileName
= self
.__Token
1577 Obj
.CreateFileName
= FileName
1581 ## __GetTokenStatements() method
1583 # Get token statements
1585 # @param self The object pointer
1586 # @param Obj for whom token statement is got
1588 def __GetTokenStatements(self
, Obj
):
1589 if self
.__IsKeyword
( "BaseAddress"):
1590 if not self
.__IsToken
( "="):
1591 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
1593 if not self
.__GetNextHexNumber
():
1594 raise Warning("expected Hex base address", self
.FileName
, self
.CurrentLineNumber
)
1596 Obj
.BaseAddress
= self
.__Token
1598 if self
.__IsToken
( "|"):
1599 pcdPair
= self
.__GetNextPcdName
()
1600 Obj
.BaseAddressPcd
= pcdPair
1601 self
.Profile
.PcdDict
[pcdPair
] = Obj
.BaseAddress
1602 FileLineTuple
= GetRealFileLine(self
.FileName
, self
.CurrentLineNumber
)
1603 self
.Profile
.PcdFileLineDict
[pcdPair
] = FileLineTuple
1606 if self
.__IsKeyword
( "Size"):
1607 if not self
.__IsToken
( "="):
1608 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
1610 if not self
.__GetNextHexNumber
():
1611 raise Warning("expected Hex size", self
.FileName
, self
.CurrentLineNumber
)
1614 if self
.__IsToken
( "|"):
1615 pcdPair
= self
.__GetNextPcdName
()
1616 Obj
.SizePcd
= pcdPair
1617 self
.Profile
.PcdDict
[pcdPair
] = Size
1618 FileLineTuple
= GetRealFileLine(self
.FileName
, self
.CurrentLineNumber
)
1619 self
.Profile
.PcdFileLineDict
[pcdPair
] = FileLineTuple
1620 Obj
.Size
= long(Size
, 0)
1623 if self
.__IsKeyword
( "ErasePolarity"):
1624 if not self
.__IsToken
( "="):
1625 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
1627 if not self
.__GetNextToken
():
1628 raise Warning("expected Erase Polarity", self
.FileName
, self
.CurrentLineNumber
)
1630 if self
.__Token
!= "1" and self
.__Token
!= "0":
1631 raise Warning("expected 1 or 0 Erase Polarity", self
.FileName
, self
.CurrentLineNumber
)
1633 Obj
.ErasePolarity
= self
.__Token
1636 return self
.__GetBlockStatements
(Obj
)
1638 ## __GetAddressStatements() method
1640 # Get address statements
1642 # @param self The object pointer
1643 # @param Obj for whom address statement is got
1644 # @retval True Successfully find
1645 # @retval False Not able to find
1647 def __GetAddressStatements(self
, Obj
):
1649 if self
.__IsKeyword
("BsBaseAddress"):
1650 if not self
.__IsToken
( "="):
1651 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
1653 if not self
.__GetNextDecimalNumber
() and not self
.__GetNextHexNumber
():
1654 raise Warning("expected address", self
.FileName
, self
.CurrentLineNumber
)
1656 BsAddress
= long(self
.__Token
, 0)
1657 Obj
.BsBaseAddress
= BsAddress
1659 if self
.__IsKeyword
("RtBaseAddress"):
1660 if not self
.__IsToken
( "="):
1661 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
1663 if not self
.__GetNextDecimalNumber
() and not self
.__GetNextHexNumber
():
1664 raise Warning("expected address", self
.FileName
, self
.CurrentLineNumber
)
1666 RtAddress
= long(self
.__Token
, 0)
1667 Obj
.RtBaseAddress
= RtAddress
1669 ## __GetBlockStatements() method
1671 # Get block statements
1673 # @param self The object pointer
1674 # @param Obj for whom block statement is got
1676 def __GetBlockStatements(self
, Obj
):
1678 while self
.__GetBlockStatement
(Obj
):
1681 Item
= Obj
.BlockSizeList
[-1]
1682 if Item
[0] == None or Item
[1] == None:
1683 raise Warning("expected block statement", self
.FileName
, self
.CurrentLineNumber
)
1686 ## __GetBlockStatement() method
1688 # Get block statement
1690 # @param self The object pointer
1691 # @param Obj for whom block statement is got
1692 # @retval True Successfully find
1693 # @retval False Not able to find
1695 def __GetBlockStatement(self
, Obj
):
1696 if not self
.__IsKeyword
( "BlockSize"):
1699 if not self
.__IsToken
( "="):
1700 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
1702 if not self
.__GetNextHexNumber
() and not self
.__GetNextDecimalNumber
():
1703 raise Warning("expected Hex or Integer block size", self
.FileName
, self
.CurrentLineNumber
)
1705 BlockSize
= self
.__Token
1707 if self
.__IsToken
( "|"):
1708 PcdPair
= self
.__GetNextPcdName
()
1709 BlockSizePcd
= PcdPair
1710 self
.Profile
.PcdDict
[PcdPair
] = BlockSize
1711 FileLineTuple
= GetRealFileLine(self
.FileName
, self
.CurrentLineNumber
)
1712 self
.Profile
.PcdFileLineDict
[PcdPair
] = FileLineTuple
1713 BlockSize
= long(BlockSize
, 0)
1716 if self
.__IsKeyword
( "NumBlocks"):
1717 if not self
.__IsToken
( "="):
1718 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
1720 if not self
.__GetNextDecimalNumber
() and not self
.__GetNextHexNumber
():
1721 raise Warning("expected block numbers", self
.FileName
, self
.CurrentLineNumber
)
1723 BlockNumber
= long(self
.__Token
, 0)
1725 Obj
.BlockSizeList
.append((BlockSize
, BlockNumber
, BlockSizePcd
))
1728 ## __GetDefineStatements() method
1730 # Get define statements
1732 # @param self The object pointer
1733 # @param Obj for whom define statement is got
1734 # @retval True Successfully find
1735 # @retval False Not able to find
1737 def __GetDefineStatements(self
, Obj
):
1738 while self
.__GetDefineStatement
( Obj
):
1741 ## __GetDefineStatement() method
1743 # Get define statement
1745 # @param self The object pointer
1746 # @param Obj for whom define statement is got
1747 # @retval True Successfully find
1748 # @retval False Not able to find
1750 def __GetDefineStatement(self
, Obj
):
1751 if self
.__IsKeyword
("DEFINE"):
1752 self
.__GetNextToken
()
1753 Macro
= self
.__Token
1754 if not self
.__IsToken
( "="):
1755 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
1757 if not self
.__GetNextToken
():
1758 raise Warning("expected value", self
.FileName
, self
.CurrentLineNumber
)
1760 Value
= self
.__Token
1761 Macro
= '$(' + Macro
+ ')'
1762 Obj
.DefineVarDict
[Macro
] = Value
1767 ## __GetSetStatements() method
1769 # Get set statements
1771 # @param self The object pointer
1772 # @param Obj for whom set statement is got
1773 # @retval True Successfully find
1774 # @retval False Not able to find
1776 def __GetSetStatements(self
, Obj
):
1777 while self
.__GetSetStatement
(Obj
):
1780 ## __GetSetStatement() method
1784 # @param self The object pointer
1785 # @param Obj for whom set statement is got
1786 # @retval True Successfully find
1787 # @retval False Not able to find
1789 def __GetSetStatement(self
, Obj
):
1790 if self
.__IsKeyword
("SET"):
1791 PcdPair
= self
.__GetNextPcdName
()
1793 if not self
.__IsToken
( "="):
1794 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
1796 Value
= self
.__GetExpression
()
1797 Value
= self
.__EvaluateConditional
(Value
, self
.CurrentLineNumber
, 'eval', True)
1800 Obj
.SetVarDict
[PcdPair
] = Value
1801 self
.Profile
.PcdDict
[PcdPair
] = Value
1802 FileLineTuple
= GetRealFileLine(self
.FileName
, self
.CurrentLineNumber
)
1803 self
.Profile
.PcdFileLineDict
[PcdPair
] = FileLineTuple
1808 ## __CalcRegionExpr(self)
1810 # Calculate expression for offset or size of a region
1812 # @return: None if invalid expression
1813 # Calculated number if successfully
1815 def __CalcRegionExpr(self
):
1816 StartPos
= self
.GetFileBufferPos()
1819 while not self
.__EndOfFile
():
1820 CurCh
= self
.__CurrentChar
()
1826 if CurCh
in '|\r\n' and PairCount
== 0:
1832 ValueExpression(Expr
,
1833 self
.__CollectMacroPcd
()
1836 self
.SetFileBufferPos(StartPos
)
1839 ## __GetRegionLayout() method
1841 # Get region layout for FD
1843 # @param self The object pointer
1844 # @param Fd for whom region is got
1845 # @retval True Successfully find
1846 # @retval False Not able to find
1848 def __GetRegionLayout(self
, Fd
):
1849 Offset
= self
.__CalcRegionExpr
()
1853 RegionObj
= Region
.Region()
1854 RegionObj
.Offset
= Offset
1855 Fd
.RegionList
.append(RegionObj
)
1857 if not self
.__IsToken
( "|"):
1858 raise Warning("expected '|'", self
.FileName
, self
.CurrentLineNumber
)
1860 Size
= self
.__CalcRegionExpr
()
1862 raise Warning("expected Region Size", self
.FileName
, self
.CurrentLineNumber
)
1863 RegionObj
.Size
= Size
1865 if not self
.__GetNextWord
():
1868 if not self
.__Token
in ("SET", "FV", "FILE", "DATA", "CAPSULE", "INF"):
1870 # If next token is a word which is not a valid FV type, it might be part of [PcdOffset[|PcdSize]]
1871 # Or it might be next region's offset described by an expression which starts with a PCD.
1872 # PcdOffset[|PcdSize] or OffsetPcdExpression|Size
1875 IsRegionPcd
= (RegionSizeGuidPattern
.match(self
.__CurrentLine
()[self
.CurrentOffsetWithinLine
:]) or
1876 RegionOffsetPcdPattern
.match(self
.__CurrentLine
()[self
.CurrentOffsetWithinLine
:]))
1878 RegionObj
.PcdOffset
= self
.__GetNextPcdName
()
1879 self
.Profile
.PcdDict
[RegionObj
.PcdOffset
] = "0x%08X" % (RegionObj
.Offset
+ long(Fd
.BaseAddress
, 0))
1880 self
.__PcdDict
['%s.%s' % (RegionObj
.PcdOffset
[1], RegionObj
.PcdOffset
[0])] = "0x%x" % RegionObj
.Offset
1881 FileLineTuple
= GetRealFileLine(self
.FileName
, self
.CurrentLineNumber
)
1882 self
.Profile
.PcdFileLineDict
[RegionObj
.PcdOffset
] = FileLineTuple
1883 if self
.__IsToken
( "|"):
1884 RegionObj
.PcdSize
= self
.__GetNextPcdName
()
1885 self
.Profile
.PcdDict
[RegionObj
.PcdSize
] = "0x%08X" % RegionObj
.Size
1886 self
.__PcdDict
['%s.%s' % (RegionObj
.PcdSize
[1], RegionObj
.PcdSize
[0])] = "0x%x" % RegionObj
.Size
1887 FileLineTuple
= GetRealFileLine(self
.FileName
, self
.CurrentLineNumber
)
1888 self
.Profile
.PcdFileLineDict
[RegionObj
.PcdSize
] = FileLineTuple
1890 if not self
.__GetNextWord
():
1893 if self
.__Token
== "SET":
1895 self
.__GetSetStatements
( RegionObj
)
1896 if not self
.__GetNextWord
():
1899 elif self
.__Token
== "FV":
1901 self
.__GetRegionFvType
( RegionObj
)
1903 elif self
.__Token
== "CAPSULE":
1905 self
.__GetRegionCapType
( RegionObj
)
1907 elif self
.__Token
== "FILE":
1909 self
.__GetRegionFileType
(RegionObj
)
1911 elif self
.__Token
== "INF":
1913 RegionObj
.RegionType
= "INF"
1914 while self
.__IsKeyword
("INF"):
1916 ffsInf
= self
.__ParseInfStatement
()
1919 RegionObj
.RegionDataList
.append(ffsInf
)
1921 elif self
.__Token
== "DATA":
1923 self
.__GetRegionDataType
(RegionObj
)
1926 if self
.__GetRegionLayout
(Fd
):
1928 raise Warning("A valid region type was not found. "
1929 "Valid types are [SET, FV, CAPSULE, FILE, DATA, INF]. This error occurred",
1930 self
.FileName
, self
.CurrentLineNumber
)
1934 ## __GetRegionFvType() method
1936 # Get region fv data for region
1938 # @param self The object pointer
1939 # @param RegionObj for whom region data is got
1941 def __GetRegionFvType(self
, RegionObj
):
1943 if not self
.__IsKeyword
( "FV"):
1944 raise Warning("expected Keyword 'FV'", self
.FileName
, self
.CurrentLineNumber
)
1946 if not self
.__IsToken
( "="):
1947 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
1949 if not self
.__GetNextToken
():
1950 raise Warning("expected FV name", self
.FileName
, self
.CurrentLineNumber
)
1952 RegionObj
.RegionType
= "FV"
1953 RegionObj
.RegionDataList
.append((self
.__Token
).upper())
1955 while self
.__IsKeyword
( "FV"):
1957 if not self
.__IsToken
( "="):
1958 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
1960 if not self
.__GetNextToken
():
1961 raise Warning("expected FV name", self
.FileName
, self
.CurrentLineNumber
)
1963 RegionObj
.RegionDataList
.append((self
.__Token
).upper())
1965 ## __GetRegionCapType() method
1967 # Get region capsule data for region
1969 # @param self The object pointer
1970 # @param RegionObj for whom region data is got
1972 def __GetRegionCapType(self
, RegionObj
):
1974 if not self
.__IsKeyword
("CAPSULE"):
1975 raise Warning("expected Keyword 'CAPSULE'", self
.FileName
, self
.CurrentLineNumber
)
1977 if not self
.__IsToken
("="):
1978 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
1980 if not self
.__GetNextToken
():
1981 raise Warning("expected CAPSULE name", self
.FileName
, self
.CurrentLineNumber
)
1983 RegionObj
.RegionType
= "CAPSULE"
1984 RegionObj
.RegionDataList
.append(self
.__Token
)
1986 while self
.__IsKeyword
("CAPSULE"):
1988 if not self
.__IsToken
("="):
1989 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
1991 if not self
.__GetNextToken
():
1992 raise Warning("expected CAPSULE name", self
.FileName
, self
.CurrentLineNumber
)
1994 RegionObj
.RegionDataList
.append(self
.__Token
)
1996 ## __GetRegionFileType() method
1998 # Get region file data for region
2000 # @param self The object pointer
2001 # @param RegionObj for whom region data is got
2003 def __GetRegionFileType(self
, RegionObj
):
2005 if not self
.__IsKeyword
( "FILE"):
2006 raise Warning("expected Keyword 'FILE'", self
.FileName
, self
.CurrentLineNumber
)
2008 if not self
.__IsToken
( "="):
2009 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2011 if not self
.__GetNextToken
():
2012 raise Warning("expected File name", self
.FileName
, self
.CurrentLineNumber
)
2014 RegionObj
.RegionType
= "FILE"
2015 RegionObj
.RegionDataList
.append( self
.__Token
)
2017 while self
.__IsKeyword
( "FILE"):
2019 if not self
.__IsToken
( "="):
2020 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2022 if not self
.__GetNextToken
():
2023 raise Warning("expected FILE name", self
.FileName
, self
.CurrentLineNumber
)
2025 RegionObj
.RegionDataList
.append(self
.__Token
)
2027 ## __GetRegionDataType() method
2029 # Get region array data for region
2031 # @param self The object pointer
2032 # @param RegionObj for whom region data is got
2034 def __GetRegionDataType(self
, RegionObj
):
2036 if not self
.__IsKeyword
( "DATA"):
2037 raise Warning("expected Region Data type", self
.FileName
, self
.CurrentLineNumber
)
2039 if not self
.__IsToken
( "="):
2040 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2042 if not self
.__IsToken
( "{"):
2043 raise Warning("expected '{'", self
.FileName
, self
.CurrentLineNumber
)
2045 if not self
.__GetNextHexNumber
():
2046 raise Warning("expected Hex byte", self
.FileName
, self
.CurrentLineNumber
)
2048 if len(self
.__Token
) > 18:
2049 raise Warning("Hex string can't be converted to a valid UINT64 value", self
.FileName
, self
.CurrentLineNumber
)
2051 # convert hex string value to byte hex string array
2052 AllString
= self
.__Token
2053 AllStrLen
= len (AllString
)
2055 while AllStrLen
> 4:
2056 DataString
= DataString
+ "0x" + AllString
[AllStrLen
- 2: AllStrLen
] + ","
2057 AllStrLen
= AllStrLen
- 2
2058 DataString
= DataString
+ AllString
[:AllStrLen
] + ","
2061 if len (self
.__Token
) <= 4:
2062 while self
.__IsToken
(","):
2063 if not self
.__GetNextHexNumber
():
2064 raise Warning("Invalid Hex number", self
.FileName
, self
.CurrentLineNumber
)
2065 if len(self
.__Token
) > 4:
2066 raise Warning("Hex byte(must be 2 digits) too long", self
.FileName
, self
.CurrentLineNumber
)
2067 DataString
+= self
.__Token
2070 if not self
.__IsToken
( "}"):
2071 raise Warning("expected '}'", self
.FileName
, self
.CurrentLineNumber
)
2073 DataString
= DataString
.rstrip(",")
2074 RegionObj
.RegionType
= "DATA"
2075 RegionObj
.RegionDataList
.append( DataString
)
2077 while self
.__IsKeyword
( "DATA"):
2079 if not self
.__IsToken
( "="):
2080 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2082 if not self
.__IsToken
( "{"):
2083 raise Warning("expected '{'", self
.FileName
, self
.CurrentLineNumber
)
2085 if not self
.__GetNextHexNumber
():
2086 raise Warning("expected Hex byte", self
.FileName
, self
.CurrentLineNumber
)
2088 if len(self
.__Token
) > 18:
2089 raise Warning("Hex string can't be converted to a valid UINT64 value", self
.FileName
, self
.CurrentLineNumber
)
2091 # convert hex string value to byte hex string array
2092 AllString
= self
.__Token
2093 AllStrLen
= len (AllString
)
2095 while AllStrLen
> 4:
2096 DataString
= DataString
+ "0x" + AllString
[AllStrLen
- 2: AllStrLen
] + ","
2097 AllStrLen
= AllStrLen
- 2
2098 DataString
= DataString
+ AllString
[:AllStrLen
] + ","
2101 if len (self
.__Token
) <= 4:
2102 while self
.__IsToken
(","):
2103 if not self
.__GetNextHexNumber
():
2104 raise Warning("Invalid Hex number", self
.FileName
, self
.CurrentLineNumber
)
2105 if len(self
.__Token
) > 4:
2106 raise Warning("Hex byte(must be 2 digits) too long", self
.FileName
, self
.CurrentLineNumber
)
2107 DataString
+= self
.__Token
2110 if not self
.__IsToken
( "}"):
2111 raise Warning("expected '}'", self
.FileName
, self
.CurrentLineNumber
)
2113 DataString
= DataString
.rstrip(",")
2114 RegionObj
.RegionDataList
.append( DataString
)
2118 # Get FV section contents and store its data into FV dictionary of self.Profile
2120 # @param self The object pointer
2121 # @retval True Successfully find a FV
2122 # @retval False Not able to find a FV
2125 if not self
.__GetNextToken
():
2128 S
= self
.__Token
.upper()
2129 if S
.startswith("[") and not S
.startswith("[FV."):
2130 self
.SectionParser(S
)
2135 if not self
.__IsToken
("[FV.", True):
2136 FileLineTuple
= GetRealFileLine(self
.FileName
, self
.CurrentLineNumber
)
2137 #print 'Parsing String: %s in File %s, At line: %d, Offset Within Line: %d' \
2138 # % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine :], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine)
2139 raise Warning("Unknown Keyword '%s'" % self
.__Token
, self
.FileName
, self
.CurrentLineNumber
)
2141 FvName
= self
.__GetUiName
()
2142 self
.CurrentFvName
= FvName
.upper()
2144 if not self
.__IsToken
( "]"):
2145 raise Warning("expected ']'", self
.FileName
, self
.CurrentLineNumber
)
2148 FvObj
.UiFvName
= self
.CurrentFvName
2149 self
.Profile
.FvDict
[self
.CurrentFvName
] = FvObj
2151 Status
= self
.__GetCreateFile
(FvObj
)
2153 raise Warning("FV name error", self
.FileName
, self
.CurrentLineNumber
)
2155 self
.__GetDefineStatements
(FvObj
)
2157 self
.__GetAddressStatements
(FvObj
)
2159 FvObj
.FvExtEntryTypeValue
= []
2160 FvObj
.FvExtEntryType
= []
2161 FvObj
.FvExtEntryData
= []
2163 self
.__GetSetStatements
(FvObj
)
2165 if not (self
.__GetBlockStatement
(FvObj
) or self
.__GetFvBaseAddress
(FvObj
) or
2166 self
.__GetFvForceRebase
(FvObj
) or self
.__GetFvAlignment
(FvObj
) or
2167 self
.__GetFvAttributes
(FvObj
) or self
.__GetFvNameGuid
(FvObj
) or
2168 self
.__GetFvExtEntryStatement
(FvObj
) or self
.__GetFvNameString
(FvObj
)):
2171 if FvObj
.FvNameString
== 'TRUE' and not FvObj
.FvNameGuid
:
2172 raise Warning("FvNameString found but FvNameGuid was not found", self
.FileName
, self
.CurrentLineNumber
)
2174 self
.__GetAprioriSection
(FvObj
, FvObj
.DefineVarDict
.copy())
2175 self
.__GetAprioriSection
(FvObj
, FvObj
.DefineVarDict
.copy())
2178 isInf
= self
.__GetInfStatement
(FvObj
, MacroDict
= FvObj
.DefineVarDict
.copy())
2179 isFile
= self
.__GetFileStatement
(FvObj
, MacroDict
= FvObj
.DefineVarDict
.copy())
2180 if not isInf
and not isFile
:
2185 ## __GetFvAlignment() method
2187 # Get alignment for FV
2189 # @param self The object pointer
2190 # @param Obj for whom alignment is got
2191 # @retval True Successfully find a alignment statement
2192 # @retval False Not able to find a alignment statement
2194 def __GetFvAlignment(self
, Obj
):
2196 if not self
.__IsKeyword
( "FvAlignment"):
2199 if not self
.__IsToken
( "="):
2200 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2202 if not self
.__GetNextToken
():
2203 raise Warning("expected alignment value", self
.FileName
, self
.CurrentLineNumber
)
2205 if self
.__Token
.upper() not in ("1", "2", "4", "8", "16", "32", "64", "128", "256", "512", \
2206 "1K", "2K", "4K", "8K", "16K", "32K", "64K", "128K", "256K", "512K", \
2207 "1M", "2M", "4M", "8M", "16M", "32M", "64M", "128M", "256M", "512M", \
2209 raise Warning("Unknown alignment value '%s'" % self
.__Token
, self
.FileName
, self
.CurrentLineNumber
)
2210 Obj
.FvAlignment
= self
.__Token
2213 ## __GetFvBaseAddress() method
2215 # Get BaseAddress for FV
2217 # @param self The object pointer
2218 # @param Obj for whom FvBaseAddress is got
2219 # @retval True Successfully find a FvBaseAddress statement
2220 # @retval False Not able to find a FvBaseAddress statement
2222 def __GetFvBaseAddress(self
, Obj
):
2224 if not self
.__IsKeyword
("FvBaseAddress"):
2227 if not self
.__IsToken
( "="):
2228 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2230 if not self
.__GetNextToken
():
2231 raise Warning("expected FV base address value", self
.FileName
, self
.CurrentLineNumber
)
2233 IsValidBaseAddrValue
= re
.compile('^0[x|X][0-9a-fA-F]+')
2235 if not IsValidBaseAddrValue
.match(self
.__Token
.upper()):
2236 raise Warning("Unknown FV base address value '%s'" % self
.__Token
, self
.FileName
, self
.CurrentLineNumber
)
2237 Obj
.FvBaseAddress
= self
.__Token
2240 ## __GetFvForceRebase() method
2242 # Get FvForceRebase for FV
2244 # @param self The object pointer
2245 # @param Obj for whom FvForceRebase is got
2246 # @retval True Successfully find a FvForceRebase statement
2247 # @retval False Not able to find a FvForceRebase statement
2249 def __GetFvForceRebase(self
, Obj
):
2251 if not self
.__IsKeyword
("FvForceRebase"):
2254 if not self
.__IsToken
( "="):
2255 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2257 if not self
.__GetNextToken
():
2258 raise Warning("expected FvForceRebase value", self
.FileName
, self
.CurrentLineNumber
)
2260 if self
.__Token
.upper() not in ["TRUE", "FALSE", "0", "0X0", "0X00", "1", "0X1", "0X01"]:
2261 raise Warning("Unknown FvForceRebase value '%s'" % self
.__Token
, self
.FileName
, self
.CurrentLineNumber
)
2263 if self
.__Token
.upper() in ["TRUE", "1", "0X1", "0X01"]:
2264 Obj
.FvForceRebase
= True
2265 elif self
.__Token
.upper() in ["FALSE", "0", "0X0", "0X00"]:
2266 Obj
.FvForceRebase
= False
2268 Obj
.FvForceRebase
= None
2273 ## __GetFvAttributes() method
2275 # Get attributes for FV
2277 # @param self The object pointer
2278 # @param Obj for whom attribute is got
2281 def __GetFvAttributes(self
, FvObj
):
2283 while self
.__GetNextWord
():
2286 if name
not in ("ERASE_POLARITY", "MEMORY_MAPPED", \
2287 "STICKY_WRITE", "LOCK_CAP", "LOCK_STATUS", "WRITE_ENABLED_CAP", \
2288 "WRITE_DISABLED_CAP", "WRITE_STATUS", "READ_ENABLED_CAP", \
2289 "READ_DISABLED_CAP", "READ_STATUS", "READ_LOCK_CAP", \
2290 "READ_LOCK_STATUS", "WRITE_LOCK_CAP", "WRITE_LOCK_STATUS", \
2291 "WRITE_POLICY_RELIABLE", "WEAK_ALIGNMENT"):
2295 if not self
.__IsToken
( "="):
2296 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2298 if not self
.__GetNextToken
() or self
.__Token
.upper() not in ("TRUE", "FALSE", "1", "0"):
2299 raise Warning("expected TRUE/FALSE (1/0)", self
.FileName
, self
.CurrentLineNumber
)
2301 FvObj
.FvAttributeDict
[name
] = self
.__Token
2305 ## __GetFvNameGuid() method
2307 # Get FV GUID for FV
2309 # @param self The object pointer
2310 # @param Obj for whom GUID is got
2313 def __GetFvNameGuid(self
, FvObj
):
2315 if not self
.__IsKeyword
( "FvNameGuid"):
2318 if not self
.__IsToken
( "="):
2319 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2321 if not self
.__GetNextGuid
():
2322 raise Warning("expected FV GUID value", self
.FileName
, self
.CurrentLineNumber
)
2324 FvObj
.FvNameGuid
= self
.__Token
2328 def __GetFvNameString(self
, FvObj
):
2330 if not self
.__IsKeyword
( "FvNameString"):
2333 if not self
.__IsToken
( "="):
2334 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2336 if not self
.__GetNextToken
() or self
.__Token
not in ('TRUE', 'FALSE'):
2337 raise Warning("expected TRUE or FALSE for FvNameString", self
.FileName
, self
.CurrentLineNumber
)
2339 FvObj
.FvNameString
= self
.__Token
2343 def __GetFvExtEntryStatement(self
, FvObj
):
2345 if not self
.__IsKeyword
( "FV_EXT_ENTRY"):
2348 if not self
.__IsKeyword
("TYPE"):
2349 raise Warning("expected 'TYPE'", self
.FileName
, self
.CurrentLineNumber
)
2351 if not self
.__IsToken
( "="):
2352 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2354 if not self
.__GetNextHexNumber
() and not self
.__GetNextDecimalNumber
():
2355 raise Warning("expected Hex FV extension entry type value At Line ", self
.FileName
, self
.CurrentLineNumber
)
2357 FvObj
.FvExtEntryTypeValue
+= [self
.__Token
]
2359 if not self
.__IsToken
( "{"):
2360 raise Warning("expected '{'", self
.FileName
, self
.CurrentLineNumber
)
2362 if not self
.__IsKeyword
("FILE") and not self
.__IsKeyword
("DATA"):
2363 raise Warning("expected 'FILE' or 'DATA'", self
.FileName
, self
.CurrentLineNumber
)
2365 FvObj
.FvExtEntryType
+= [self
.__Token
]
2367 if self
.__Token
== 'DATA':
2369 if not self
.__IsToken
( "="):
2370 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2372 if not self
.__IsToken
( "{"):
2373 raise Warning("expected '{'", self
.FileName
, self
.CurrentLineNumber
)
2375 if not self
.__GetNextHexNumber
():
2376 raise Warning("expected Hex byte", self
.FileName
, self
.CurrentLineNumber
)
2378 if len(self
.__Token
) > 4:
2379 raise Warning("Hex byte(must be 2 digits) too long", self
.FileName
, self
.CurrentLineNumber
)
2381 DataString
= self
.__Token
2384 while self
.__IsToken
(","):
2385 if not self
.__GetNextHexNumber
():
2386 raise Warning("Invalid Hex number", self
.FileName
, self
.CurrentLineNumber
)
2387 if len(self
.__Token
) > 4:
2388 raise Warning("Hex byte(must be 2 digits) too long", self
.FileName
, self
.CurrentLineNumber
)
2389 DataString
+= self
.__Token
2392 if not self
.__IsToken
( "}"):
2393 raise Warning("expected '}'", self
.FileName
, self
.CurrentLineNumber
)
2395 if not self
.__IsToken
( "}"):
2396 raise Warning("expected '}'", self
.FileName
, self
.CurrentLineNumber
)
2398 DataString
= DataString
.rstrip(",")
2399 FvObj
.FvExtEntryData
+= [DataString
]
2401 if self
.__Token
== 'FILE':
2403 if not self
.__IsToken
( "="):
2404 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2406 if not self
.__GetNextToken
():
2407 raise Warning("expected FV Extension Entry file path At Line ", self
.FileName
, self
.CurrentLineNumber
)
2409 FvObj
.FvExtEntryData
+= [self
.__Token
]
2411 if not self
.__IsToken
( "}"):
2412 raise Warning("expected '}'", self
.FileName
, self
.CurrentLineNumber
)
2416 ## __GetAprioriSection() method
2418 # Get token statements
2420 # @param self The object pointer
2421 # @param FvObj for whom apriori is got
2422 # @param MacroDict dictionary used to replace macro
2423 # @retval True Successfully find apriori statement
2424 # @retval False Not able to find apriori statement
2426 def __GetAprioriSection(self
, FvObj
, MacroDict
= {}):
2428 if not self
.__IsKeyword
( "APRIORI"):
2431 if not self
.__IsKeyword
("PEI") and not self
.__IsKeyword
("DXE"):
2432 raise Warning("expected Apriori file type", self
.FileName
, self
.CurrentLineNumber
)
2433 AprType
= self
.__Token
2435 if not self
.__IsToken
( "{"):
2436 raise Warning("expected '{'", self
.FileName
, self
.CurrentLineNumber
)
2438 AprSectionObj
= AprioriSection
.AprioriSection()
2439 AprSectionObj
.AprioriType
= AprType
2441 self
.__GetDefineStatements
(AprSectionObj
)
2442 MacroDict
.update(AprSectionObj
.DefineVarDict
)
2445 IsInf
= self
.__GetInfStatement
( AprSectionObj
, MacroDict
= MacroDict
)
2446 IsFile
= self
.__GetFileStatement
( AprSectionObj
)
2447 if not IsInf
and not IsFile
:
2450 if not self
.__IsToken
( "}"):
2451 raise Warning("expected '}'", self
.FileName
, self
.CurrentLineNumber
)
2453 FvObj
.AprioriSectionList
.append(AprSectionObj
)
2456 def __ParseInfStatement(self
):
2457 if not self
.__IsKeyword
("INF"):
2460 ffsInf
= FfsInfStatement
.FfsInfStatement()
2461 self
.__GetInfOptions
(ffsInf
)
2463 if not self
.__GetNextToken
():
2464 raise Warning("expected INF file path", self
.FileName
, self
.CurrentLineNumber
)
2465 ffsInf
.InfFileName
= self
.__Token
2467 ffsInf
.CurrentLineNum
= self
.CurrentLineNumber
2468 ffsInf
.CurrentLineContent
= self
.__CurrentLine
()
2470 #Replace $(SAPCE) with real space
2471 ffsInf
.InfFileName
= ffsInf
.InfFileName
.replace('$(SPACE)', ' ')
2473 if ffsInf
.InfFileName
.replace('$(WORKSPACE)', '').find('$') == -1:
2474 #do case sensitive check for file path
2475 ErrorCode
, ErrorInfo
= PathClass(NormPath(ffsInf
.InfFileName
), GenFdsGlobalVariable
.WorkSpaceDir
).Validate()
2477 EdkLogger
.error("GenFds", ErrorCode
, ExtraData
=ErrorInfo
)
2479 if not ffsInf
.InfFileName
in self
.Profile
.InfList
:
2480 self
.Profile
.InfList
.append(ffsInf
.InfFileName
)
2481 FileLineTuple
= GetRealFileLine(self
.FileName
, self
.CurrentLineNumber
)
2482 self
.Profile
.InfFileLineList
.append(FileLineTuple
)
2484 if ffsInf
.UseArch
not in self
.Profile
.InfDict
:
2485 self
.Profile
.InfDict
[ffsInf
.UseArch
] = [ffsInf
.InfFileName
]
2487 self
.Profile
.InfDict
[ffsInf
.UseArch
].append(ffsInf
.InfFileName
)
2489 self
.Profile
.InfDict
['ArchTBD'].append(ffsInf
.InfFileName
)
2491 if self
.__IsToken
('|'):
2492 if self
.__IsKeyword
('RELOCS_STRIPPED'):
2493 ffsInf
.KeepReloc
= False
2494 elif self
.__IsKeyword
('RELOCS_RETAINED'):
2495 ffsInf
.KeepReloc
= True
2497 raise Warning("Unknown reloc strip flag '%s'" % self
.__Token
, self
.FileName
, self
.CurrentLineNumber
)
2500 ## __GetInfStatement() method
2502 # Get INF statements
2504 # @param self The object pointer
2505 # @param Obj for whom inf statement is got
2506 # @param MacroDict dictionary used to replace macro
2507 # @retval True Successfully find inf statement
2508 # @retval False Not able to find inf statement
2510 def __GetInfStatement(self
, Obj
, ForCapsule
=False, MacroDict
={}):
2511 ffsInf
= self
.__ParseInfStatement
()
2516 capsuleFfs
= CapsuleData
.CapsuleFfs()
2517 capsuleFfs
.Ffs
= ffsInf
2518 Obj
.CapsuleDataList
.append(capsuleFfs
)
2520 Obj
.FfsList
.append(ffsInf
)
2523 ## __GetInfOptions() method
2525 # Get options for INF
2527 # @param self The object pointer
2528 # @param FfsInfObj for whom option is got
2530 def __GetInfOptions(self
, FfsInfObj
):
2531 if self
.__IsKeyword
("FILE_GUID"):
2532 if not self
.__IsToken
("="):
2533 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2534 if not self
.__GetNextGuid
():
2535 raise Warning("expected GUID value", self
.FileName
, self
.CurrentLineNumber
)
2536 FfsInfObj
.OverrideGuid
= self
.__Token
2538 if self
.__IsKeyword
( "RuleOverride"):
2539 if not self
.__IsToken
( "="):
2540 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2541 if not self
.__GetNextToken
():
2542 raise Warning("expected Rule name", self
.FileName
, self
.CurrentLineNumber
)
2543 FfsInfObj
.Rule
= self
.__Token
2545 if self
.__IsKeyword
( "VERSION"):
2546 if not self
.__IsToken
( "="):
2547 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2548 if not self
.__GetNextToken
():
2549 raise Warning("expected Version", self
.FileName
, self
.CurrentLineNumber
)
2551 if self
.__GetStringData
():
2552 FfsInfObj
.Version
= self
.__Token
2554 if self
.__IsKeyword
( "UI"):
2555 if not self
.__IsToken
( "="):
2556 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2557 if not self
.__GetNextToken
():
2558 raise Warning("expected UI name", self
.FileName
, self
.CurrentLineNumber
)
2560 if self
.__GetStringData
():
2561 FfsInfObj
.Ui
= self
.__Token
2563 if self
.__IsKeyword
( "USE"):
2564 if not self
.__IsToken
( "="):
2565 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2566 if not self
.__GetNextToken
():
2567 raise Warning("expected ARCH name", self
.FileName
, self
.CurrentLineNumber
)
2568 FfsInfObj
.UseArch
= self
.__Token
2571 if self
.__GetNextToken
():
2572 p
= re
.compile(r
'([a-zA-Z0-9\-]+|\$\(TARGET\)|\*)_([a-zA-Z0-9\-]+|\$\(TOOL_CHAIN_TAG\)|\*)_([a-zA-Z0-9\-]+|\$\(ARCH\))')
2573 if p
.match(self
.__Token
) and p
.match(self
.__Token
).span()[1] == len(self
.__Token
):
2574 FfsInfObj
.KeyStringList
.append(self
.__Token
)
2575 if not self
.__IsToken
(","):
2581 while self
.__GetNextToken
():
2582 if not p
.match(self
.__Token
):
2583 raise Warning("expected KeyString \"Target_Tag_Arch\"", self
.FileName
, self
.CurrentLineNumber
)
2584 FfsInfObj
.KeyStringList
.append(self
.__Token
)
2586 if not self
.__IsToken
(","):
2589 ## __GetFileStatement() method
2591 # Get FILE statements
2593 # @param self The object pointer
2594 # @param Obj for whom FILE statement is got
2595 # @param MacroDict dictionary used to replace macro
2596 # @retval True Successfully find FILE statement
2597 # @retval False Not able to find FILE statement
2599 def __GetFileStatement(self
, Obj
, ForCapsule
= False, MacroDict
= {}):
2601 if not self
.__IsKeyword
( "FILE"):
2604 if not self
.__GetNextWord
():
2605 raise Warning("expected FFS type", self
.FileName
, self
.CurrentLineNumber
)
2607 if ForCapsule
and self
.__Token
== 'DATA':
2612 FfsFileObj
= FfsFileStatement
.FileStatement()
2613 FfsFileObj
.FvFileType
= self
.__Token
2615 if not self
.__IsToken
( "="):
2616 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2618 if not self
.__GetNextGuid
():
2619 if not self
.__GetNextWord
():
2620 raise Warning("expected File GUID", self
.FileName
, self
.CurrentLineNumber
)
2621 if self
.__Token
== 'PCD':
2622 if not self
.__IsToken
( "("):
2623 raise Warning("expected '('", self
.FileName
, self
.CurrentLineNumber
)
2624 PcdPair
= self
.__GetNextPcdName
()
2625 if not self
.__IsToken
( ")"):
2626 raise Warning("expected ')'", self
.FileName
, self
.CurrentLineNumber
)
2627 self
.__Token
= 'PCD('+PcdPair
[1]+'.'+PcdPair
[0]+')'
2629 FfsFileObj
.NameGuid
= self
.__Token
2631 self
.__GetFilePart
( FfsFileObj
, MacroDict
.copy())
2634 capsuleFfs
= CapsuleData
.CapsuleFfs()
2635 capsuleFfs
.Ffs
= FfsFileObj
2636 Obj
.CapsuleDataList
.append(capsuleFfs
)
2638 Obj
.FfsList
.append(FfsFileObj
)
2642 ## __FileCouldHaveRelocFlag() method
2644 # Check whether reloc strip flag can be set for a file type.
2646 # @param self The object pointer
2647 # @param FileType The file type to check with
2648 # @retval True This type could have relocation strip flag
2649 # @retval False No way to have it
2652 def __FileCouldHaveRelocFlag (self
, FileType
):
2653 if FileType
in ('SEC', 'PEI_CORE', 'PEIM', 'PEI_DXE_COMBO'):
2658 ## __SectionCouldHaveRelocFlag() method
2660 # Check whether reloc strip flag can be set for a section type.
2662 # @param self The object pointer
2663 # @param SectionType The section type to check with
2664 # @retval True This type could have relocation strip flag
2665 # @retval False No way to have it
2668 def __SectionCouldHaveRelocFlag (self
, SectionType
):
2669 if SectionType
in ('TE', 'PE32'):
2674 ## __GetFilePart() method
2676 # Get components for FILE statement
2678 # @param self The object pointer
2679 # @param FfsFileObj for whom component is got
2680 # @param MacroDict dictionary used to replace macro
2682 def __GetFilePart(self
, FfsFileObj
, MacroDict
= {}):
2684 self
.__GetFileOpts
( FfsFileObj
)
2686 if not self
.__IsToken
("{"):
2687 if self
.__IsKeyword
('RELOCS_STRIPPED') or self
.__IsKeyword
('RELOCS_RETAINED'):
2688 if self
.__FileCouldHaveRelocFlag
(FfsFileObj
.FvFileType
):
2689 if self
.__Token
== 'RELOCS_STRIPPED':
2690 FfsFileObj
.KeepReloc
= False
2692 FfsFileObj
.KeepReloc
= True
2694 raise Warning("File type %s could not have reloc strip flag%d" % (FfsFileObj
.FvFileType
, self
.CurrentLineNumber
), self
.FileName
, self
.CurrentLineNumber
)
2696 if not self
.__IsToken
("{"):
2697 raise Warning("expected '{'", self
.FileName
, self
.CurrentLineNumber
)
2699 if not self
.__GetNextToken
():
2700 raise Warning("expected File name or section data", self
.FileName
, self
.CurrentLineNumber
)
2702 if self
.__Token
== "FV":
2703 if not self
.__IsToken
( "="):
2704 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2705 if not self
.__GetNextToken
():
2706 raise Warning("expected FV name", self
.FileName
, self
.CurrentLineNumber
)
2707 FfsFileObj
.FvName
= self
.__Token
2709 elif self
.__Token
== "FD":
2710 if not self
.__IsToken
( "="):
2711 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2712 if not self
.__GetNextToken
():
2713 raise Warning("expected FD name", self
.FileName
, self
.CurrentLineNumber
)
2714 FfsFileObj
.FdName
= self
.__Token
2716 elif self
.__Token
in ("DEFINE", "APRIORI", "SECTION"):
2718 self
.__GetSectionData
( FfsFileObj
, MacroDict
)
2720 elif hasattr(FfsFileObj
, 'FvFileType') and FfsFileObj
.FvFileType
== 'RAW':
2722 self
.__GetRAWData
(FfsFileObj
, MacroDict
)
2725 FfsFileObj
.CurrentLineNum
= self
.CurrentLineNumber
2726 FfsFileObj
.CurrentLineContent
= self
.__CurrentLine
()
2727 FfsFileObj
.FileName
= self
.__Token
.replace('$(SPACE)', ' ')
2728 self
.__VerifyFile
(FfsFileObj
.FileName
)
2730 if not self
.__IsToken
( "}"):
2731 raise Warning("expected '}'", self
.FileName
, self
.CurrentLineNumber
)
2733 ## __GetRAWData() method
2735 # Get RAW data for FILE statement
2737 # @param self The object pointer
2738 # @param FfsFileObj for whom section is got
2739 # @param MacroDict dictionary used to replace macro
2741 def __GetRAWData(self
, FfsFileObj
, MacroDict
= {}):
2742 FfsFileObj
.FileName
= []
2743 FfsFileObj
.SubAlignment
= []
2746 if self
.__GetAlignment
():
2747 if self
.__Token
not in ("Auto", "8", "16", "32", "64", "128", "512", "1K", "4K", "32K" ,"64K"):
2748 raise Warning("Incorrect alignment '%s'" % self
.__Token
, self
.FileName
, self
.CurrentLineNumber
)
2749 AlignValue
= self
.__Token
2750 if not self
.__GetNextToken
():
2751 raise Warning("expected Filename value", self
.FileName
, self
.CurrentLineNumber
)
2753 FileName
= self
.__Token
.replace('$(SPACE)', ' ')
2756 raise Warning("expected Filename value", self
.FileName
, self
.CurrentLineNumber
)
2758 self
.__VerifyFile
(FileName
)
2759 File
= PathClass(NormPath(FileName
), GenFdsGlobalVariable
.WorkSpaceDir
)
2760 FfsFileObj
.FileName
.append(File
.Path
)
2761 FfsFileObj
.SubAlignment
.append(AlignValue
)
2763 if self
.__IsToken
( "}"):
2767 if len(FfsFileObj
.SubAlignment
) == 1:
2768 FfsFileObj
.SubAlignment
= FfsFileObj
.SubAlignment
[0]
2769 if len(FfsFileObj
.FileName
) == 1:
2770 FfsFileObj
.FileName
= FfsFileObj
.FileName
[0]
2772 ## __GetFileOpts() method
2774 # Get options for FILE statement
2776 # @param self The object pointer
2777 # @param FfsFileObj for whom options is got
2779 def __GetFileOpts(self
, FfsFileObj
):
2781 if self
.__GetNextToken
():
2782 Pattern
= re
.compile(r
'([a-zA-Z0-9\-]+|\$\(TARGET\)|\*)_([a-zA-Z0-9\-]+|\$\(TOOL_CHAIN_TAG\)|\*)_([a-zA-Z0-9\-]+|\$\(ARCH\)|\*)')
2783 if Pattern
.match(self
.__Token
):
2784 FfsFileObj
.KeyStringList
.append(self
.__Token
)
2785 if self
.__IsToken
(","):
2786 while self
.__GetNextToken
():
2787 if not Pattern
.match(self
.__Token
):
2788 raise Warning("expected KeyString \"Target_Tag_Arch\"", self
.FileName
, self
.CurrentLineNumber
)
2789 FfsFileObj
.KeyStringList
.append(self
.__Token
)
2791 if not self
.__IsToken
(","):
2797 if self
.__IsKeyword
( "FIXED", True):
2798 FfsFileObj
.Fixed
= True
2800 if self
.__IsKeyword
( "CHECKSUM", True):
2801 FfsFileObj
.CheckSum
= True
2803 if self
.__GetAlignment
():
2804 if self
.__Token
not in ("Auto", "8", "16", "32", "64", "128", "512", "1K", "4K", "32K" ,"64K"):
2805 raise Warning("Incorrect alignment '%s'" % self
.__Token
, self
.FileName
, self
.CurrentLineNumber
)
2806 #For FFS, Auto is default option same to ""
2807 if not self
.__Token
== "Auto":
2808 FfsFileObj
.Alignment
= self
.__Token
2810 ## __GetAlignment() method
2812 # Return the alignment value
2814 # @param self The object pointer
2815 # @retval True Successfully find alignment
2816 # @retval False Not able to find alignment
2818 def __GetAlignment(self
):
2819 if self
.__IsKeyword
( "Align", True):
2820 if not self
.__IsToken
( "="):
2821 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2823 if not self
.__GetNextToken
():
2824 raise Warning("expected alignment value", self
.FileName
, self
.CurrentLineNumber
)
2829 ## __GetFilePart() method
2831 # Get section data for FILE statement
2833 # @param self The object pointer
2834 # @param FfsFileObj for whom section is got
2835 # @param MacroDict dictionary used to replace macro
2837 def __GetSectionData(self
, FfsFileObj
, MacroDict
= {}):
2839 Dict
.update(MacroDict
)
2841 self
.__GetDefineStatements
(FfsFileObj
)
2843 Dict
.update(FfsFileObj
.DefineVarDict
)
2844 self
.__GetAprioriSection
(FfsFileObj
, Dict
.copy())
2845 self
.__GetAprioriSection
(FfsFileObj
, Dict
.copy())
2848 IsLeafSection
= self
.__GetLeafSection
(FfsFileObj
, Dict
)
2849 IsEncapSection
= self
.__GetEncapsulationSec
(FfsFileObj
)
2850 if not IsLeafSection
and not IsEncapSection
:
2853 ## __GetLeafSection() method
2855 # Get leaf section for Obj
2857 # @param self The object pointer
2858 # @param Obj for whom leaf section is got
2859 # @param MacroDict dictionary used to replace macro
2860 # @retval True Successfully find section statement
2861 # @retval False Not able to find section statement
2863 def __GetLeafSection(self
, Obj
, MacroDict
= {}):
2865 OldPos
= self
.GetFileBufferPos()
2867 if not self
.__IsKeyword
( "SECTION"):
2868 if len(Obj
.SectionList
) == 0:
2869 raise Warning("expected SECTION", self
.FileName
, self
.CurrentLineNumber
)
2874 if self
.__GetAlignment
():
2875 if self
.__Token
not in ("Auto", "8", "16", "32", "64", "128", "512", "1K", "4K", "32K" ,"64K"):
2876 raise Warning("Incorrect alignment '%s'" % self
.__Token
, self
.FileName
, self
.CurrentLineNumber
)
2877 AlignValue
= self
.__Token
2880 if self
.__IsKeyword
( "BUILD_NUM"):
2881 if not self
.__IsToken
( "="):
2882 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2884 if not self
.__GetNextToken
():
2885 raise Warning("expected Build number value", self
.FileName
, self
.CurrentLineNumber
)
2887 BuildNum
= self
.__Token
2889 if self
.__IsKeyword
( "VERSION"):
2890 if AlignValue
== 'Auto':
2891 raise Warning("Auto alignment can only be used in PE32 or TE section ", self
.FileName
, self
.CurrentLineNumber
)
2892 if not self
.__IsToken
( "="):
2893 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2894 if not self
.__GetNextToken
():
2895 raise Warning("expected version", self
.FileName
, self
.CurrentLineNumber
)
2896 VerSectionObj
= VerSection
.VerSection()
2897 VerSectionObj
.Alignment
= AlignValue
2898 VerSectionObj
.BuildNum
= BuildNum
2899 if self
.__GetStringData
():
2900 VerSectionObj
.StringData
= self
.__Token
2902 VerSectionObj
.FileName
= self
.__Token
2903 Obj
.SectionList
.append(VerSectionObj
)
2905 elif self
.__IsKeyword
( "UI"):
2906 if AlignValue
== 'Auto':
2907 raise Warning("Auto alignment can only be used in PE32 or TE section ", self
.FileName
, self
.CurrentLineNumber
)
2908 if not self
.__IsToken
( "="):
2909 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2910 if not self
.__GetNextToken
():
2911 raise Warning("expected UI", self
.FileName
, self
.CurrentLineNumber
)
2912 UiSectionObj
= UiSection
.UiSection()
2913 UiSectionObj
.Alignment
= AlignValue
2914 if self
.__GetStringData
():
2915 UiSectionObj
.StringData
= self
.__Token
2917 UiSectionObj
.FileName
= self
.__Token
2918 Obj
.SectionList
.append(UiSectionObj
)
2920 elif self
.__IsKeyword
( "FV_IMAGE"):
2921 if AlignValue
== 'Auto':
2922 raise Warning("Auto alignment can only be used in PE32 or TE section ", self
.FileName
, self
.CurrentLineNumber
)
2923 if not self
.__IsToken
( "="):
2924 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2925 if not self
.__GetNextToken
():
2926 raise Warning("expected FV name or FV file path", self
.FileName
, self
.CurrentLineNumber
)
2928 FvName
= self
.__Token
2931 if self
.__IsToken
( "{"):
2933 FvObj
.UiFvName
= FvName
.upper()
2934 self
.__GetDefineStatements
(FvObj
)
2935 MacroDict
.update(FvObj
.DefineVarDict
)
2936 self
.__GetBlockStatement
(FvObj
)
2937 self
.__GetSetStatements
(FvObj
)
2938 self
.__GetFvAlignment
(FvObj
)
2939 self
.__GetFvAttributes
(FvObj
)
2940 self
.__GetAprioriSection
(FvObj
, MacroDict
.copy())
2941 self
.__GetAprioriSection
(FvObj
, MacroDict
.copy())
2944 IsInf
= self
.__GetInfStatement
(FvObj
, MacroDict
.copy())
2945 IsFile
= self
.__GetFileStatement
(FvObj
, MacroDict
.copy())
2946 if not IsInf
and not IsFile
:
2949 if not self
.__IsToken
( "}"):
2950 raise Warning("expected '}'", self
.FileName
, self
.CurrentLineNumber
)
2952 FvImageSectionObj
= FvImageSection
.FvImageSection()
2953 FvImageSectionObj
.Alignment
= AlignValue
2955 FvImageSectionObj
.Fv
= FvObj
2956 FvImageSectionObj
.FvName
= None
2958 FvImageSectionObj
.FvName
= FvName
.upper()
2959 FvImageSectionObj
.FvFileName
= FvName
2961 Obj
.SectionList
.append(FvImageSectionObj
)
2963 elif self
.__IsKeyword
("PEI_DEPEX_EXP") or self
.__IsKeyword
("DXE_DEPEX_EXP") or self
.__IsKeyword
("SMM_DEPEX_EXP"):
2964 if AlignValue
== 'Auto':
2965 raise Warning("Auto alignment can only be used in PE32 or TE section ", self
.FileName
, self
.CurrentLineNumber
)
2966 DepexSectionObj
= DepexSection
.DepexSection()
2967 DepexSectionObj
.Alignment
= AlignValue
2968 DepexSectionObj
.DepexType
= self
.__Token
2970 if not self
.__IsToken
( "="):
2971 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
2972 if not self
.__IsToken
( "{"):
2973 raise Warning("expected '{'", self
.FileName
, self
.CurrentLineNumber
)
2974 if not self
.__SkipToToken
( "}"):
2975 raise Warning("expected Depex expression ending '}'", self
.FileName
, self
.CurrentLineNumber
)
2977 DepexSectionObj
.Expression
= self
.__SkippedChars
.rstrip('}')
2978 Obj
.SectionList
.append(DepexSectionObj
)
2981 if not self
.__GetNextWord
():
2982 raise Warning("expected section type", self
.FileName
, self
.CurrentLineNumber
)
2984 # Encapsulation section appear, UndoToken and return
2985 if self
.__Token
== "COMPRESS" or self
.__Token
== "GUIDED":
2986 self
.SetFileBufferPos(OldPos
)
2989 if self
.__Token
not in ("COMPAT16", "PE32", "PIC", "TE", "FV_IMAGE", "RAW", "DXE_DEPEX",\
2990 "UI", "VERSION", "PEI_DEPEX", "SUBTYPE_GUID", "SMM_DEPEX"):
2991 raise Warning("Unknown section type '%s'" % self
.__Token
, self
.FileName
, self
.CurrentLineNumber
)
2992 if AlignValue
== 'Auto'and (not self
.__Token
== 'PE32') and (not self
.__Token
== 'TE'):
2993 raise Warning("Auto alignment can only be used in PE32 or TE section ", self
.FileName
, self
.CurrentLineNumber
)
2996 DataSectionObj
= DataSection
.DataSection()
2997 DataSectionObj
.Alignment
= AlignValue
2998 DataSectionObj
.SecType
= self
.__Token
3000 if self
.__IsKeyword
('RELOCS_STRIPPED') or self
.__IsKeyword
('RELOCS_RETAINED'):
3001 if self
.__FileCouldHaveRelocFlag
(Obj
.FvFileType
) and self
.__SectionCouldHaveRelocFlag
(DataSectionObj
.SecType
):
3002 if self
.__Token
== 'RELOCS_STRIPPED':
3003 DataSectionObj
.KeepReloc
= False
3005 DataSectionObj
.KeepReloc
= True
3007 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
)
3009 if self
.__IsToken
("="):
3010 if not self
.__GetNextToken
():
3011 raise Warning("expected section file path", self
.FileName
, self
.CurrentLineNumber
)
3012 DataSectionObj
.SectFileName
= self
.__Token
3013 self
.__VerifyFile
(DataSectionObj
.SectFileName
)
3015 if not self
.__GetCglSection
(DataSectionObj
):
3018 Obj
.SectionList
.append(DataSectionObj
)
3024 # Check if file exists or not:
3025 # If current phase if GenFds, the file must exist;
3026 # If current phase is AutoGen and the file is not in $(OUTPUT_DIRECTORY), the file must exist
3027 # @param FileName: File path to be verified.
3029 def __VerifyFile(self
, FileName
):
3030 if FileName
.replace('$(WORKSPACE)', '').find('$') != -1:
3032 if not GlobalData
.gAutoGenPhase
or not self
.__GetMacroValue
("OUTPUT_DIRECTORY") in FileName
:
3033 ErrorCode
, ErrorInfo
= PathClass(NormPath(FileName
), GenFdsGlobalVariable
.WorkSpaceDir
).Validate()
3035 EdkLogger
.error("GenFds", ErrorCode
, ExtraData
=ErrorInfo
)
3037 ## __GetCglSection() method
3039 # Get compressed or GUIDed section for Obj
3041 # @param self The object pointer
3042 # @param Obj for whom leaf section is got
3043 # @param AlignValue alignment value for complex section
3044 # @retval True Successfully find section statement
3045 # @retval False Not able to find section statement
3047 def __GetCglSection(self
, Obj
, AlignValue
= None):
3049 if self
.__IsKeyword
( "COMPRESS"):
3051 if self
.__IsKeyword
("PI_STD") or self
.__IsKeyword
("PI_NONE"):
3054 if not self
.__IsToken
("{"):
3055 raise Warning("expected '{'", self
.FileName
, self
.CurrentLineNumber
)
3057 CompressSectionObj
= CompressSection
.CompressSection()
3058 CompressSectionObj
.Alignment
= AlignValue
3059 CompressSectionObj
.CompType
= type
3060 # Recursive sections...
3062 IsLeafSection
= self
.__GetLeafSection
(CompressSectionObj
)
3063 IsEncapSection
= self
.__GetEncapsulationSec
(CompressSectionObj
)
3064 if not IsLeafSection
and not IsEncapSection
:
3068 if not self
.__IsToken
( "}"):
3069 raise Warning("expected '}'", self
.FileName
, self
.CurrentLineNumber
)
3070 Obj
.SectionList
.append(CompressSectionObj
)
3073 # raise Warning("Compress type not known")
3077 elif self
.__IsKeyword
( "GUIDED"):
3079 if self
.__GetNextGuid
():
3080 GuidValue
= self
.__Token
3082 AttribDict
= self
.__GetGuidAttrib
()
3083 if not self
.__IsToken
("{"):
3084 raise Warning("expected '{'", self
.FileName
, self
.CurrentLineNumber
)
3085 GuidSectionObj
= GuidSection
.GuidSection()
3086 GuidSectionObj
.Alignment
= AlignValue
3087 GuidSectionObj
.NameGuid
= GuidValue
3088 GuidSectionObj
.SectionType
= "GUIDED"
3089 GuidSectionObj
.ProcessRequired
= AttribDict
["PROCESSING_REQUIRED"]
3090 GuidSectionObj
.AuthStatusValid
= AttribDict
["AUTH_STATUS_VALID"]
3091 GuidSectionObj
.ExtraHeaderSize
= AttribDict
["EXTRA_HEADER_SIZE"]
3092 # Recursive sections...
3094 IsLeafSection
= self
.__GetLeafSection
(GuidSectionObj
)
3095 IsEncapSection
= self
.__GetEncapsulationSec
(GuidSectionObj
)
3096 if not IsLeafSection
and not IsEncapSection
:
3099 if not self
.__IsToken
( "}"):
3100 raise Warning("expected '}'", self
.FileName
, self
.CurrentLineNumber
)
3101 Obj
.SectionList
.append(GuidSectionObj
)
3107 ## __GetGuidAttri() method
3109 # Get attributes for GUID section
3111 # @param self The object pointer
3112 # @retval AttribDict Dictionary of key-value pair of section attributes
3114 def __GetGuidAttrib(self
):
3117 AttribDict
["PROCESSING_REQUIRED"] = "NONE"
3118 AttribDict
["AUTH_STATUS_VALID"] = "NONE"
3119 AttribDict
["EXTRA_HEADER_SIZE"] = -1
3120 while self
.__IsKeyword
("PROCESSING_REQUIRED") or self
.__IsKeyword
("AUTH_STATUS_VALID") \
3121 or self
.__IsKeyword
("EXTRA_HEADER_SIZE"):
3122 AttribKey
= self
.__Token
3124 if not self
.__IsToken
("="):
3125 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
3127 if not self
.__GetNextToken
():
3128 raise Warning("expected TRUE(1)/FALSE(0)/Number", self
.FileName
, self
.CurrentLineNumber
)
3129 elif AttribKey
== "EXTRA_HEADER_SIZE":
3131 if self
.__Token
[0:2].upper() == "0X":
3134 AttribDict
[AttribKey
] = int(self
.__Token
, Base
)
3137 raise Warning("expected Number", self
.FileName
, self
.CurrentLineNumber
)
3138 elif self
.__Token
.upper() not in ("TRUE", "FALSE", "1", "0"):
3139 raise Warning("expected TRUE/FALSE (1/0)", self
.FileName
, self
.CurrentLineNumber
)
3140 AttribDict
[AttribKey
] = self
.__Token
3144 ## __GetEncapsulationSec() method
3146 # Get encapsulation section for FILE
3148 # @param self The object pointer
3149 # @param FfsFile for whom section is got
3150 # @retval True Successfully find section statement
3151 # @retval False Not able to find section statement
3153 def __GetEncapsulationSec(self
, FfsFileObj
):
3155 OldPos
= self
.GetFileBufferPos()
3156 if not self
.__IsKeyword
( "SECTION"):
3157 if len(FfsFileObj
.SectionList
) == 0:
3158 raise Warning("expected SECTION", self
.FileName
, self
.CurrentLineNumber
)
3163 if self
.__GetAlignment
():
3164 if self
.__Token
not in ("8", "16", "32", "64", "128", "512", "1K", "4K", "32K" ,"64K"):
3165 raise Warning("Incorrect alignment '%s'" % self
.__Token
, self
.FileName
, self
.CurrentLineNumber
)
3166 AlignValue
= self
.__Token
3168 if not self
.__GetCglSection
(FfsFileObj
, AlignValue
):
3169 self
.SetFileBufferPos(OldPos
)
3175 if not self
.__GetNextToken
():
3177 S
= self
.__Token
.upper()
3178 if S
.startswith("[") and not S
.startswith("[FMPPAYLOAD."):
3179 self
.SectionParser(S
)
3184 self
.__SkipToToken
("[FMPPAYLOAD.", True)
3185 FmpUiName
= self
.__GetUiName
().upper()
3186 if FmpUiName
in self
.Profile
.FmpPayloadDict
:
3187 raise Warning("Duplicated FMP UI name found: %s" % FmpUiName
, self
.FileName
, self
.CurrentLineNumber
)
3189 FmpData
= CapsuleData
.CapsulePayload()
3190 FmpData
.UiName
= FmpUiName
3192 if not self
.__IsToken
( "]"):
3193 raise Warning("expected ']'", self
.FileName
, self
.CurrentLineNumber
)
3195 if not self
.__GetNextToken
():
3196 raise Warning("The FMP payload section is empty!", self
.FileName
, self
.CurrentLineNumber
)
3197 FmpKeyList
= ['IMAGE_HEADER_INIT_VERSION', 'IMAGE_TYPE_ID', 'IMAGE_INDEX', 'HARDWARE_INSTANCE', 'CERTIFICATE_GUID', 'MONOTONIC_COUNT']
3198 while self
.__Token
in FmpKeyList
:
3200 FmpKeyList
.remove(Name
)
3201 if not self
.__IsToken
("="):
3202 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
3203 if Name
== 'IMAGE_TYPE_ID':
3204 if not self
.__GetNextGuid
():
3205 raise Warning("expected GUID value for IMAGE_TYPE_ID.", self
.FileName
, self
.CurrentLineNumber
)
3206 FmpData
.ImageTypeId
= self
.__Token
3207 elif Name
== 'CERTIFICATE_GUID':
3208 if not self
.__GetNextGuid
():
3209 raise Warning("expected GUID value for CERTIFICATE_GUID.", self
.FileName
, self
.CurrentLineNumber
)
3210 FmpData
.Certificate_Guid
= self
.__Token
3211 if uuid
.UUID(FmpData
.Certificate_Guid
) != EFI_CERT_TYPE_RSA2048_SHA256_GUID
and uuid
.UUID(FmpData
.Certificate_Guid
) != EFI_CERT_TYPE_PKCS7_GUID
:
3212 raise Warning("Only support EFI_CERT_TYPE_RSA2048_SHA256_GUID or EFI_CERT_TYPE_PKCS7_GUID for CERTIFICATE_GUID.", self
.FileName
, self
.CurrentLineNumber
)
3214 if not self
.__GetNextToken
():
3215 raise Warning("expected value of %s" % Name
, self
.FileName
, self
.CurrentLineNumber
)
3216 Value
= self
.__Token
3217 if Name
== 'IMAGE_HEADER_INIT_VERSION':
3218 if self
.__Verify
(Name
, Value
, 'UINT8'):
3219 FmpData
.Version
= Value
3220 elif Name
== 'IMAGE_INDEX':
3221 if self
.__Verify
(Name
, Value
, 'UINT8'):
3222 FmpData
.ImageIndex
= Value
3223 elif Name
== 'HARDWARE_INSTANCE':
3224 if self
.__Verify
(Name
, Value
, 'UINT8'):
3225 FmpData
.HardwareInstance
= Value
3226 elif Name
== 'MONOTONIC_COUNT':
3227 if self
.__Verify
(Name
, Value
, 'UINT64'):
3228 FmpData
.MonotonicCount
= Value
3229 if FmpData
.MonotonicCount
.upper().startswith('0X'):
3230 FmpData
.MonotonicCount
= (long)(FmpData
.MonotonicCount
, 16)
3232 FmpData
.MonotonicCount
= (long)(FmpData
.MonotonicCount
)
3233 if not self
.__GetNextToken
():
3238 if (FmpData
.MonotonicCount
and not FmpData
.Certificate_Guid
) or (not FmpData
.MonotonicCount
and FmpData
.Certificate_Guid
):
3239 EdkLogger
.error("FdfParser", FORMAT_INVALID
, "CERTIFICATE_GUID and MONOTONIC_COUNT must be work as a pair.")
3240 # remove CERTIFICATE_GUID and MONOTONIC_COUNT from FmpKeyList, since these keys are optional
3241 if 'CERTIFICATE_GUID' in FmpKeyList
:
3242 FmpKeyList
.remove('CERTIFICATE_GUID')
3243 if 'MONOTONIC_COUNT' in FmpKeyList
:
3244 FmpKeyList
.remove('MONOTONIC_COUNT')
3246 raise Warning("Missing keywords %s in FMP payload section." % ', '.join(FmpKeyList
), self
.FileName
, self
.CurrentLineNumber
)
3247 # get the Image file and Vendor code file
3248 self
.__GetFMPCapsuleData
(FmpData
)
3249 if not FmpData
.ImageFile
:
3250 raise Warning("Missing image file in FMP payload section.", self
.FileName
, self
.CurrentLineNumber
)
3251 # check whether more than one Vendor code file
3252 if len(FmpData
.VendorCodeFile
) > 1:
3253 raise Warning("At most one Image file and one Vendor code file are allowed in FMP payload section.", self
.FileName
, self
.CurrentLineNumber
)
3254 self
.Profile
.FmpPayloadDict
[FmpUiName
] = FmpData
3257 ## __GetCapsule() method
3259 # Get capsule section contents and store its data into capsule list of self.Profile
3261 # @param self The object pointer
3262 # @retval True Successfully find a capsule
3263 # @retval False Not able to find a capsule
3265 def __GetCapsule(self
):
3267 if not self
.__GetNextToken
():
3270 S
= self
.__Token
.upper()
3271 if S
.startswith("[") and not S
.startswith("[CAPSULE."):
3272 self
.SectionParser(S
)
3277 if not self
.__IsToken
("[CAPSULE.", True):
3278 FileLineTuple
= GetRealFileLine(self
.FileName
, self
.CurrentLineNumber
)
3279 #print 'Parsing String: %s in File %s, At line: %d, Offset Within Line: %d' \
3280 # % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine :], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine)
3281 raise Warning("expected [Capsule.]", self
.FileName
, self
.CurrentLineNumber
)
3283 CapsuleObj
= Capsule
.Capsule()
3285 CapsuleName
= self
.__GetUiName
()
3287 raise Warning("expected capsule name", self
.FileName
, self
.CurrentLineNumber
)
3289 CapsuleObj
.UiCapsuleName
= CapsuleName
.upper()
3291 if not self
.__IsToken
( "]"):
3292 raise Warning("expected ']'", self
.FileName
, self
.CurrentLineNumber
)
3294 if self
.__IsKeyword
("CREATE_FILE"):
3295 if not self
.__IsToken
( "="):
3296 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
3298 if not self
.__GetNextToken
():
3299 raise Warning("expected file name", self
.FileName
, self
.CurrentLineNumber
)
3301 CapsuleObj
.CreateFile
= self
.__Token
3303 self
.__GetCapsuleStatements
(CapsuleObj
)
3304 self
.Profile
.CapsuleDict
[CapsuleObj
.UiCapsuleName
] = CapsuleObj
3307 ## __GetCapsuleStatements() method
3309 # Get statements for capsule
3311 # @param self The object pointer
3312 # @param Obj for whom statements are got
3314 def __GetCapsuleStatements(self
, Obj
):
3315 self
.__GetCapsuleTokens
(Obj
)
3316 self
.__GetDefineStatements
(Obj
)
3317 self
.__GetSetStatements
(Obj
)
3318 self
.__GetCapsuleData
(Obj
)
3320 ## __GetCapsuleTokens() method
3322 # Get token statements for capsule
3324 # @param self The object pointer
3325 # @param Obj for whom token statements are got
3327 def __GetCapsuleTokens(self
, Obj
):
3328 if not self
.__GetNextToken
():
3330 while self
.__Token
in ("CAPSULE_GUID", "CAPSULE_HEADER_SIZE", "CAPSULE_FLAGS", "OEM_CAPSULE_FLAGS", "CAPSULE_HEADER_INIT_VERSION"):
3331 Name
= self
.__Token
.strip()
3332 if not self
.__IsToken
("="):
3333 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
3334 if not self
.__GetNextToken
():
3335 raise Warning("expected value", self
.FileName
, self
.CurrentLineNumber
)
3336 if Name
== 'CAPSULE_FLAGS':
3337 if not self
.__Token
in ("PersistAcrossReset", "PopulateSystemTable", "InitiateReset"):
3338 raise Warning("expected PersistAcrossReset, PopulateSystemTable, or InitiateReset", self
.FileName
, self
.CurrentLineNumber
)
3339 Value
= self
.__Token
.strip()
3340 while self
.__IsToken
(","):
3342 if not self
.__GetNextToken
():
3343 raise Warning("expected value", self
.FileName
, self
.CurrentLineNumber
)
3344 if not self
.__Token
in ("PersistAcrossReset", "PopulateSystemTable", "InitiateReset"):
3345 raise Warning("expected PersistAcrossReset, PopulateSystemTable, or InitiateReset", self
.FileName
, self
.CurrentLineNumber
)
3346 Value
+= self
.__Token
.strip()
3347 elif Name
== 'OEM_CAPSULE_FLAGS':
3348 Value
= self
.__Token
.strip()
3349 if not Value
.upper().startswith('0X'):
3350 raise Warning("expected hex value between 0x0000 and 0xFFFF", self
.FileName
, self
.CurrentLineNumber
)
3352 Value
= int(Value
, 0)
3354 raise Warning("expected hex value between 0x0000 and 0xFFFF", self
.FileName
, self
.CurrentLineNumber
)
3355 if not 0x0000 <= Value
<= 0xFFFF:
3356 raise Warning("expected hex value between 0x0000 and 0xFFFF", self
.FileName
, self
.CurrentLineNumber
)
3357 Value
= self
.__Token
.strip()
3359 Value
= self
.__Token
.strip()
3360 Obj
.TokensDict
[Name
] = Value
3361 if not self
.__GetNextToken
():
3365 ## __GetCapsuleData() method
3367 # Get capsule data for capsule
3369 # @param self The object pointer
3370 # @param Obj for whom capsule data are got
3372 def __GetCapsuleData(self
, Obj
):
3375 IsInf
= self
.__GetInfStatement
(Obj
, True)
3376 IsFile
= self
.__GetFileStatement
(Obj
, True)
3377 IsFv
= self
.__GetFvStatement
(Obj
)
3378 IsFd
= self
.__GetFdStatement
(Obj
)
3379 IsAnyFile
= self
.__GetAnyFileStatement
(Obj
)
3380 IsAfile
= self
.__GetAfileStatement
(Obj
)
3381 IsFmp
= self
.__GetFmpStatement
(Obj
)
3382 if not (IsInf
or IsFile
or IsFv
or IsFd
or IsAnyFile
or IsAfile
or IsFmp
):
3385 ## __GetFMPCapsuleData() method
3387 # Get capsule data for FMP capsule
3389 # @param self The object pointer
3390 # @param Obj for whom capsule data are got
3392 def __GetFMPCapsuleData(self
, Obj
):
3395 IsFv
= self
.__GetFvStatement
(Obj
, True)
3396 IsFd
= self
.__GetFdStatement
(Obj
, True)
3397 IsAnyFile
= self
.__GetAnyFileStatement
(Obj
, True)
3398 if not (IsFv
or IsFd
or IsAnyFile
):
3401 ## __GetFvStatement() method
3403 # Get FV for capsule
3405 # @param self The object pointer
3406 # @param CapsuleObj for whom FV is got
3407 # @retval True Successfully find a FV statement
3408 # @retval False Not able to find a FV statement
3410 def __GetFvStatement(self
, CapsuleObj
, FMPCapsule
= False):
3412 if not self
.__IsKeyword
("FV"):
3415 if not self
.__IsToken
("="):
3416 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
3418 if not self
.__GetNextToken
():
3419 raise Warning("expected FV name", self
.FileName
, self
.CurrentLineNumber
)
3421 if self
.__Token
.upper() not in self
.Profile
.FvDict
.keys():
3422 raise Warning("FV name does not exist", self
.FileName
, self
.CurrentLineNumber
)
3424 CapsuleFv
= CapsuleData
.CapsuleFv()
3425 CapsuleFv
.FvName
= self
.__Token
3427 if not CapsuleObj
.ImageFile
:
3428 CapsuleObj
.ImageFile
.append(CapsuleFv
)
3430 CapsuleObj
.VendorCodeFile
.append(CapsuleFv
)
3432 CapsuleObj
.CapsuleDataList
.append(CapsuleFv
)
3435 ## __GetFdStatement() method
3437 # Get FD for capsule
3439 # @param self The object pointer
3440 # @param CapsuleObj for whom FD is got
3441 # @retval True Successfully find a FD statement
3442 # @retval False Not able to find a FD statement
3444 def __GetFdStatement(self
, CapsuleObj
, FMPCapsule
= False):
3446 if not self
.__IsKeyword
("FD"):
3449 if not self
.__IsToken
("="):
3450 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
3452 if not self
.__GetNextToken
():
3453 raise Warning("expected FD name", self
.FileName
, self
.CurrentLineNumber
)
3455 if self
.__Token
.upper() not in self
.Profile
.FdDict
.keys():
3456 raise Warning("FD name does not exist", self
.FileName
, self
.CurrentLineNumber
)
3458 CapsuleFd
= CapsuleData
.CapsuleFd()
3459 CapsuleFd
.FdName
= self
.__Token
3461 if not CapsuleObj
.ImageFile
:
3462 CapsuleObj
.ImageFile
.append(CapsuleFd
)
3464 CapsuleObj
.VendorCodeFile
.append(CapsuleFd
)
3466 CapsuleObj
.CapsuleDataList
.append(CapsuleFd
)
3469 def __GetFmpStatement(self
, CapsuleObj
):
3470 if not self
.__IsKeyword
("FMP_PAYLOAD"):
3471 if not self
.__IsKeyword
("FMP"):
3474 if not self
.__IsKeyword
("PAYLOAD"):
3478 if not self
.__IsToken
("="):
3479 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
3481 if not self
.__GetNextToken
():
3482 raise Warning("expected payload name after FMP_PAYLOAD =", self
.FileName
, self
.CurrentLineNumber
)
3483 Payload
= self
.__Token
.upper()
3484 if Payload
not in self
.Profile
.FmpPayloadDict
:
3485 raise Warning("This FMP Payload does not exist: %s" % self
.__Token
, self
.FileName
, self
.CurrentLineNumber
)
3486 CapsuleObj
.FmpPayloadList
.append(self
.Profile
.FmpPayloadDict
[Payload
])
3489 def __ParseRawFileStatement(self
):
3490 if not self
.__IsKeyword
("FILE"):
3493 if not self
.__IsKeyword
("DATA"):
3497 if not self
.__IsToken
("="):
3498 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
3500 if not self
.__GetNextToken
():
3501 raise Warning("expected File name", self
.FileName
, self
.CurrentLineNumber
)
3503 AnyFileName
= self
.__Token
3504 self
.__VerifyFile
(AnyFileName
)
3508 ## __GetAnyFileStatement() method
3510 # Get AnyFile for capsule
3512 # @param self The object pointer
3513 # @param CapsuleObj for whom AnyFile is got
3514 # @retval True Successfully find a Anyfile statement
3515 # @retval False Not able to find a AnyFile statement
3517 def __GetAnyFileStatement(self
, CapsuleObj
, FMPCapsule
= False):
3518 AnyFileName
= self
.__ParseRawFileStatement
()
3522 CapsuleAnyFile
= CapsuleData
.CapsuleAnyFile()
3523 CapsuleAnyFile
.FileName
= AnyFileName
3525 if not CapsuleObj
.ImageFile
:
3526 CapsuleObj
.ImageFile
.append(CapsuleAnyFile
)
3528 CapsuleObj
.VendorCodeFile
.append(CapsuleAnyFile
)
3530 CapsuleObj
.CapsuleDataList
.append(CapsuleAnyFile
)
3533 ## __GetAfileStatement() method
3535 # Get Afile for capsule
3537 # @param self The object pointer
3538 # @param CapsuleObj for whom Afile is got
3539 # @retval True Successfully find a Afile statement
3540 # @retval False Not able to find a Afile statement
3542 def __GetAfileStatement(self
, CapsuleObj
):
3544 if not self
.__IsKeyword
("APPEND"):
3547 if not self
.__IsToken
("="):
3548 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
3550 if not self
.__GetNextToken
():
3551 raise Warning("expected Afile name", self
.FileName
, self
.CurrentLineNumber
)
3553 AfileName
= self
.__Token
3554 AfileBaseName
= os
.path
.basename(AfileName
)
3556 if os
.path
.splitext(AfileBaseName
)[1] not in [".bin",".BIN",".Bin",".dat",".DAT",".Dat",".data",".DATA",".Data"]:
3557 raise Warning('invalid binary file type, should be one of "bin","BIN","Bin","dat","DAT","Dat","data","DATA","Data"', \
3558 self
.FileName
, self
.CurrentLineNumber
)
3560 if not os
.path
.isabs(AfileName
):
3561 AfileName
= GenFdsGlobalVariable
.ReplaceWorkspaceMacro(AfileName
)
3562 self
.__VerifyFile
(AfileName
)
3564 if not os
.path
.exists(AfileName
):
3565 raise Warning('%s does not exist' % AfileName
, self
.FileName
, self
.CurrentLineNumber
)
3569 CapsuleAfile
= CapsuleData
.CapsuleAfile()
3570 CapsuleAfile
.FileName
= AfileName
3571 CapsuleObj
.CapsuleDataList
.append(CapsuleAfile
)
3574 ## __GetRule() method
3576 # Get Rule section contents and store its data into rule list of self.Profile
3578 # @param self The object pointer
3579 # @retval True Successfully find a Rule
3580 # @retval False Not able to find a Rule
3582 def __GetRule(self
):
3584 if not self
.__GetNextToken
():
3587 S
= self
.__Token
.upper()
3588 if S
.startswith("[") and not S
.startswith("[RULE."):
3589 self
.SectionParser(S
)
3593 if not self
.__IsToken
("[Rule.", True):
3594 FileLineTuple
= GetRealFileLine(self
.FileName
, self
.CurrentLineNumber
)
3595 #print 'Parsing String: %s in File %s, At line: %d, Offset Within Line: %d' \
3596 # % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine :], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine)
3597 raise Warning("expected [Rule.]", self
.FileName
, self
.CurrentLineNumber
)
3599 if not self
.__SkipToToken
("."):
3600 raise Warning("expected '.'", self
.FileName
, self
.CurrentLineNumber
)
3602 Arch
= self
.__SkippedChars
.rstrip(".")
3603 if Arch
.upper() not in ("IA32", "X64", "IPF", "EBC", "ARM", "AARCH64", "COMMON"):
3604 raise Warning("Unknown Arch '%s'" % Arch
, self
.FileName
, self
.CurrentLineNumber
)
3606 ModuleType
= self
.__GetModuleType
()
3609 if self
.__IsToken
("."):
3610 if not self
.__GetNextWord
():
3611 raise Warning("expected template name", self
.FileName
, self
.CurrentLineNumber
)
3612 TemplateName
= self
.__Token
3614 if not self
.__IsToken
( "]"):
3615 raise Warning("expected ']'", self
.FileName
, self
.CurrentLineNumber
)
3617 RuleObj
= self
.__GetRuleFileStatements
()
3618 RuleObj
.Arch
= Arch
.upper()
3619 RuleObj
.ModuleType
= ModuleType
3620 RuleObj
.TemplateName
= TemplateName
3621 if TemplateName
== '' :
3622 self
.Profile
.RuleDict
['RULE' + \
3626 ModuleType
.upper() ] = RuleObj
3628 self
.Profile
.RuleDict
['RULE' + \
3632 ModuleType
.upper() + \
3634 TemplateName
.upper() ] = RuleObj
3635 # self.Profile.RuleList.append(rule)
3638 ## __GetModuleType() method
3640 # Return the module type
3642 # @param self The object pointer
3643 # @retval string module type
3645 def __GetModuleType(self
):
3647 if not self
.__GetNextWord
():
3648 raise Warning("expected Module type", self
.FileName
, self
.CurrentLineNumber
)
3649 if self
.__Token
.upper() not in ("SEC", "PEI_CORE", "PEIM", "DXE_CORE", \
3650 "DXE_DRIVER", "DXE_SAL_DRIVER", \
3651 "DXE_SMM_DRIVER", "DXE_RUNTIME_DRIVER", \
3652 "UEFI_DRIVER", "UEFI_APPLICATION", "USER_DEFINED", "DEFAULT", "BASE", \
3653 "SECURITY_CORE", "COMBINED_PEIM_DRIVER", "PIC_PEIM", "RELOCATABLE_PEIM", \
3654 "PE32_PEIM", "BS_DRIVER", "RT_DRIVER", "SAL_RT_DRIVER", "APPLICATION", "ACPITABLE", "SMM_CORE"):
3655 raise Warning("Unknown Module type '%s'" % self
.__Token
, self
.FileName
, self
.CurrentLineNumber
)
3658 ## __GetFileExtension() method
3660 # Return the file extension
3662 # @param self The object pointer
3663 # @retval string file name extension
3665 def __GetFileExtension(self
):
3666 if not self
.__IsToken
("."):
3667 raise Warning("expected '.'", self
.FileName
, self
.CurrentLineNumber
)
3670 if self
.__GetNextToken
():
3671 Pattern
= re
.compile(r
'([a-zA-Z][a-zA-Z0-9]*)')
3672 if Pattern
.match(self
.__Token
):
3676 raise Warning("Unknown file extension '%s'" % self
.__Token
, self
.FileName
, self
.CurrentLineNumber
)
3679 raise Warning("expected file extension", self
.FileName
, self
.CurrentLineNumber
)
3681 ## __GetRuleFileStatement() method
3685 # @param self The object pointer
3686 # @retval Rule Rule object
3688 def __GetRuleFileStatements(self
):
3690 if not self
.__IsKeyword
("FILE"):
3691 raise Warning("expected FILE", self
.FileName
, self
.CurrentLineNumber
)
3693 if not self
.__GetNextWord
():
3694 raise Warning("expected FFS type", self
.FileName
, self
.CurrentLineNumber
)
3696 Type
= self
.__Token
.strip().upper()
3697 if Type
not in ("RAW", "FREEFORM", "SEC", "PEI_CORE", "PEIM",\
3698 "PEI_DXE_COMBO", "DRIVER", "DXE_CORE", "APPLICATION", "FV_IMAGE", "SMM", "SMM_CORE"):
3699 raise Warning("Unknown FV type '%s'" % self
.__Token
, self
.FileName
, self
.CurrentLineNumber
)
3701 if not self
.__IsToken
("="):
3702 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
3704 if not self
.__IsKeyword
("$(NAMED_GUID)"):
3705 if not self
.__GetNextWord
():
3706 raise Warning("expected $(NAMED_GUID)", self
.FileName
, self
.CurrentLineNumber
)
3707 if self
.__Token
== 'PCD':
3708 if not self
.__IsToken
( "("):
3709 raise Warning("expected '('", self
.FileName
, self
.CurrentLineNumber
)
3710 PcdPair
= self
.__GetNextPcdName
()
3711 if not self
.__IsToken
( ")"):
3712 raise Warning("expected ')'", self
.FileName
, self
.CurrentLineNumber
)
3713 self
.__Token
= 'PCD('+PcdPair
[1]+'.'+PcdPair
[0]+')'
3715 NameGuid
= self
.__Token
3718 if self
.__IsKeyword
('RELOCS_STRIPPED') or self
.__IsKeyword
('RELOCS_RETAINED'):
3719 if self
.__FileCouldHaveRelocFlag
(Type
):
3720 if self
.__Token
== 'RELOCS_STRIPPED':
3725 raise Warning("File type %s could not have reloc strip flag%d" % (Type
, self
.CurrentLineNumber
), self
.FileName
, self
.CurrentLineNumber
)
3728 if self
.__GetNextToken
():
3729 Pattern
= re
.compile(r
'([a-zA-Z0-9\-]+|\$\(TARGET\)|\*)_([a-zA-Z0-9\-]+|\$\(TOOL_CHAIN_TAG\)|\*)_([a-zA-Z0-9\-]+|\$\(ARCH\)|\*)')
3730 if Pattern
.match(self
.__Token
):
3731 KeyStringList
.append(self
.__Token
)
3732 if self
.__IsToken
(","):
3733 while self
.__GetNextToken
():
3734 if not Pattern
.match(self
.__Token
):
3735 raise Warning("expected KeyString \"Target_Tag_Arch\"", self
.FileName
, self
.CurrentLineNumber
)
3736 KeyStringList
.append(self
.__Token
)
3738 if not self
.__IsToken
(","):
3746 if self
.__IsKeyword
("Fixed", True):
3750 if self
.__IsKeyword
("CheckSum", True):
3754 if self
.__GetAlignment
():
3755 if self
.__Token
not in ("Auto", "8", "16", "32", "64", "128", "512", "1K", "4K", "32K" ,"64K"):
3756 raise Warning("Incorrect alignment '%s'" % self
.__Token
, self
.FileName
, self
.CurrentLineNumber
)
3757 #For FFS, Auto is default option same to ""
3758 if not self
.__Token
== "Auto":
3759 AlignValue
= self
.__Token
3761 if self
.__IsToken
("{"):
3762 # Complex file rule expected
3763 Rule
= RuleComplexFile
.RuleComplexFile()
3764 Rule
.FvFileType
= Type
3765 Rule
.NameGuid
= NameGuid
3766 Rule
.Alignment
= AlignValue
3767 Rule
.CheckSum
= CheckSum
3769 Rule
.KeyStringList
= KeyStringList
3770 if KeepReloc
!= None:
3771 Rule
.KeepReloc
= KeepReloc
3774 IsEncapsulate
= self
.__GetRuleEncapsulationSection
(Rule
)
3775 IsLeaf
= self
.__GetEfiSection
(Rule
)
3776 if not IsEncapsulate
and not IsLeaf
:
3779 if not self
.__IsToken
("}"):
3780 raise Warning("expected '}'", self
.FileName
, self
.CurrentLineNumber
)
3785 # Simple file rule expected
3786 if not self
.__GetNextWord
():
3787 raise Warning("expected leaf section type", self
.FileName
, self
.CurrentLineNumber
)
3789 SectionName
= self
.__Token
3791 if SectionName
not in ("COMPAT16", "PE32", "PIC", "TE", "FV_IMAGE", "RAW", "DXE_DEPEX",\
3792 "UI", "PEI_DEPEX", "VERSION", "SUBTYPE_GUID", "SMM_DEPEX"):
3793 raise Warning("Unknown leaf section name '%s'" % SectionName
, self
.FileName
, self
.CurrentLineNumber
)
3796 if self
.__IsKeyword
("Fixed", True):
3799 if self
.__IsKeyword
("CheckSum", True):
3803 if self
.__GetAlignment
():
3804 if self
.__Token
not in ("Auto", "8", "16", "32", "64", "128", "512", "1K", "4K", "32K" ,"64K"):
3805 raise Warning("Incorrect alignment '%s'" % self
.__Token
, self
.FileName
, self
.CurrentLineNumber
)
3806 if self
.__Token
== 'Auto' and (not SectionName
== 'PE32') and (not SectionName
== 'TE'):
3807 raise Warning("Auto alignment can only be used in PE32 or TE section ", self
.FileName
, self
.CurrentLineNumber
)
3808 SectAlignment
= self
.__Token
3811 if self
.__IsToken
('|'):
3812 Ext
= self
.__GetFileExtension
()
3813 elif not self
.__GetNextToken
():
3814 raise Warning("expected File name", self
.FileName
, self
.CurrentLineNumber
)
3816 Rule
= RuleSimpleFile
.RuleSimpleFile()
3817 Rule
.SectionType
= SectionName
3818 Rule
.FvFileType
= Type
3819 Rule
.NameGuid
= NameGuid
3820 Rule
.Alignment
= AlignValue
3821 Rule
.SectAlignment
= SectAlignment
3822 Rule
.CheckSum
= CheckSum
3824 Rule
.KeyStringList
= KeyStringList
3825 if KeepReloc
!= None:
3826 Rule
.KeepReloc
= KeepReloc
3827 Rule
.FileExtension
= Ext
3828 Rule
.FileName
= self
.__Token
3831 ## __GetEfiSection() method
3833 # Get section list for Rule
3835 # @param self The object pointer
3836 # @param Obj for whom section is got
3837 # @retval True Successfully find section statement
3838 # @retval False Not able to find section statement
3840 def __GetEfiSection(self
, Obj
):
3842 OldPos
= self
.GetFileBufferPos()
3843 if not self
.__GetNextWord
():
3845 SectionName
= self
.__Token
3847 if SectionName
not in ("COMPAT16", "PE32", "PIC", "TE", "FV_IMAGE", "RAW", "DXE_DEPEX",\
3848 "UI", "VERSION", "PEI_DEPEX", "GUID", "SMM_DEPEX"):
3852 if SectionName
== "FV_IMAGE":
3853 FvImageSectionObj
= FvImageSection
.FvImageSection()
3854 if self
.__IsKeyword
("FV_IMAGE"):
3856 if self
.__IsToken
( "{"):
3858 self
.__GetDefineStatements
(FvObj
)
3859 self
.__GetBlockStatement
(FvObj
)
3860 self
.__GetSetStatements
(FvObj
)
3861 self
.__GetFvAlignment
(FvObj
)
3862 self
.__GetFvAttributes
(FvObj
)
3863 self
.__GetAprioriSection
(FvObj
)
3864 self
.__GetAprioriSection
(FvObj
)
3867 IsInf
= self
.__GetInfStatement
(FvObj
)
3868 IsFile
= self
.__GetFileStatement
(FvObj
)
3869 if not IsInf
and not IsFile
:
3872 if not self
.__IsToken
( "}"):
3873 raise Warning("expected '}'", self
.FileName
, self
.CurrentLineNumber
)
3874 FvImageSectionObj
.Fv
= FvObj
3875 FvImageSectionObj
.FvName
= None
3878 if not self
.__IsKeyword
("FV"):
3879 raise Warning("expected 'FV'", self
.FileName
, self
.CurrentLineNumber
)
3880 FvImageSectionObj
.FvFileType
= self
.__Token
3882 if self
.__GetAlignment
():
3883 if self
.__Token
not in ("8", "16", "32", "64", "128", "512", "1K", "4K", "32K" ,"64K"):
3884 raise Warning("Incorrect alignment '%s'" % self
.__Token
, self
.FileName
, self
.CurrentLineNumber
)
3885 FvImageSectionObj
.Alignment
= self
.__Token
3887 if self
.__IsToken
('|'):
3888 FvImageSectionObj
.FvFileExtension
= self
.__GetFileExtension
()
3889 elif self
.__GetNextToken
():
3890 if self
.__Token
not in ("}", "COMPAT16", "PE32", "PIC", "TE", "FV_IMAGE", "RAW", "DXE_DEPEX",\
3891 "UI", "VERSION", "PEI_DEPEX", "GUID", "SMM_DEPEX"):
3892 FvImageSectionObj
.FvFileName
= self
.__Token
3896 raise Warning("expected FV file name", self
.FileName
, self
.CurrentLineNumber
)
3898 Obj
.SectionList
.append(FvImageSectionObj
)
3901 EfiSectionObj
= EfiSection
.EfiSection()
3902 EfiSectionObj
.SectionType
= SectionName
3904 if not self
.__GetNextToken
():
3905 raise Warning("expected file type", self
.FileName
, self
.CurrentLineNumber
)
3907 if self
.__Token
== "STRING":
3908 if not self
.__RuleSectionCouldHaveString
(EfiSectionObj
.SectionType
):
3909 raise Warning("%s section could NOT have string data%d" % (EfiSectionObj
.SectionType
, self
.CurrentLineNumber
), self
.FileName
, self
.CurrentLineNumber
)
3911 if not self
.__IsToken
('='):
3912 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
3914 if not self
.__GetNextToken
():
3915 raise Warning("expected Quoted String", self
.FileName
, self
.CurrentLineNumber
)
3917 if self
.__GetStringData
():
3918 EfiSectionObj
.StringData
= self
.__Token
3920 if self
.__IsKeyword
("BUILD_NUM"):
3921 if not self
.__RuleSectionCouldHaveBuildNum
(EfiSectionObj
.SectionType
):
3922 raise Warning("%s section could NOT have BUILD_NUM%d" % (EfiSectionObj
.SectionType
, self
.CurrentLineNumber
), self
.FileName
, self
.CurrentLineNumber
)
3924 if not self
.__IsToken
("="):
3925 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
3926 if not self
.__GetNextToken
():
3927 raise Warning("expected Build number", self
.FileName
, self
.CurrentLineNumber
)
3928 EfiSectionObj
.BuildNum
= self
.__Token
3931 EfiSectionObj
.FileType
= self
.__Token
3932 self
.__CheckRuleSectionFileType
(EfiSectionObj
.SectionType
, EfiSectionObj
.FileType
)
3934 if self
.__IsKeyword
("Optional"):
3935 if not self
.__RuleSectionCouldBeOptional
(EfiSectionObj
.SectionType
):
3936 raise Warning("%s section could NOT be optional%d" % (EfiSectionObj
.SectionType
, self
.CurrentLineNumber
), self
.FileName
, self
.CurrentLineNumber
)
3937 EfiSectionObj
.Optional
= True
3939 if self
.__IsKeyword
("BUILD_NUM"):
3940 if not self
.__RuleSectionCouldHaveBuildNum
(EfiSectionObj
.SectionType
):
3941 raise Warning("%s section could NOT have BUILD_NUM%d" % (EfiSectionObj
.SectionType
, self
.CurrentLineNumber
), self
.FileName
, self
.CurrentLineNumber
)
3943 if not self
.__IsToken
("="):
3944 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
3945 if not self
.__GetNextToken
():
3946 raise Warning("expected Build number", self
.FileName
, self
.CurrentLineNumber
)
3947 EfiSectionObj
.BuildNum
= self
.__Token
3949 if self
.__GetAlignment
():
3950 if self
.__Token
not in ("Auto", "8", "16", "32", "64", "128", "512", "1K", "4K", "32K" ,"64K"):
3951 raise Warning("Incorrect alignment '%s'" % self
.__Token
, self
.FileName
, self
.CurrentLineNumber
)
3952 if self
.__Token
== 'Auto' and (not SectionName
== 'PE32') and (not SectionName
== 'TE'):
3953 raise Warning("Auto alignment can only be used in PE32 or TE section ", self
.FileName
, self
.CurrentLineNumber
)
3954 EfiSectionObj
.Alignment
= self
.__Token
3956 if self
.__IsKeyword
('RELOCS_STRIPPED') or self
.__IsKeyword
('RELOCS_RETAINED'):
3957 if self
.__SectionCouldHaveRelocFlag
(EfiSectionObj
.SectionType
):
3958 if self
.__Token
== 'RELOCS_STRIPPED':
3959 EfiSectionObj
.KeepReloc
= False
3961 EfiSectionObj
.KeepReloc
= True
3962 if Obj
.KeepReloc
!= None and Obj
.KeepReloc
!= EfiSectionObj
.KeepReloc
:
3963 raise Warning("Section type %s has reloc strip flag conflict with Rule" % EfiSectionObj
.SectionType
, self
.FileName
, self
.CurrentLineNumber
)
3965 raise Warning("Section type %s could not have reloc strip flag" % EfiSectionObj
.SectionType
, self
.FileName
, self
.CurrentLineNumber
)
3968 if self
.__IsToken
('|'):
3969 EfiSectionObj
.FileExtension
= self
.__GetFileExtension
()
3970 elif self
.__GetNextToken
():
3971 if self
.__Token
not in ("}", "COMPAT16", "PE32", "PIC", "TE", "FV_IMAGE", "RAW", "DXE_DEPEX",\
3972 "UI", "VERSION", "PEI_DEPEX", "GUID", "SMM_DEPEX"):
3974 if self
.__Token
.startswith('PCD'):
3976 self
.__GetNextWord
()
3978 if self
.__Token
== 'PCD':
3979 if not self
.__IsToken
( "("):
3980 raise Warning("expected '('", self
.FileName
, self
.CurrentLineNumber
)
3981 PcdPair
= self
.__GetNextPcdName
()
3982 if not self
.__IsToken
( ")"):
3983 raise Warning("expected ')'", self
.FileName
, self
.CurrentLineNumber
)
3984 self
.__Token
= 'PCD('+PcdPair
[1]+'.'+PcdPair
[0]+')'
3986 EfiSectionObj
.FileName
= self
.__Token
3991 raise Warning("expected section file name", self
.FileName
, self
.CurrentLineNumber
)
3993 Obj
.SectionList
.append(EfiSectionObj
)
3996 ## __RuleSectionCouldBeOptional() method
3998 # Get whether a section could be optional
4000 # @param self The object pointer
4001 # @param SectionType The section type to check
4002 # @retval True section could be optional
4003 # @retval False section never optional
4005 def __RuleSectionCouldBeOptional(self
, SectionType
):
4006 if SectionType
in ("DXE_DEPEX", "UI", "VERSION", "PEI_DEPEX", "RAW", "SMM_DEPEX"):
4011 ## __RuleSectionCouldHaveBuildNum() method
4013 # Get whether a section could have build number information
4015 # @param self The object pointer
4016 # @param SectionType The section type to check
4017 # @retval True section could have build number information
4018 # @retval False section never have build number information
4020 def __RuleSectionCouldHaveBuildNum(self
, SectionType
):
4021 if SectionType
in ("VERSION"):
4026 ## __RuleSectionCouldHaveString() method
4028 # Get whether a section could have string
4030 # @param self The object pointer
4031 # @param SectionType The section type to check
4032 # @retval True section could have string
4033 # @retval False section never have string
4035 def __RuleSectionCouldHaveString(self
, SectionType
):
4036 if SectionType
in ("UI", "VERSION"):
4041 ## __CheckRuleSectionFileType() method
4043 # Get whether a section matches a file type
4045 # @param self The object pointer
4046 # @param SectionType The section type to check
4047 # @param FileType The file type to check
4049 def __CheckRuleSectionFileType(self
, SectionType
, FileType
):
4050 if SectionType
== "COMPAT16":
4051 if FileType
not in ("COMPAT16", "SEC_COMPAT16"):
4052 raise Warning("Incorrect section file type '%s'" % FileType
, self
.FileName
, self
.CurrentLineNumber
)
4053 elif SectionType
== "PE32":
4054 if FileType
not in ("PE32", "SEC_PE32"):
4055 raise Warning("Incorrect section file type '%s'" % FileType
, self
.FileName
, self
.CurrentLineNumber
)
4056 elif SectionType
== "PIC":
4057 if FileType
not in ("PIC", "PIC"):
4058 raise Warning("Incorrect section file type '%s'" % FileType
, self
.FileName
, self
.CurrentLineNumber
)
4059 elif SectionType
== "TE":
4060 if FileType
not in ("TE", "SEC_TE"):
4061 raise Warning("Incorrect section file type '%s'" % FileType
, self
.FileName
, self
.CurrentLineNumber
)
4062 elif SectionType
== "RAW":
4063 if FileType
not in ("BIN", "SEC_BIN", "RAW", "ASL", "ACPI"):
4064 raise Warning("Incorrect section file type '%s'" % FileType
, self
.FileName
, self
.CurrentLineNumber
)
4065 elif SectionType
== "DXE_DEPEX" or SectionType
== "SMM_DEPEX":
4066 if FileType
not in ("DXE_DEPEX", "SEC_DXE_DEPEX", "SMM_DEPEX"):
4067 raise Warning("Incorrect section file type '%s'" % FileType
, self
.FileName
, self
.CurrentLineNumber
)
4068 elif SectionType
== "UI":
4069 if FileType
not in ("UI", "SEC_UI"):
4070 raise Warning("Incorrect section file type '%s'" % FileType
, self
.FileName
, self
.CurrentLineNumber
)
4071 elif SectionType
== "VERSION":
4072 if FileType
not in ("VERSION", "SEC_VERSION"):
4073 raise Warning("Incorrect section file type '%s'" % FileType
, self
.FileName
, self
.CurrentLineNumber
)
4074 elif SectionType
== "PEI_DEPEX":
4075 if FileType
not in ("PEI_DEPEX", "SEC_PEI_DEPEX"):
4076 raise Warning("Incorrect section file type '%s'" % FileType
, self
.FileName
, self
.CurrentLineNumber
)
4077 elif SectionType
== "GUID":
4078 if FileType
not in ("PE32", "SEC_GUID"):
4079 raise Warning("Incorrect section file type '%s'" % FileType
, self
.FileName
, self
.CurrentLineNumber
)
4081 ## __GetRuleEncapsulationSection() method
4083 # Get encapsulation section for Rule
4085 # @param self The object pointer
4086 # @param Rule for whom section is got
4087 # @retval True Successfully find section statement
4088 # @retval False Not able to find section statement
4090 def __GetRuleEncapsulationSection(self
, Rule
):
4092 if self
.__IsKeyword
( "COMPRESS"):
4094 if self
.__IsKeyword
("PI_STD") or self
.__IsKeyword
("PI_NONE"):
4097 if not self
.__IsToken
("{"):
4098 raise Warning("expected '{'", self
.FileName
, self
.CurrentLineNumber
)
4100 CompressSectionObj
= CompressSection
.CompressSection()
4102 CompressSectionObj
.CompType
= Type
4103 # Recursive sections...
4105 IsEncapsulate
= self
.__GetRuleEncapsulationSection
(CompressSectionObj
)
4106 IsLeaf
= self
.__GetEfiSection
(CompressSectionObj
)
4107 if not IsEncapsulate
and not IsLeaf
:
4110 if not self
.__IsToken
( "}"):
4111 raise Warning("expected '}'", self
.FileName
, self
.CurrentLineNumber
)
4112 Rule
.SectionList
.append(CompressSectionObj
)
4116 elif self
.__IsKeyword
( "GUIDED"):
4118 if self
.__GetNextGuid
():
4119 GuidValue
= self
.__Token
4121 if self
.__IsKeyword
( "$(NAMED_GUID)"):
4122 GuidValue
= self
.__Token
4124 AttribDict
= self
.__GetGuidAttrib
()
4126 if not self
.__IsToken
("{"):
4127 raise Warning("expected '{'", self
.FileName
, self
.CurrentLineNumber
)
4128 GuidSectionObj
= GuidSection
.GuidSection()
4129 GuidSectionObj
.NameGuid
= GuidValue
4130 GuidSectionObj
.SectionType
= "GUIDED"
4131 GuidSectionObj
.ProcessRequired
= AttribDict
["PROCESSING_REQUIRED"]
4132 GuidSectionObj
.AuthStatusValid
= AttribDict
["AUTH_STATUS_VALID"]
4133 GuidSectionObj
.ExtraHeaderSize
= AttribDict
["EXTRA_HEADER_SIZE"]
4137 IsEncapsulate
= self
.__GetRuleEncapsulationSection
(GuidSectionObj
)
4138 IsLeaf
= self
.__GetEfiSection
(GuidSectionObj
)
4139 if not IsEncapsulate
and not IsLeaf
:
4142 if not self
.__IsToken
( "}"):
4143 raise Warning("expected '}'", self
.FileName
, self
.CurrentLineNumber
)
4144 Rule
.SectionList
.append(GuidSectionObj
)
4150 ## __GetVtf() method
4152 # Get VTF section contents and store its data into VTF list of self.Profile
4154 # @param self The object pointer
4155 # @retval True Successfully find a VTF
4156 # @retval False Not able to find a VTF
4160 if not self
.__GetNextToken
():
4163 S
= self
.__Token
.upper()
4164 if S
.startswith("[") and not S
.startswith("[VTF."):
4165 self
.SectionParser(S
)
4170 if not self
.__IsToken
("[VTF.", True):
4171 FileLineTuple
= GetRealFileLine(self
.FileName
, self
.CurrentLineNumber
)
4172 #print 'Parsing String: %s in File %s, At line: %d, Offset Within Line: %d' \
4173 # % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine :], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine)
4174 raise Warning("expected [VTF.]", self
.FileName
, self
.CurrentLineNumber
)
4176 if not self
.__SkipToToken
("."):
4177 raise Warning("expected '.'", self
.FileName
, self
.CurrentLineNumber
)
4179 Arch
= self
.__SkippedChars
.rstrip(".").upper()
4180 if Arch
not in ("IA32", "X64", "IPF", "ARM", "AARCH64"):
4181 raise Warning("Unknown Arch '%s'" % Arch
, self
.FileName
, self
.CurrentLineNumber
)
4183 if not self
.__GetNextWord
():
4184 raise Warning("expected VTF name", self
.FileName
, self
.CurrentLineNumber
)
4185 Name
= self
.__Token
.upper()
4188 VtfObj
.UiName
= Name
4189 VtfObj
.KeyArch
= Arch
4191 if self
.__IsToken
(","):
4192 if not self
.__GetNextWord
():
4193 raise Warning("expected Arch list", self
.FileName
, self
.CurrentLineNumber
)
4194 if self
.__Token
.upper() not in ("IA32", "X64", "IPF", "ARM", "AARCH64"):
4195 raise Warning("Unknown Arch '%s'" % self
.__Token
, self
.FileName
, self
.CurrentLineNumber
)
4196 VtfObj
.ArchList
= self
.__Token
.upper()
4198 if not self
.__IsToken
( "]"):
4199 raise Warning("expected ']'", self
.FileName
, self
.CurrentLineNumber
)
4201 if self
.__IsKeyword
("IA32_RST_BIN"):
4202 if not self
.__IsToken
("="):
4203 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
4205 if not self
.__GetNextToken
():
4206 raise Warning("expected Reset file", self
.FileName
, self
.CurrentLineNumber
)
4208 VtfObj
.ResetBin
= self
.__Token
4209 if VtfObj
.ResetBin
.replace('$(WORKSPACE)', '').find('$') == -1:
4210 #check for file path
4211 ErrorCode
, ErrorInfo
= PathClass(NormPath(VtfObj
.ResetBin
), GenFdsGlobalVariable
.WorkSpaceDir
).Validate()
4213 EdkLogger
.error("GenFds", ErrorCode
, ExtraData
=ErrorInfo
)
4215 while self
.__GetComponentStatement
(VtfObj
):
4218 self
.Profile
.VtfList
.append(VtfObj
)
4221 ## __GetComponentStatement() method
4223 # Get components in VTF
4225 # @param self The object pointer
4226 # @param VtfObj for whom component is got
4227 # @retval True Successfully find a component
4228 # @retval False Not able to find a component
4230 def __GetComponentStatement(self
, VtfObj
):
4232 if not self
.__IsKeyword
("COMP_NAME"):
4235 if not self
.__IsToken
("="):
4236 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
4238 if not self
.__GetNextWord
():
4239 raise Warning("expected Component Name", self
.FileName
, self
.CurrentLineNumber
)
4241 CompStatementObj
= ComponentStatement
.ComponentStatement()
4242 CompStatementObj
.CompName
= self
.__Token
4244 if not self
.__IsKeyword
("COMP_LOC"):
4245 raise Warning("expected COMP_LOC", self
.FileName
, self
.CurrentLineNumber
)
4247 if not self
.__IsToken
("="):
4248 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
4250 CompStatementObj
.CompLoc
= ""
4251 if self
.__GetNextWord
():
4252 CompStatementObj
.CompLoc
= self
.__Token
4253 if self
.__IsToken
('|'):
4254 if not self
.__GetNextWord
():
4255 raise Warning("Expected Region Name", self
.FileName
, self
.CurrentLineNumber
)
4257 if self
.__Token
not in ("F", "N", "S"): #, "H", "L", "PH", "PL"): not support
4258 raise Warning("Unknown location type '%s'" % self
.__Token
, self
.FileName
, self
.CurrentLineNumber
)
4260 CompStatementObj
.FilePos
= self
.__Token
4262 self
.CurrentLineNumber
+= 1
4263 self
.CurrentOffsetWithinLine
= 0
4265 if not self
.__IsKeyword
("COMP_TYPE"):
4266 raise Warning("expected COMP_TYPE", self
.FileName
, self
.CurrentLineNumber
)
4268 if not self
.__IsToken
("="):
4269 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
4271 if not self
.__GetNextToken
():
4272 raise Warning("expected Component type", self
.FileName
, self
.CurrentLineNumber
)
4273 if self
.__Token
not in ("FIT", "PAL_B", "PAL_A", "OEM"):
4274 if not self
.__Token
.startswith("0x") or len(self
.__Token
) < 3 or len(self
.__Token
) > 4 or \
4275 not self
.__HexDigit
(self
.__Token
[2]) or not self
.__HexDigit
(self
.__Token
[-1]):
4276 raise Warning("Unknown location type '%s'" % self
.__Token
, self
.FileName
, self
.CurrentLineNumber
)
4277 CompStatementObj
.CompType
= self
.__Token
4279 if not self
.__IsKeyword
("COMP_VER"):
4280 raise Warning("expected COMP_VER", self
.FileName
, self
.CurrentLineNumber
)
4282 if not self
.__IsToken
("="):
4283 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
4285 if not self
.__GetNextToken
():
4286 raise Warning("expected Component version", self
.FileName
, self
.CurrentLineNumber
)
4288 Pattern
= re
.compile('-$|[0-9a-fA-F]{1,2}\.[0-9a-fA-F]{1,2}$', re
.DOTALL
)
4289 if Pattern
.match(self
.__Token
) == None:
4290 raise Warning("Unknown version format '%s'" % self
.__Token
, self
.FileName
, self
.CurrentLineNumber
)
4291 CompStatementObj
.CompVer
= self
.__Token
4293 if not self
.__IsKeyword
("COMP_CS"):
4294 raise Warning("expected COMP_CS", self
.FileName
, self
.CurrentLineNumber
)
4296 if not self
.__IsToken
("="):
4297 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
4299 if not self
.__GetNextToken
():
4300 raise Warning("expected Component CS", self
.FileName
, self
.CurrentLineNumber
)
4301 if self
.__Token
not in ("1", "0"):
4302 raise Warning("Unknown Component CS '%s'" % self
.__Token
, self
.FileName
, self
.CurrentLineNumber
)
4303 CompStatementObj
.CompCs
= self
.__Token
4306 if not self
.__IsKeyword
("COMP_BIN"):
4307 raise Warning("expected COMP_BIN", self
.FileName
, self
.CurrentLineNumber
)
4309 if not self
.__IsToken
("="):
4310 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
4312 if not self
.__GetNextToken
():
4313 raise Warning("expected Component file", self
.FileName
, self
.CurrentLineNumber
)
4315 CompStatementObj
.CompBin
= self
.__Token
4316 if CompStatementObj
.CompBin
!= '-' and CompStatementObj
.CompBin
.replace('$(WORKSPACE)', '').find('$') == -1:
4317 #check for file path
4318 ErrorCode
, ErrorInfo
= PathClass(NormPath(CompStatementObj
.CompBin
), GenFdsGlobalVariable
.WorkSpaceDir
).Validate()
4320 EdkLogger
.error("GenFds", ErrorCode
, ExtraData
=ErrorInfo
)
4322 if not self
.__IsKeyword
("COMP_SYM"):
4323 raise Warning("expected COMP_SYM", self
.FileName
, self
.CurrentLineNumber
)
4325 if not self
.__IsToken
("="):
4326 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
4328 if not self
.__GetNextToken
():
4329 raise Warning("expected Component symbol file", self
.FileName
, self
.CurrentLineNumber
)
4331 CompStatementObj
.CompSym
= self
.__Token
4332 if CompStatementObj
.CompSym
!= '-' and CompStatementObj
.CompSym
.replace('$(WORKSPACE)', '').find('$') == -1:
4333 #check for file path
4334 ErrorCode
, ErrorInfo
= PathClass(NormPath(CompStatementObj
.CompSym
), GenFdsGlobalVariable
.WorkSpaceDir
).Validate()
4336 EdkLogger
.error("GenFds", ErrorCode
, ExtraData
=ErrorInfo
)
4338 if not self
.__IsKeyword
("COMP_SIZE"):
4339 raise Warning("expected COMP_SIZE", self
.FileName
, self
.CurrentLineNumber
)
4341 if not self
.__IsToken
("="):
4342 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
4344 if self
.__IsToken
("-"):
4345 CompStatementObj
.CompSize
= self
.__Token
4346 elif self
.__GetNextDecimalNumber
():
4347 CompStatementObj
.CompSize
= self
.__Token
4348 elif self
.__GetNextHexNumber
():
4349 CompStatementObj
.CompSize
= self
.__Token
4351 raise Warning("Unknown size '%s'" % self
.__Token
, self
.FileName
, self
.CurrentLineNumber
)
4353 VtfObj
.ComponentStatementList
.append(CompStatementObj
)
4356 ## __GetOptionRom() method
4358 # Get OptionROM section contents and store its data into OptionROM list of self.Profile
4360 # @param self The object pointer
4361 # @retval True Successfully find a OptionROM
4362 # @retval False Not able to find a OptionROM
4364 def __GetOptionRom(self
):
4366 if not self
.__GetNextToken
():
4369 S
= self
.__Token
.upper()
4370 if S
.startswith("[") and not S
.startswith("[OPTIONROM."):
4371 self
.SectionParser(S
)
4376 if not self
.__IsToken
("[OptionRom.", True):
4377 raise Warning("Unknown Keyword '%s'" % self
.__Token
, self
.FileName
, self
.CurrentLineNumber
)
4379 OptRomName
= self
.__GetUiName
()
4381 if not self
.__IsToken
( "]"):
4382 raise Warning("expected ']'", self
.FileName
, self
.CurrentLineNumber
)
4384 OptRomObj
= OptionRom
.OPTIONROM()
4385 OptRomObj
.DriverName
= OptRomName
4386 self
.Profile
.OptRomDict
[OptRomName
] = OptRomObj
4389 isInf
= self
.__GetOptRomInfStatement
(OptRomObj
)
4390 isFile
= self
.__GetOptRomFileStatement
(OptRomObj
)
4391 if not isInf
and not isFile
:
4396 ## __GetOptRomInfStatement() method
4398 # Get INF statements
4400 # @param self The object pointer
4401 # @param Obj for whom inf statement is got
4402 # @retval True Successfully find inf statement
4403 # @retval False Not able to find inf statement
4405 def __GetOptRomInfStatement(self
, Obj
):
4407 if not self
.__IsKeyword
( "INF"):
4410 ffsInf
= OptRomInfStatement
.OptRomInfStatement()
4411 self
.__GetInfOptions
( ffsInf
)
4413 if not self
.__GetNextToken
():
4414 raise Warning("expected INF file path", self
.FileName
, self
.CurrentLineNumber
)
4415 ffsInf
.InfFileName
= self
.__Token
4416 if ffsInf
.InfFileName
.replace('$(WORKSPACE)', '').find('$') == -1:
4417 #check for file path
4418 ErrorCode
, ErrorInfo
= PathClass(NormPath(ffsInf
.InfFileName
), GenFdsGlobalVariable
.WorkSpaceDir
).Validate()
4420 EdkLogger
.error("GenFds", ErrorCode
, ExtraData
=ErrorInfo
)
4422 if not ffsInf
.InfFileName
in self
.Profile
.InfList
:
4423 self
.Profile
.InfList
.append(ffsInf
.InfFileName
)
4424 FileLineTuple
= GetRealFileLine(self
.FileName
, self
.CurrentLineNumber
)
4425 self
.Profile
.InfFileLineList
.append(FileLineTuple
)
4427 if ffsInf
.UseArch
not in self
.Profile
.InfDict
:
4428 self
.Profile
.InfDict
[ffsInf
.UseArch
] = [ffsInf
.InfFileName
]
4430 self
.Profile
.InfDict
[ffsInf
.UseArch
].append(ffsInf
.InfFileName
)
4432 self
.Profile
.InfDict
['ArchTBD'].append(ffsInf
.InfFileName
)
4435 self
.__GetOptRomOverrides
(ffsInf
)
4437 Obj
.FfsList
.append(ffsInf
)
4440 ## __GetOptRomOverrides() method
4442 # Get overrides for OptROM INF & FILE
4444 # @param self The object pointer
4445 # @param FfsInfObj for whom overrides is got
4447 def __GetOptRomOverrides(self
, Obj
):
4448 if self
.__IsToken
('{'):
4449 Overrides
= OptionRom
.OverrideAttribs()
4451 if self
.__IsKeyword
( "PCI_VENDOR_ID"):
4452 if not self
.__IsToken
( "="):
4453 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
4454 if not self
.__GetNextHexNumber
():
4455 raise Warning("expected Hex vendor id", self
.FileName
, self
.CurrentLineNumber
)
4456 Overrides
.PciVendorId
= self
.__Token
4459 if self
.__IsKeyword
( "PCI_CLASS_CODE"):
4460 if not self
.__IsToken
( "="):
4461 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
4462 if not self
.__GetNextHexNumber
():
4463 raise Warning("expected Hex class code", self
.FileName
, self
.CurrentLineNumber
)
4464 Overrides
.PciClassCode
= self
.__Token
4467 if self
.__IsKeyword
( "PCI_DEVICE_ID"):
4468 if not self
.__IsToken
( "="):
4469 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
4470 if not self
.__GetNextHexNumber
():
4471 raise Warning("expected Hex device id", self
.FileName
, self
.CurrentLineNumber
)
4473 Overrides
.PciDeviceId
= self
.__Token
4476 if self
.__IsKeyword
( "PCI_REVISION"):
4477 if not self
.__IsToken
( "="):
4478 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
4479 if not self
.__GetNextHexNumber
():
4480 raise Warning("expected Hex revision", self
.FileName
, self
.CurrentLineNumber
)
4481 Overrides
.PciRevision
= self
.__Token
4484 if self
.__IsKeyword
( "PCI_COMPRESS"):
4485 if not self
.__IsToken
( "="):
4486 raise Warning("expected '='", self
.FileName
, self
.CurrentLineNumber
)
4487 if not self
.__GetNextToken
():
4488 raise Warning("expected TRUE/FALSE for compress", self
.FileName
, self
.CurrentLineNumber
)
4489 Overrides
.NeedCompress
= self
.__Token
.upper() == 'TRUE'
4492 if self
.__IsToken
( "}"):
4495 EdkLogger
.error("FdfParser", FORMAT_INVALID
, File
=self
.FileName
, Line
=self
.CurrentLineNumber
)
4497 Obj
.OverrideAttribs
= Overrides
4499 ## __GetOptRomFileStatement() method
4501 # Get FILE statements
4503 # @param self The object pointer
4504 # @param Obj for whom FILE statement is got
4505 # @retval True Successfully find FILE statement
4506 # @retval False Not able to find FILE statement
4508 def __GetOptRomFileStatement(self
, Obj
):
4510 if not self
.__IsKeyword
( "FILE"):
4513 FfsFileObj
= OptRomFileStatement
.OptRomFileStatement()
4515 if not self
.__IsKeyword
("EFI") and not self
.__IsKeyword
("BIN"):
4516 raise Warning("expected Binary type (EFI/BIN)", self
.FileName
, self
.CurrentLineNumber
)
4517 FfsFileObj
.FileType
= self
.__Token
4519 if not self
.__GetNextToken
():
4520 raise Warning("expected File path", self
.FileName
, self
.CurrentLineNumber
)
4521 FfsFileObj
.FileName
= self
.__Token
4522 if FfsFileObj
.FileName
.replace('$(WORKSPACE)', '').find('$') == -1:
4523 #check for file path
4524 ErrorCode
, ErrorInfo
= PathClass(NormPath(FfsFileObj
.FileName
), GenFdsGlobalVariable
.WorkSpaceDir
).Validate()
4526 EdkLogger
.error("GenFds", ErrorCode
, ExtraData
=ErrorInfo
)
4528 if FfsFileObj
.FileType
== 'EFI':
4529 self
.__GetOptRomOverrides
(FfsFileObj
)
4531 Obj
.FfsList
.append(FfsFileObj
)
4535 ## __GetCapInFd() method
4537 # Get Cap list contained in FD
4539 # @param self The object pointer
4540 # @param FdName FD name
4541 # @retval CapList List of Capsule in FD
4543 def __GetCapInFd (self
, FdName
):
4546 if FdName
.upper() in self
.Profile
.FdDict
.keys():
4547 FdObj
= self
.Profile
.FdDict
[FdName
.upper()]
4548 for elementRegion
in FdObj
.RegionList
:
4549 if elementRegion
.RegionType
== 'CAPSULE':
4550 for elementRegionData
in elementRegion
.RegionDataList
:
4551 if elementRegionData
.endswith(".cap"):
4553 if elementRegionData
!= None and elementRegionData
.upper() not in CapList
:
4554 CapList
.append(elementRegionData
.upper())
4557 ## __GetReferencedFdCapTuple() method
4559 # Get FV and FD list referenced by a capsule image
4561 # @param self The object pointer
4562 # @param CapObj Capsule section to be searched
4563 # @param RefFdList referenced FD by section
4564 # @param RefFvList referenced FV by section
4566 def __GetReferencedFdCapTuple(self
, CapObj
, RefFdList
= [], RefFvList
= []):
4568 for CapsuleDataObj
in CapObj
.CapsuleDataList
:
4569 if hasattr(CapsuleDataObj
, 'FvName') and CapsuleDataObj
.FvName
!= None and CapsuleDataObj
.FvName
.upper() not in RefFvList
:
4570 RefFvList
.append (CapsuleDataObj
.FvName
.upper())
4571 elif hasattr(CapsuleDataObj
, 'FdName') and CapsuleDataObj
.FdName
!= None and CapsuleDataObj
.FdName
.upper() not in RefFdList
:
4572 RefFdList
.append (CapsuleDataObj
.FdName
.upper())
4573 elif CapsuleDataObj
.Ffs
!= None:
4574 if isinstance(CapsuleDataObj
.Ffs
, FfsFileStatement
.FileStatement
):
4575 if CapsuleDataObj
.Ffs
.FvName
!= None and CapsuleDataObj
.Ffs
.FvName
.upper() not in RefFvList
:
4576 RefFvList
.append(CapsuleDataObj
.Ffs
.FvName
.upper())
4577 elif CapsuleDataObj
.Ffs
.FdName
!= None and CapsuleDataObj
.Ffs
.FdName
.upper() not in RefFdList
:
4578 RefFdList
.append(CapsuleDataObj
.Ffs
.FdName
.upper())
4580 self
.__GetReferencedFdFvTupleFromSection
(CapsuleDataObj
.Ffs
, RefFdList
, RefFvList
)
4582 ## __GetFvInFd() method
4584 # Get FV list contained in FD
4586 # @param self The object pointer
4587 # @param FdName FD name
4588 # @retval FvList list of FV in FD
4590 def __GetFvInFd (self
, FdName
):
4593 if FdName
.upper() in self
.Profile
.FdDict
.keys():
4594 FdObj
= self
.Profile
.FdDict
[FdName
.upper()]
4595 for elementRegion
in FdObj
.RegionList
:
4596 if elementRegion
.RegionType
== 'FV':
4597 for elementRegionData
in elementRegion
.RegionDataList
:
4598 if elementRegionData
.endswith(".fv"):
4600 if elementRegionData
!= None and elementRegionData
.upper() not in FvList
:
4601 FvList
.append(elementRegionData
.upper())
4604 ## __GetReferencedFdFvTuple() method
4606 # Get FD and FV list referenced by a FFS file
4608 # @param self The object pointer
4609 # @param FfsFile contains sections to be searched
4610 # @param RefFdList referenced FD by section
4611 # @param RefFvList referenced FV by section
4613 def __GetReferencedFdFvTuple(self
, FvObj
, RefFdList
= [], RefFvList
= []):
4615 for FfsObj
in FvObj
.FfsList
:
4616 if isinstance(FfsObj
, FfsFileStatement
.FileStatement
):
4617 if FfsObj
.FvName
!= None and FfsObj
.FvName
.upper() not in RefFvList
:
4618 RefFvList
.append(FfsObj
.FvName
.upper())
4619 elif FfsObj
.FdName
!= None and FfsObj
.FdName
.upper() not in RefFdList
:
4620 RefFdList
.append(FfsObj
.FdName
.upper())
4622 self
.__GetReferencedFdFvTupleFromSection
(FfsObj
, RefFdList
, RefFvList
)
4624 ## __GetReferencedFdFvTupleFromSection() method
4626 # Get FD and FV list referenced by a FFS section
4628 # @param self The object pointer
4629 # @param FfsFile contains sections to be searched
4630 # @param FdList referenced FD by section
4631 # @param FvList referenced FV by section
4633 def __GetReferencedFdFvTupleFromSection(self
, FfsFile
, FdList
= [], FvList
= []):
4636 SectionStack
.extend(FfsFile
.SectionList
)
4637 while SectionStack
!= []:
4638 SectionObj
= SectionStack
.pop()
4639 if isinstance(SectionObj
, FvImageSection
.FvImageSection
):
4640 if SectionObj
.FvName
!= None and SectionObj
.FvName
.upper() not in FvList
:
4641 FvList
.append(SectionObj
.FvName
.upper())
4642 if SectionObj
.Fv
!= None and SectionObj
.Fv
.UiFvName
!= None and SectionObj
.Fv
.UiFvName
.upper() not in FvList
:
4643 FvList
.append(SectionObj
.Fv
.UiFvName
.upper())
4644 self
.__GetReferencedFdFvTuple
(SectionObj
.Fv
, FdList
, FvList
)
4646 if isinstance(SectionObj
, CompressSection
.CompressSection
) or isinstance(SectionObj
, GuidSection
.GuidSection
):
4647 SectionStack
.extend(SectionObj
.SectionList
)
4649 ## CycleReferenceCheck() method
4651 # Check whether cycle reference exists in FDF
4653 # @param self The object pointer
4654 # @retval True cycle reference exists
4655 # @retval False Not exists cycle reference
4657 def CycleReferenceCheck(self
):
4659 # Check the cycle between FV and FD image
4661 MaxLength
= len (self
.Profile
.FvDict
)
4662 for FvName
in self
.Profile
.FvDict
.keys():
4663 LogStr
= "\nCycle Reference Checking for FV: %s\n" % FvName
4665 RefFvStack
.append(FvName
)
4669 while RefFvStack
!= [] and Index
< MaxLength
:
4671 FvNameFromStack
= RefFvStack
.pop()
4672 if FvNameFromStack
.upper() in self
.Profile
.FvDict
.keys():
4673 FvObj
= self
.Profile
.FvDict
[FvNameFromStack
.upper()]
4679 self
.__GetReferencedFdFvTuple
(FvObj
, RefFdList
, RefFvList
)
4681 for RefFdName
in RefFdList
:
4682 if RefFdName
in FdAnalyzedList
:
4685 LogStr
+= "FV %s contains FD %s\n" % (FvNameFromStack
, RefFdName
)
4686 FvInFdList
= self
.__GetFvInFd
(RefFdName
)
4687 if FvInFdList
!= []:
4688 for FvNameInFd
in FvInFdList
:
4689 LogStr
+= "FD %s contains FV %s\n" % (RefFdName
,FvNameInFd
)
4690 if FvNameInFd
not in RefFvStack
:
4691 RefFvStack
.append(FvNameInFd
)
4693 if FvName
in RefFvStack
or FvNameFromStack
in RefFvStack
:
4694 EdkLogger
.info(LogStr
)
4696 FdAnalyzedList
.append(RefFdName
)
4698 for RefFvName
in RefFvList
:
4699 LogStr
+= "FV %s contains FV %s\n" % (FvNameFromStack
, RefFvName
)
4700 if RefFvName
not in RefFvStack
:
4701 RefFvStack
.append(RefFvName
)
4703 if FvName
in RefFvStack
or FvNameFromStack
in RefFvStack
:
4704 EdkLogger
.info(LogStr
)
4708 # Check the cycle between Capsule and FD image
4710 MaxLength
= len (self
.Profile
.CapsuleDict
)
4711 for CapName
in self
.Profile
.CapsuleDict
.keys():
4713 # Capsule image to be checked.
4715 LogStr
= "\n\n\nCycle Reference Checking for Capsule: %s\n" % CapName
4717 RefCapStack
.append(CapName
)
4722 while RefCapStack
!= [] and Index
< MaxLength
:
4724 CapNameFromStack
= RefCapStack
.pop()
4725 if CapNameFromStack
.upper() in self
.Profile
.CapsuleDict
.keys():
4726 CapObj
= self
.Profile
.CapsuleDict
[CapNameFromStack
.upper()]
4732 self
.__GetReferencedFdCapTuple
(CapObj
, RefFdList
, RefFvList
)
4736 while FvListLength
< len (RefFvList
) or FdListLength
< len (RefFdList
):
4737 for RefFdName
in RefFdList
:
4738 if RefFdName
in FdAnalyzedList
:
4741 LogStr
+= "Capsule %s contains FD %s\n" % (CapNameFromStack
, RefFdName
)
4742 CapInFdList
= self
.__GetCapInFd
(RefFdName
)
4743 if CapInFdList
!= []:
4744 for CapNameInFd
in CapInFdList
:
4745 LogStr
+= "FD %s contains Capsule %s\n" % (RefFdName
,CapNameInFd
)
4746 if CapNameInFd
not in RefCapStack
:
4747 RefCapStack
.append(CapNameInFd
)
4749 if CapName
in RefCapStack
or CapNameFromStack
in RefCapStack
:
4750 EdkLogger
.info(LogStr
)
4753 FvInFdList
= self
.__GetFvInFd
(RefFdName
)
4754 if FvInFdList
!= []:
4755 for FvNameInFd
in FvInFdList
:
4756 LogStr
+= "FD %s contains FV %s\n" % (RefFdName
,FvNameInFd
)
4757 if FvNameInFd
not in RefFvList
:
4758 RefFvList
.append(FvNameInFd
)
4760 FdAnalyzedList
.append(RefFdName
)
4762 # the number of the parsed FV and FD image
4764 FvListLength
= len (RefFvList
)
4765 FdListLength
= len (RefFdList
)
4766 for RefFvName
in RefFvList
:
4767 if RefFvName
in FvAnalyzedList
:
4769 LogStr
+= "Capsule %s contains FV %s\n" % (CapNameFromStack
, RefFvName
)
4770 if RefFvName
.upper() in self
.Profile
.FvDict
.keys():
4771 FvObj
= self
.Profile
.FvDict
[RefFvName
.upper()]
4774 self
.__GetReferencedFdFvTuple
(FvObj
, RefFdList
, RefFvList
)
4775 FvAnalyzedList
.append(RefFvName
)
4779 if __name__
== "__main__":
4782 test_file
= sys
.argv
[1]
4783 except IndexError, v
:
4784 print "Usage: %s filename" % sys
.argv
[0]
4787 parser
= FdfParser(test_file
)
4790 parser
.CycleReferenceCheck()