]> git.proxmox.com Git - mirror_edk2.git/blame_incremental - BaseTools/Source/Python/Workspace/MetaFileParser.py
projects / mirror_edk2.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
MdeModulePkg/NonDiscoverablePciDevice: Remove the redundant check
[mirror_edk2.git] / BaseTools / Source / Python / Workspace / MetaFileParser.py
... / ...
CommitLineData
1## @file\r
2# This file is used to parse meta files\r
3#\r
4# Copyright (c) 2008 - 2018, Intel Corporation. All rights reserved.<BR>\r
5# (C) Copyright 2015-2018 Hewlett Packard Enterprise Development LP<BR>\r
6# This program and the accompanying materials\r
7# are licensed and made available under the terms and conditions of the BSD License\r
8# which accompanies this distribution. The full text of the license may be found at\r
9# http://opensource.org/licenses/bsd-license.php\r
10#\r
11# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
12# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
13#\r
14\r
15##\r
16# Import Modules\r
17#\r
18from __future__ import print_function\r
19from __future__ import absolute_import\r
20import Common.LongFilePathOs as os\r
21import re\r
22import time\r
23import copy\r
24from hashlib import md5\r
25\r
26import Common.EdkLogger as EdkLogger\r
27import Common.GlobalData as GlobalData\r
28\r
29from CommonDataClass.DataClass import *\r
30from Common.DataType import *\r
31from Common.StringUtils import *\r
32from Common.Misc import GuidStructureStringToGuidString, CheckPcdDatum, PathClass, AnalyzePcdData, AnalyzeDscPcd, AnalyzePcdExpression, ParseFieldValue, StructPattern\r
33from Common.Expression import *\r
34from CommonDataClass.Exceptions import *\r
35from Common.LongFilePathSupport import OpenLongFilePath as open\r
36from collections import defaultdict\r
37from .MetaFileTable import MetaFileStorage\r
38from .MetaFileCommentParser import CheckInfComment\r
39\r
40## RegEx for finding file versions\r
41hexVersionPattern = re.compile(r'0[xX][\da-f-A-F]{5,8}')\r
42decVersionPattern = re.compile(r'\d+\.\d+')\r
43CODEPattern = re.compile(r"{CODE\([a-fA-F0-9Xx\{\},\s]*\)}")\r
44\r
45## A decorator used to parse macro definition\r
46def ParseMacro(Parser):\r
47 def MacroParser(self):\r
48 Match = gMacroDefPattern.match(self._CurrentLine)\r
49 if not Match:\r
50 # Not 'DEFINE/EDK_GLOBAL' statement, call decorated method\r
51 Parser(self)\r
52 return\r
53\r
54 TokenList = GetSplitValueList(self._CurrentLine[Match.end(1):], TAB_EQUAL_SPLIT, 1)\r
55 # Syntax check\r
56 if not TokenList[0]:\r
57 EdkLogger.error('Parser', FORMAT_INVALID, "No macro name given",\r
58 ExtraData=self._CurrentLine, File=self.MetaFile, Line=self._LineIndex + 1)\r
59 if len(TokenList) < 2:\r
60 TokenList.append('')\r
61\r
62 Type = Match.group(1)\r
63 Name, Value = TokenList\r
64 # Global macros can be only defined via environment variable\r
65 if Name in GlobalData.gGlobalDefines:\r
66 EdkLogger.error('Parser', FORMAT_INVALID, "%s can only be defined via environment variable" % Name,\r
67 ExtraData=self._CurrentLine, File=self.MetaFile, Line=self._LineIndex + 1)\r
68 # Only upper case letters, digit and '_' are allowed\r
69 if not gMacroNamePattern.match(Name):\r
70 EdkLogger.error('Parser', FORMAT_INVALID, "The macro name must be in the pattern [A-Z][A-Z0-9_]*",\r
71 ExtraData=self._CurrentLine, File=self.MetaFile, Line=self._LineIndex + 1)\r
72\r
73 Value = ReplaceMacro(Value, self._Macros)\r
74 if Type in self.DataType:\r
75 self._ItemType = self.DataType[Type]\r
76 else:\r
77 self._ItemType = MODEL_META_DATA_DEFINE\r
78 # DEFINE defined macros\r
79 if Type == TAB_DSC_DEFINES_DEFINE:\r
80 #\r
81 # First judge whether this DEFINE is in conditional directive statements or not.\r
82 #\r
83 if isinstance(self, DscParser) and self._InDirective > -1:\r
84 pass\r
85 else:\r
86 if isinstance(self, DecParser):\r
87 if MODEL_META_DATA_HEADER in self._SectionType:\r
88 self._FileLocalMacros[Name] = Value\r
89 else:\r
90 self._ConstructSectionMacroDict(Name, Value)\r
91 elif self._SectionType == MODEL_META_DATA_HEADER:\r
92 self._FileLocalMacros[Name] = Value\r
93 else:\r
94 self._ConstructSectionMacroDict(Name, Value)\r
95\r
96 # EDK_GLOBAL defined macros\r
97 elif not isinstance(self, DscParser):\r
98 EdkLogger.error('Parser', FORMAT_INVALID, "EDK_GLOBAL can only be used in .dsc file",\r
99 ExtraData=self._CurrentLine, File=self.MetaFile, Line=self._LineIndex + 1)\r
100 elif self._SectionType != MODEL_META_DATA_HEADER:\r
101 EdkLogger.error('Parser', FORMAT_INVALID, "EDK_GLOBAL can only be used under [Defines] section",\r
102 ExtraData=self._CurrentLine, File=self.MetaFile, Line=self._LineIndex + 1)\r
103 elif (Name in self._FileLocalMacros) and (self._FileLocalMacros[Name] != Value):\r
104 EdkLogger.error('Parser', FORMAT_INVALID, "EDK_GLOBAL defined a macro with the same name and different value as one defined by 'DEFINE'",\r
105 ExtraData=self._CurrentLine, File=self.MetaFile, Line=self._LineIndex + 1)\r
106\r
107 self._ValueList = [Type, Name, Value]\r
108\r
109 return MacroParser\r
110\r
111## Base class of parser\r
112#\r
113# This class is used for derivation purpose. The specific parser for one kind\r
114# type file must derive this class and implement some public interfaces.\r
115#\r
116# @param FilePath The path of platform description file\r
117# @param FileType The raw data of DSC file\r
118# @param Table Database used to retrieve module/package information\r
119# @param Macros Macros used for replacement in file\r
120# @param Owner Owner ID (for sub-section parsing)\r
121# @param From ID from which the data comes (for !INCLUDE directive)\r
122#\r
123class MetaFileParser(object):\r
124 # data type (file content) for specific file type\r
125 DataType = {}\r
126\r
127 # Parser objects used to implement singleton\r
128 MetaFiles = {}\r
129\r
130 ## Factory method\r
131 #\r
132 # One file, one parser object. This factory method makes sure that there's\r
133 # only one object constructed for one meta file.\r
134 #\r
135 # @param Class class object of real AutoGen class\r
136 # (InfParser, DecParser or DscParser)\r
137 # @param FilePath The path of meta file\r
138 # @param *args The specific class related parameters\r
139 # @param **kwargs The specific class related dict parameters\r
140 #\r
141 def __new__(Class, FilePath, *args, **kwargs):\r
142 if FilePath in Class.MetaFiles:\r
143 return Class.MetaFiles[FilePath]\r
144 else:\r
145 ParserObject = super(MetaFileParser, Class).__new__(Class)\r
146 Class.MetaFiles[FilePath] = ParserObject\r
147 return ParserObject\r
148\r
149 ## Constructor of MetaFileParser\r
150 #\r
151 # Initialize object of MetaFileParser\r
152 #\r
153 # @param FilePath The path of platform description file\r
154 # @param FileType The raw data of DSC file\r
155 # @param Arch Default Arch value for filtering sections\r
156 # @param Table Database used to retrieve module/package information\r
157 # @param Owner Owner ID (for sub-section parsing)\r
158 # @param From ID from which the data comes (for !INCLUDE directive)\r
159 #\r
160 def __init__(self, FilePath, FileType, Arch, Table, Owner= -1, From= -1):\r
161 self._Table = Table\r
162 self._RawTable = Table\r
163 self._Arch = Arch\r
164 self._FileType = FileType\r
165 self.MetaFile = FilePath\r
166 self._FileDir = self.MetaFile.Dir\r
167 self._Defines = {}\r
168 self._FileLocalMacros = {}\r
169 self._SectionsMacroDict = defaultdict(dict)\r
170\r
171 # for recursive parsing\r
172 self._Owner = [Owner]\r
173 self._From = From\r
174\r
175 # parsr status for parsing\r
176 self._ValueList = ['', '', '', '', '']\r
177 self._Scope = []\r
178 self._LineIndex = 0\r
179 self._CurrentLine = ''\r
180 self._SectionType = MODEL_UNKNOWN\r
181 self._SectionName = ''\r
182 self._InSubsection = False\r
183 self._SubsectionType = MODEL_UNKNOWN\r
184 self._SubsectionName = ''\r
185 self._ItemType = MODEL_UNKNOWN\r
186 self._LastItem = -1\r
187 self._Enabled = 0\r
188 self._Finished = False\r
189 self._PostProcessed = False\r
190 # Different version of meta-file has different way to parse.\r
191 self._Version = 0\r
192 self._GuidDict = {} # for Parser PCD value {GUID(gTokeSpaceGuidName)}\r
193\r
194 ## Store the parsed data in table\r
195 def _Store(self, *Args):\r
196 return self._Table.Insert(*Args)\r
197\r
198 ## Virtual method for starting parse\r
199 def Start(self):\r
200 raise NotImplementedError\r
201\r
202 ## Notify a post-process is needed\r
203 def DoPostProcess(self):\r
204 self._PostProcessed = False\r
205\r
206 ## Set parsing complete flag in both class and table\r
207 def _Done(self):\r
208 self._Finished = True\r
209 self._Table.SetEndFlag()\r
210\r
211 def _PostProcess(self):\r
212 self._PostProcessed = True\r
213\r
214 ## Get the parse complete flag\r
215 @property\r
216 def Finished(self):\r
217 return self._Finished\r
218\r
219 ## Set the complete flag\r
220 @Finished.setter\r
221 def Finished(self, Value):\r
222 self._Finished = Value\r
223\r
224 ## Remove records that do not match given Filter Arch\r
225 def _FilterRecordList(self, RecordList, FilterArch):\r
226 NewRecordList = []\r
227 for Record in RecordList:\r
228 Arch = Record[3]\r
229 if Arch == TAB_ARCH_COMMON or Arch == FilterArch:\r
230 NewRecordList.append(Record)\r
231 return NewRecordList\r
232\r
233 ## Use [] style to query data in table, just for readability\r
234 #\r
235 # DataInfo = [data_type, scope1(arch), scope2(platform/moduletype)]\r
236 #\r
237 def __getitem__(self, DataInfo):\r
238 if not isinstance(DataInfo, type(())):\r
239 DataInfo = (DataInfo,)\r
240\r
241 # Parse the file first, if necessary\r
242 self.StartParse()\r
243\r
244 # No specific ARCH or Platform given, use raw data\r
245 if self._RawTable and (len(DataInfo) == 1 or DataInfo[1] is None):\r
246 return self._FilterRecordList(self._RawTable.Query(*DataInfo), self._Arch)\r
247\r
248 # Do post-process if necessary\r
249 if not self._PostProcessed:\r
250 self._PostProcess()\r
251\r
252 return self._FilterRecordList(self._Table.Query(*DataInfo), DataInfo[1])\r
253\r
254 def StartParse(self):\r
255 if not self._Finished:\r
256 if self._RawTable.IsIntegrity():\r
257 self._Finished = True\r
258 else:\r
259 self._Table = self._RawTable\r
260 self._PostProcessed = False\r
261 self.Start()\r
262 ## Data parser for the common format in different type of file\r
263 #\r
264 # The common format in the meatfile is like\r
265 #\r
266 # xxx1 | xxx2 | xxx3\r
267 #\r
268 @ParseMacro\r
269 def _CommonParser(self):\r
270 TokenList = GetSplitValueList(self._CurrentLine, TAB_VALUE_SPLIT)\r
271 self._ValueList[0:len(TokenList)] = TokenList\r
272\r
273 ## Data parser for the format in which there's path\r
274 #\r
275 # Only path can have macro used. So we need to replace them before use.\r
276 #\r
277 @ParseMacro\r
278 def _PathParser(self):\r
279 TokenList = GetSplitValueList(self._CurrentLine, TAB_VALUE_SPLIT)\r
280 self._ValueList[0:len(TokenList)] = TokenList\r
281 # Don't do macro replacement for dsc file at this point\r
282 if not isinstance(self, DscParser):\r
283 Macros = self._Macros\r
284 self._ValueList = [ReplaceMacro(Value, Macros) for Value in self._ValueList]\r
285\r
286 ## Skip unsupported data\r
287 def _Skip(self):\r
288 EdkLogger.warn("Parser", "Unrecognized content", File=self.MetaFile,\r
289 Line=self._LineIndex + 1, ExtraData=self._CurrentLine);\r
290 self._ValueList[0:1] = [self._CurrentLine]\r
291\r
292 ## Skip unsupported data for UserExtension Section\r
293 def _SkipUserExtension(self):\r
294 self._ValueList[0:1] = [self._CurrentLine]\r
295\r
296 ## Section header parser\r
297 #\r
298 # The section header is always in following format:\r
299 #\r
300 # [section_name.arch<.platform|module_type>]\r
301 #\r
302 def _SectionHeaderParser(self):\r
303 self._Scope = []\r
304 self._SectionName = ''\r
305 ArchList = set()\r
306 for Item in GetSplitValueList(self._CurrentLine[1:-1], TAB_COMMA_SPLIT):\r
307 if Item == '':\r
308 continue\r
309 ItemList = GetSplitValueList(Item, TAB_SPLIT, 3)\r
310 # different section should not mix in one section\r
311 if self._SectionName != '' and self._SectionName != ItemList[0].upper():\r
312 EdkLogger.error('Parser', FORMAT_INVALID, "Different section names in the same section",\r
313 File=self.MetaFile, Line=self._LineIndex + 1, ExtraData=self._CurrentLine)\r
314 self._SectionName = ItemList[0].upper()\r
315 if self._SectionName in self.DataType:\r
316 self._SectionType = self.DataType[self._SectionName]\r
317 # Check if the section name is valid\r
318 if self._SectionName not in SECTIONS_HAVE_ITEM_AFTER_ARCH_SET and len(ItemList) > 3:\r
319 EdkLogger.error("Parser", FORMAT_UNKNOWN_ERROR, "%s is not a valid section name" % Item,\r
320 self.MetaFile, self._LineIndex + 1, self._CurrentLine)\r
321 elif self._Version >= 0x00010005:\r
322 EdkLogger.error("Parser", FORMAT_UNKNOWN_ERROR, "%s is not a valid section name" % Item,\r
323 self.MetaFile, self._LineIndex + 1, self._CurrentLine)\r
324 else:\r
325 self._SectionType = MODEL_UNKNOWN\r
326\r
327 # S1 is always Arch\r
328 if len(ItemList) > 1:\r
329 S1 = ItemList[1].upper()\r
330 else:\r
331 S1 = TAB_ARCH_COMMON\r
332 ArchList.add(S1)\r
333\r
334 # S2 may be Platform or ModuleType\r
335 if len(ItemList) > 2:\r
336 if self._SectionName.upper() in SECTIONS_HAVE_ITEM_PCD_SET:\r
337 S2 = ItemList[2]\r
338 else:\r
339 S2 = ItemList[2].upper()\r
340 else:\r
341 S2 = TAB_COMMON\r
342 if len(ItemList) > 3:\r
343 S3 = ItemList[3]\r
344 else:\r
345 S3 = TAB_COMMON\r
346 self._Scope.append([S1, S2, S3])\r
347\r
348 # 'COMMON' must not be used with specific ARCHs at the same section\r
349 if TAB_ARCH_COMMON in ArchList and len(ArchList) > 1:\r
350 EdkLogger.error('Parser', FORMAT_INVALID, "'common' ARCH must not be used with specific ARCHs",\r
351 File=self.MetaFile, Line=self._LineIndex + 1, ExtraData=self._CurrentLine)\r
352 # If the section information is needed later, it should be stored in database\r
353 self._ValueList[0] = self._SectionName\r
354\r
355 ## [defines] section parser\r
356 @ParseMacro\r
357 def _DefineParser(self):\r
358 TokenList = GetSplitValueList(self._CurrentLine, TAB_EQUAL_SPLIT, 1)\r
359 self._ValueList[1:len(TokenList)] = TokenList\r
360 if not self._ValueList[1]:\r
361 EdkLogger.error('Parser', FORMAT_INVALID, "No name specified",\r
362 ExtraData=self._CurrentLine, File=self.MetaFile, Line=self._LineIndex + 1)\r
363 if not self._ValueList[2]:\r
364 EdkLogger.error('Parser', FORMAT_INVALID, "No value specified",\r
365 ExtraData=self._CurrentLine, File=self.MetaFile, Line=self._LineIndex + 1)\r
366\r
367 self._ValueList = [ReplaceMacro(Value, self._Macros) for Value in self._ValueList]\r
368 Name, Value = self._ValueList[1], self._ValueList[2]\r
369 MacroUsed = GlobalData.gMacroRefPattern.findall(Value)\r
370 if len(MacroUsed) != 0:\r
371 for Macro in MacroUsed:\r
372 if Macro in GlobalData.gGlobalDefines:\r
373 EdkLogger.error("Parser", FORMAT_INVALID, "Global macro %s is not permitted." % (Macro), ExtraData=self._CurrentLine, File=self.MetaFile, Line=self._LineIndex + 1)\r
374 else:\r
375 EdkLogger.error("Parser", FORMAT_INVALID, "%s not defined" % (Macro), ExtraData=self._CurrentLine, File=self.MetaFile, Line=self._LineIndex + 1)\r
376 # Sometimes, we need to make differences between EDK and EDK2 modules\r
377 if Name == 'INF_VERSION':\r
378 if hexVersionPattern.match(Value):\r
379 self._Version = int(Value, 0)\r
380 elif decVersionPattern.match(Value):\r
381 ValueList = Value.split('.')\r
382 Major = int(ValueList[0], 0)\r
383 Minor = int(ValueList[1], 0)\r
384 if Major > 0xffff or Minor > 0xffff:\r
385 EdkLogger.error('Parser', FORMAT_INVALID, "Invalid version number",\r
386 ExtraData=self._CurrentLine, File=self.MetaFile, Line=self._LineIndex + 1)\r
387 self._Version = int('0x{0:04x}{1:04x}'.format(Major, Minor), 0)\r
388 else:\r
389 EdkLogger.error('Parser', FORMAT_INVALID, "Invalid version number",\r
390 ExtraData=self._CurrentLine, File=self.MetaFile, Line=self._LineIndex + 1)\r
391\r
392 if isinstance(self, InfParser) and self._Version < 0x00010005:\r
393 # EDK module allows using defines as macros\r
394 self._FileLocalMacros[Name] = Value\r
395 self._Defines[Name] = Value\r
396\r
397 ## [BuildOptions] section parser\r
398 @ParseMacro\r
399 def _BuildOptionParser(self):\r
400 self._CurrentLine = CleanString(self._CurrentLine, BuildOption=True)\r
401 TokenList = GetSplitValueList(self._CurrentLine, TAB_EQUAL_SPLIT, 1)\r
402 TokenList2 = GetSplitValueList(TokenList[0], ':', 1)\r
403 if len(TokenList2) == 2:\r
404 self._ValueList[0] = TokenList2[0] # toolchain family\r
405 self._ValueList[1] = TokenList2[1] # keys\r
406 else:\r
407 self._ValueList[1] = TokenList[0]\r
408 if len(TokenList) == 2 and not isinstance(self, DscParser): # value\r
409 self._ValueList[2] = ReplaceMacro(TokenList[1], self._Macros)\r
410\r
411 if self._ValueList[1].count('_') != 4:\r
412 EdkLogger.error(\r
413 'Parser',\r
414 FORMAT_INVALID,\r
415 "'%s' must be in format of <TARGET>_<TOOLCHAIN>_<ARCH>_<TOOL>_FLAGS" % self._ValueList[1],\r
416 ExtraData=self._CurrentLine,\r
417 File=self.MetaFile,\r
418 Line=self._LineIndex + 1\r
419 )\r
420 def GetValidExpression(self, TokenSpaceGuid, PcdCName):\r
421 return self._Table.GetValidExpression(TokenSpaceGuid, PcdCName)\r
422\r
423 @property\r
424 def _Macros(self):\r
425 Macros = {}\r
426 Macros.update(self._FileLocalMacros)\r
427 Macros.update(self._GetApplicableSectionMacro())\r
428 return Macros\r
429\r
430 ## Construct section Macro dict\r
431 def _ConstructSectionMacroDict(self, Name, Value):\r
432 ScopeKey = [(Scope[0], Scope[1], Scope[2]) for Scope in self._Scope]\r
433 ScopeKey = tuple(ScopeKey)\r
434 #\r
435 # DecParser SectionType is a list, will contain more than one item only in Pcd Section\r
436 # As Pcd section macro usage is not alllowed, so here it is safe\r
437 #\r
438 if isinstance(self, DecParser):\r
439 SectionDictKey = self._SectionType[0], ScopeKey\r
440 else:\r
441 SectionDictKey = self._SectionType, ScopeKey\r
442\r
443 self._SectionsMacroDict[SectionDictKey][Name] = Value\r
444\r
445 ## Get section Macros that are applicable to current line, which may come from other sections\r
446 ## that share the same name while scope is wider\r
447 def _GetApplicableSectionMacro(self):\r
448 Macros = {}\r
449\r
450 ComComMacroDict = {}\r
451 ComSpeMacroDict = {}\r
452 SpeSpeMacroDict = {}\r
453\r
454 ActiveSectionType = self._SectionType\r
455 if isinstance(self, DecParser):\r
456 ActiveSectionType = self._SectionType[0]\r
457\r
458 for (SectionType, Scope) in self._SectionsMacroDict:\r
459 if SectionType != ActiveSectionType:\r
460 continue\r
461\r
462 for ActiveScope in self._Scope:\r
463 Scope0, Scope1, Scope2= ActiveScope[0], ActiveScope[1], ActiveScope[2]\r
464 if(Scope0, Scope1, Scope2) not in Scope:\r
465 break\r
466 else:\r
467 SpeSpeMacroDict.update(self._SectionsMacroDict[(SectionType, Scope)])\r
468\r
469 for ActiveScope in self._Scope:\r
470 Scope0, Scope1, Scope2 = ActiveScope[0], ActiveScope[1], ActiveScope[2]\r
471 if(Scope0, Scope1, Scope2) not in Scope and (Scope0, TAB_COMMON, TAB_COMMON) not in Scope and (TAB_COMMON, Scope1, TAB_COMMON) not in Scope:\r
472 break\r
473 else:\r
474 ComSpeMacroDict.update(self._SectionsMacroDict[(SectionType, Scope)])\r
475\r
476 if (TAB_COMMON, TAB_COMMON, TAB_COMMON) in Scope:\r
477 ComComMacroDict.update(self._SectionsMacroDict[(SectionType, Scope)])\r
478\r
479 Macros.update(ComComMacroDict)\r
480 Macros.update(ComSpeMacroDict)\r
481 Macros.update(SpeSpeMacroDict)\r
482\r
483 return Macros\r
484\r
485 _SectionParser = {}\r
486\r
487## INF file parser class\r
488#\r
489# @param FilePath The path of platform description file\r
490# @param FileType The raw data of DSC file\r
491# @param Table Database used to retrieve module/package information\r
492# @param Macros Macros used for replacement in file\r
493#\r
494class InfParser(MetaFileParser):\r
495 # INF file supported data types (one type per section)\r
496 DataType = {\r
497 TAB_UNKNOWN.upper() : MODEL_UNKNOWN,\r
498 TAB_INF_DEFINES.upper() : MODEL_META_DATA_HEADER,\r
499 TAB_DSC_DEFINES_DEFINE : MODEL_META_DATA_DEFINE,\r
500 TAB_BUILD_OPTIONS.upper() : MODEL_META_DATA_BUILD_OPTION,\r
501 TAB_INCLUDES.upper() : MODEL_EFI_INCLUDE,\r
502 TAB_LIBRARIES.upper() : MODEL_EFI_LIBRARY_INSTANCE,\r
503 TAB_LIBRARY_CLASSES.upper() : MODEL_EFI_LIBRARY_CLASS,\r
504 TAB_PACKAGES.upper() : MODEL_META_DATA_PACKAGE,\r
505 TAB_NMAKE.upper() : MODEL_META_DATA_NMAKE,\r
506 TAB_INF_FIXED_PCD.upper() : MODEL_PCD_FIXED_AT_BUILD,\r
507 TAB_INF_PATCH_PCD.upper() : MODEL_PCD_PATCHABLE_IN_MODULE,\r
508 TAB_INF_FEATURE_PCD.upper() : MODEL_PCD_FEATURE_FLAG,\r
509 TAB_INF_PCD_EX.upper() : MODEL_PCD_DYNAMIC_EX,\r
510 TAB_INF_PCD.upper() : MODEL_PCD_DYNAMIC,\r
511 TAB_SOURCES.upper() : MODEL_EFI_SOURCE_FILE,\r
512 TAB_GUIDS.upper() : MODEL_EFI_GUID,\r
513 TAB_PROTOCOLS.upper() : MODEL_EFI_PROTOCOL,\r
514 TAB_PPIS.upper() : MODEL_EFI_PPI,\r
515 TAB_DEPEX.upper() : MODEL_EFI_DEPEX,\r
516 TAB_BINARIES.upper() : MODEL_EFI_BINARY_FILE,\r
517 TAB_USER_EXTENSIONS.upper() : MODEL_META_DATA_USER_EXTENSION\r
518 }\r
519\r
520 ## Constructor of InfParser\r
521 #\r
522 # Initialize object of InfParser\r
523 #\r
524 # @param FilePath The path of module description file\r
525 # @param FileType The raw data of DSC file\r
526 # @param Arch Default Arch value for filtering sections\r
527 # @param Table Database used to retrieve module/package information\r
528 #\r
529 def __init__(self, FilePath, FileType, Arch, Table):\r
530 # prevent re-initialization\r
531 if hasattr(self, "_Table"):\r
532 return\r
533 MetaFileParser.__init__(self, FilePath, FileType, Arch, Table)\r
534 self.PcdsDict = {}\r
535\r
536 ## Parser starter\r
537 def Start(self):\r
538 NmakeLine = ''\r
539 Content = ''\r
540 try:\r
541 Content = open(str(self.MetaFile), 'r').readlines()\r
542 except:\r
543 EdkLogger.error("Parser", FILE_READ_FAILURE, ExtraData=self.MetaFile)\r
544\r
545 # parse the file line by line\r
546 IsFindBlockComment = False\r
547 GetHeaderComment = False\r
548 TailComments = []\r
549 SectionComments = []\r
550 Comments = []\r
551\r
552 for Index in range(0, len(Content)):\r
553 # skip empty, commented, block commented lines\r
554 Line, Comment = CleanString2(Content[Index], AllowCppStyleComment=True)\r
555 NextLine = ''\r
556 if Index + 1 < len(Content):\r
557 NextLine, NextComment = CleanString2(Content[Index + 1])\r
558 if Line == '':\r
559 if Comment:\r
560 Comments.append((Comment, Index + 1))\r
561 elif GetHeaderComment:\r
562 SectionComments.extend(Comments)\r
563 Comments = []\r
564 continue\r
565 if Line.find(DataType.TAB_COMMENT_EDK_START) > -1:\r
566 IsFindBlockComment = True\r
567 continue\r
568 if Line.find(DataType.TAB_COMMENT_EDK_END) > -1:\r
569 IsFindBlockComment = False\r
570 continue\r
571 if IsFindBlockComment:\r
572 continue\r
573\r
574 self._LineIndex = Index\r
575 self._CurrentLine = Line\r
576\r
577 # section header\r
578 if Line[0] == TAB_SECTION_START and Line[-1] == TAB_SECTION_END:\r
579 if not GetHeaderComment:\r
580 for Cmt, LNo in Comments:\r
581 self._Store(MODEL_META_DATA_HEADER_COMMENT, Cmt, '', '', TAB_COMMON,\r
582 TAB_COMMON, self._Owner[-1], LNo, -1, LNo, -1, 0)\r
583 GetHeaderComment = True\r
584 else:\r
585 TailComments.extend(SectionComments + Comments)\r
586 Comments = []\r
587 self._SectionHeaderParser()\r
588 # Check invalid sections\r
589 if self._Version < 0x00010005:\r
590 if self._SectionType in [MODEL_META_DATA_BUILD_OPTION,\r
591 MODEL_EFI_LIBRARY_CLASS,\r
592 MODEL_META_DATA_PACKAGE,\r
593 MODEL_PCD_FIXED_AT_BUILD,\r
594 MODEL_PCD_PATCHABLE_IN_MODULE,\r
595 MODEL_PCD_FEATURE_FLAG,\r
596 MODEL_PCD_DYNAMIC_EX,\r
597 MODEL_PCD_DYNAMIC,\r
598 MODEL_EFI_GUID,\r
599 MODEL_EFI_PROTOCOL,\r
600 MODEL_EFI_PPI,\r
601 MODEL_META_DATA_USER_EXTENSION]:\r
602 EdkLogger.error('Parser', FORMAT_INVALID,\r
603 "Section [%s] is not allowed in inf file without version" % (self._SectionName),\r
604 ExtraData=self._CurrentLine, File=self.MetaFile, Line=self._LineIndex + 1)\r
605 elif self._SectionType in [MODEL_EFI_INCLUDE,\r
606 MODEL_EFI_LIBRARY_INSTANCE,\r
607 MODEL_META_DATA_NMAKE]:\r
608 EdkLogger.error('Parser', FORMAT_INVALID,\r
609 "Section [%s] is not allowed in inf file with version 0x%08x" % (self._SectionName, self._Version),\r
610 ExtraData=self._CurrentLine, File=self.MetaFile, Line=self._LineIndex + 1)\r
611 continue\r
612 # merge two lines specified by '\' in section NMAKE\r
613 elif self._SectionType == MODEL_META_DATA_NMAKE:\r
614 if Line[-1] == '\\':\r
615 if NextLine == '':\r
616 self._CurrentLine = NmakeLine + Line[0:-1]\r
617 NmakeLine = ''\r
618 else:\r
619 if NextLine[0] == TAB_SECTION_START and NextLine[-1] == TAB_SECTION_END:\r
620 self._CurrentLine = NmakeLine + Line[0:-1]\r
621 NmakeLine = ''\r
622 else:\r
623 NmakeLine = NmakeLine + ' ' + Line[0:-1]\r
624 continue\r
625 else:\r
626 self._CurrentLine = NmakeLine + Line\r
627 NmakeLine = ''\r
628\r
629 # section content\r
630 self._ValueList = ['', '', '']\r
631 # parse current line, result will be put in self._ValueList\r
632 self._SectionParser[self._SectionType](self)\r
633 if self._ValueList is None or self._ItemType == MODEL_META_DATA_DEFINE:\r
634 self._ItemType = -1\r
635 Comments = []\r
636 continue\r
637 if Comment:\r
638 Comments.append((Comment, Index + 1))\r
639 if GlobalData.gOptions and GlobalData.gOptions.CheckUsage:\r
640 CheckInfComment(self._SectionType, Comments, str(self.MetaFile), Index + 1, self._ValueList)\r
641 #\r
642 # Model, Value1, Value2, Value3, Arch, Platform, BelongsToItem=-1,\r
643 # LineBegin=-1, ColumnBegin=-1, LineEnd=-1, ColumnEnd=-1, Enabled=-1\r
644 #\r
645 for Arch, Platform, _ in self._Scope:\r
646 LastItem = self._Store(self._SectionType,\r
647 self._ValueList[0],\r
648 self._ValueList[1],\r
649 self._ValueList[2],\r
650 Arch,\r
651 Platform,\r
652 self._Owner[-1],\r
653 self._LineIndex + 1,\r
654 - 1,\r
655 self._LineIndex + 1,\r
656 - 1,\r
657 0\r
658 )\r
659 for Comment, LineNo in Comments:\r
660 self._Store(MODEL_META_DATA_COMMENT, Comment, '', '', Arch, Platform,\r
661 LastItem, LineNo, -1, LineNo, -1, 0)\r
662 Comments = []\r
663 SectionComments = []\r
664 TailComments.extend(SectionComments + Comments)\r
665 if IsFindBlockComment:\r
666 EdkLogger.error("Parser", FORMAT_INVALID, "Open block comments (starting with /*) are expected to end with */",\r
667 File=self.MetaFile)\r
668\r
669 # If there are tail comments in INF file, save to database whatever the comments are\r
670 for Comment in TailComments:\r
671 self._Store(MODEL_META_DATA_TAIL_COMMENT, Comment[0], '', '', TAB_COMMON,\r
672 TAB_COMMON, self._Owner[-1], -1, -1, -1, -1, 0)\r
673 self._Done()\r
674\r
675 ## Data parser for the format in which there's path\r
676 #\r
677 # Only path can have macro used. So we need to replace them before use.\r
678 #\r
679 def _IncludeParser(self):\r
680 TokenList = GetSplitValueList(self._CurrentLine, TAB_VALUE_SPLIT)\r
681 self._ValueList[0:len(TokenList)] = TokenList\r
682 Macros = self._Macros\r
683 if Macros:\r
684 for Index in range(0, len(self._ValueList)):\r
685 Value = self._ValueList[Index]\r
686 if not Value:\r
687 continue\r
688\r
689 if Value.upper().find('$(EFI_SOURCE)\Edk'.upper()) > -1 or Value.upper().find('$(EFI_SOURCE)/Edk'.upper()) > -1:\r
690 Value = '$(EDK_SOURCE)' + Value[17:]\r
691 if Value.find('$(EFI_SOURCE)') > -1 or Value.find('$(EDK_SOURCE)') > -1:\r
692 pass\r
693 elif Value.startswith('.'):\r
694 pass\r
695 elif Value.startswith('$('):\r
696 pass\r
697 else:\r
698 Value = '$(EFI_SOURCE)/' + Value\r
699\r
700 self._ValueList[Index] = ReplaceMacro(Value, Macros)\r
701\r
702 ## Parse [Sources] section\r
703 #\r
704 # Only path can have macro used. So we need to replace them before use.\r
705 #\r
706 @ParseMacro\r
707 def _SourceFileParser(self):\r
708 TokenList = GetSplitValueList(self._CurrentLine, TAB_VALUE_SPLIT)\r
709 self._ValueList[0:len(TokenList)] = TokenList\r
710 Macros = self._Macros\r
711 # For Acpi tables, remove macro like ' TABLE_NAME=Sata1'\r
712 if 'COMPONENT_TYPE' in Macros:\r
713 if self._Defines['COMPONENT_TYPE'].upper() == 'ACPITABLE':\r
714 self._ValueList[0] = GetSplitValueList(self._ValueList[0], ' ', 1)[0]\r
715 if self._Defines['BASE_NAME'] == 'Microcode':\r
716 pass\r
717 self._ValueList = [ReplaceMacro(Value, Macros) for Value in self._ValueList]\r
718\r
719 ## Parse [Binaries] section\r
720 #\r
721 # Only path can have macro used. So we need to replace them before use.\r
722 #\r
723 @ParseMacro\r
724 def _BinaryFileParser(self):\r
725 TokenList = GetSplitValueList(self._CurrentLine, TAB_VALUE_SPLIT, 2)\r
726 if len(TokenList) < 2:\r
727 EdkLogger.error('Parser', FORMAT_INVALID, "No file type or path specified",\r
728 ExtraData=self._CurrentLine + " (<FileType> | <FilePath> [| <Target>])",\r
729 File=self.MetaFile, Line=self._LineIndex + 1)\r
730 if not TokenList[0]:\r
731 EdkLogger.error('Parser', FORMAT_INVALID, "No file type specified",\r
732 ExtraData=self._CurrentLine + " (<FileType> | <FilePath> [| <Target>])",\r
733 File=self.MetaFile, Line=self._LineIndex + 1)\r
734 if not TokenList[1]:\r
735 EdkLogger.error('Parser', FORMAT_INVALID, "No file path specified",\r
736 ExtraData=self._CurrentLine + " (<FileType> | <FilePath> [| <Target>])",\r
737 File=self.MetaFile, Line=self._LineIndex + 1)\r
738 self._ValueList[0:len(TokenList)] = TokenList\r
739 self._ValueList[1] = ReplaceMacro(self._ValueList[1], self._Macros)\r
740\r
741 ## [nmake] section parser (Edk.x style only)\r
742 def _NmakeParser(self):\r
743 TokenList = GetSplitValueList(self._CurrentLine, TAB_EQUAL_SPLIT, 1)\r
744 self._ValueList[0:len(TokenList)] = TokenList\r
745 # remove macros\r
746 self._ValueList[1] = ReplaceMacro(self._ValueList[1], self._Macros)\r
747 # remove self-reference in macro setting\r
748 #self._ValueList[1] = ReplaceMacro(self._ValueList[1], {self._ValueList[0]:''})\r
749\r
750 ## [FixedPcd], [FeaturePcd], [PatchPcd], [Pcd] and [PcdEx] sections parser\r
751 @ParseMacro\r
752 def _PcdParser(self):\r
753 TokenList = GetSplitValueList(self._CurrentLine, TAB_VALUE_SPLIT, 1)\r
754 ValueList = GetSplitValueList(TokenList[0], TAB_SPLIT)\r
755 if len(ValueList) != 2:\r
756 EdkLogger.error('Parser', FORMAT_INVALID, "Illegal token space GUID and PCD name format",\r
757 ExtraData=self._CurrentLine + " (<TokenSpaceGuidCName>.<PcdCName>)",\r
758 File=self.MetaFile, Line=self._LineIndex + 1)\r
759 self._ValueList[0:1] = ValueList\r
760 if len(TokenList) > 1:\r
761 self._ValueList[2] = TokenList[1]\r
762 if self._ValueList[0] == '' or self._ValueList[1] == '':\r
763 EdkLogger.error('Parser', FORMAT_INVALID, "No token space GUID or PCD name specified",\r
764 ExtraData=self._CurrentLine + " (<TokenSpaceGuidCName>.<PcdCName>)",\r
765 File=self.MetaFile, Line=self._LineIndex + 1)\r
766\r
767 # if value are 'True', 'true', 'TRUE' or 'False', 'false', 'FALSE', replace with integer 1 or 0.\r
768 if self._ValueList[2] != '':\r
769 InfPcdValueList = GetSplitValueList(TokenList[1], TAB_VALUE_SPLIT, 1)\r
770 if InfPcdValueList[0] in ['True', 'true', 'TRUE']:\r
771 self._ValueList[2] = TokenList[1].replace(InfPcdValueList[0], '1', 1);\r
772 elif InfPcdValueList[0] in ['False', 'false', 'FALSE']:\r
773 self._ValueList[2] = TokenList[1].replace(InfPcdValueList[0], '0', 1);\r
774 if (self._ValueList[0], self._ValueList[1]) not in self.PcdsDict:\r
775 self.PcdsDict[self._ValueList[0], self._ValueList[1]] = self._SectionType\r
776 elif self.PcdsDict[self._ValueList[0], self._ValueList[1]] != self._SectionType:\r
777 EdkLogger.error('Parser', FORMAT_INVALID, "It is not permissible to list a specified PCD in different PCD type sections.",\r
778 ExtraData=self._CurrentLine + " (<TokenSpaceGuidCName>.<PcdCName>)",\r
779 File=self.MetaFile, Line=self._LineIndex + 1)\r
780\r
781 ## [depex] section parser\r
782 @ParseMacro\r
783 def _DepexParser(self):\r
784 self._ValueList[0:1] = [self._CurrentLine]\r
785\r
786 _SectionParser = {\r
787 MODEL_UNKNOWN : MetaFileParser._Skip,\r
788 MODEL_META_DATA_HEADER : MetaFileParser._DefineParser,\r
789 MODEL_META_DATA_BUILD_OPTION : MetaFileParser._BuildOptionParser,\r
790 MODEL_EFI_INCLUDE : _IncludeParser, # for Edk.x modules\r
791 MODEL_EFI_LIBRARY_INSTANCE : MetaFileParser._CommonParser, # for Edk.x modules\r
792 MODEL_EFI_LIBRARY_CLASS : MetaFileParser._PathParser,\r
793 MODEL_META_DATA_PACKAGE : MetaFileParser._PathParser,\r
794 MODEL_META_DATA_NMAKE : _NmakeParser, # for Edk.x modules\r
795 MODEL_PCD_FIXED_AT_BUILD : _PcdParser,\r
796 MODEL_PCD_PATCHABLE_IN_MODULE : _PcdParser,\r
797 MODEL_PCD_FEATURE_FLAG : _PcdParser,\r
798 MODEL_PCD_DYNAMIC_EX : _PcdParser,\r
799 MODEL_PCD_DYNAMIC : _PcdParser,\r
800 MODEL_EFI_SOURCE_FILE : _SourceFileParser,\r
801 MODEL_EFI_GUID : MetaFileParser._CommonParser,\r
802 MODEL_EFI_PROTOCOL : MetaFileParser._CommonParser,\r
803 MODEL_EFI_PPI : MetaFileParser._CommonParser,\r
804 MODEL_EFI_DEPEX : _DepexParser,\r
805 MODEL_EFI_BINARY_FILE : _BinaryFileParser,\r
806 MODEL_META_DATA_USER_EXTENSION : MetaFileParser._SkipUserExtension,\r
807 }\r
808\r
809## DSC file parser class\r
810#\r
811# @param FilePath The path of platform description file\r
812# @param FileType The raw data of DSC file\r
813# @param Table Database used to retrieve module/package information\r
814# @param Macros Macros used for replacement in file\r
815# @param Owner Owner ID (for sub-section parsing)\r
816# @param From ID from which the data comes (for !INCLUDE directive)\r
817#\r
818class DscParser(MetaFileParser):\r
819 # DSC file supported data types (one type per section)\r
820 DataType = {\r
821 TAB_SKUIDS.upper() : MODEL_EFI_SKU_ID,\r
822 TAB_DEFAULT_STORES.upper() : MODEL_EFI_DEFAULT_STORES,\r
823 TAB_LIBRARIES.upper() : MODEL_EFI_LIBRARY_INSTANCE,\r
824 TAB_LIBRARY_CLASSES.upper() : MODEL_EFI_LIBRARY_CLASS,\r
825 TAB_BUILD_OPTIONS.upper() : MODEL_META_DATA_BUILD_OPTION,\r
826 TAB_PCDS_FIXED_AT_BUILD_NULL.upper() : MODEL_PCD_FIXED_AT_BUILD,\r
827 TAB_PCDS_PATCHABLE_IN_MODULE_NULL.upper() : MODEL_PCD_PATCHABLE_IN_MODULE,\r
828 TAB_PCDS_FEATURE_FLAG_NULL.upper() : MODEL_PCD_FEATURE_FLAG,\r
829 TAB_PCDS_DYNAMIC_DEFAULT_NULL.upper() : MODEL_PCD_DYNAMIC_DEFAULT,\r
830 TAB_PCDS_DYNAMIC_HII_NULL.upper() : MODEL_PCD_DYNAMIC_HII,\r
831 TAB_PCDS_DYNAMIC_VPD_NULL.upper() : MODEL_PCD_DYNAMIC_VPD,\r
832 TAB_PCDS_DYNAMIC_EX_DEFAULT_NULL.upper() : MODEL_PCD_DYNAMIC_EX_DEFAULT,\r
833 TAB_PCDS_DYNAMIC_EX_HII_NULL.upper() : MODEL_PCD_DYNAMIC_EX_HII,\r
834 TAB_PCDS_DYNAMIC_EX_VPD_NULL.upper() : MODEL_PCD_DYNAMIC_EX_VPD,\r
835 TAB_COMPONENTS.upper() : MODEL_META_DATA_COMPONENT,\r
836 TAB_COMPONENTS_SOURCE_OVERRIDE_PATH.upper() : MODEL_META_DATA_COMPONENT_SOURCE_OVERRIDE_PATH,\r
837 TAB_DSC_DEFINES.upper() : MODEL_META_DATA_HEADER,\r
838 TAB_DSC_DEFINES_DEFINE : MODEL_META_DATA_DEFINE,\r
839 TAB_DSC_DEFINES_EDKGLOBAL : MODEL_META_DATA_GLOBAL_DEFINE,\r
840 TAB_INCLUDE.upper() : MODEL_META_DATA_INCLUDE,\r
841 TAB_IF.upper() : MODEL_META_DATA_CONDITIONAL_STATEMENT_IF,\r
842 TAB_IF_DEF.upper() : MODEL_META_DATA_CONDITIONAL_STATEMENT_IFDEF,\r
843 TAB_IF_N_DEF.upper() : MODEL_META_DATA_CONDITIONAL_STATEMENT_IFNDEF,\r
844 TAB_ELSE_IF.upper() : MODEL_META_DATA_CONDITIONAL_STATEMENT_ELSEIF,\r
845 TAB_ELSE.upper() : MODEL_META_DATA_CONDITIONAL_STATEMENT_ELSE,\r
846 TAB_END_IF.upper() : MODEL_META_DATA_CONDITIONAL_STATEMENT_ENDIF,\r
847 TAB_USER_EXTENSIONS.upper() : MODEL_META_DATA_USER_EXTENSION,\r
848 TAB_ERROR.upper() : MODEL_META_DATA_CONDITIONAL_STATEMENT_ERROR,\r
849 }\r
850\r
851 # Valid names in define section\r
852 DefineKeywords = [\r
853 "DSC_SPECIFICATION",\r
854 "PLATFORM_NAME",\r
855 "PLATFORM_GUID",\r
856 "PLATFORM_VERSION",\r
857 "SKUID_IDENTIFIER",\r
858 "PCD_INFO_GENERATION",\r
859 "PCD_VAR_CHECK_GENERATION",\r
860 "SUPPORTED_ARCHITECTURES",\r
861 "BUILD_TARGETS",\r
862 "OUTPUT_DIRECTORY",\r
863 "FLASH_DEFINITION",\r
864 "BUILD_NUMBER",\r
865 "RFC_LANGUAGES",\r
866 "ISO_LANGUAGES",\r
867 "TIME_STAMP_FILE",\r
868 "VPD_TOOL_GUID",\r
869 "FIX_LOAD_TOP_MEMORY_ADDRESS",\r
870 "PREBUILD",\r
871 "POSTBUILD"\r
872 ]\r
873\r
874 SubSectionDefineKeywords = [\r
875 "FILE_GUID"\r
876 ]\r
877\r
878 SymbolPattern = ValueExpression.SymbolPattern\r
879\r
880 IncludedFiles = set()\r
881\r
882 ## Constructor of DscParser\r
883 #\r
884 # Initialize object of DscParser\r
885 #\r
886 # @param FilePath The path of platform description file\r
887 # @param FileType The raw data of DSC file\r
888 # @param Arch Default Arch value for filtering sections\r
889 # @param Table Database used to retrieve module/package information\r
890 # @param Owner Owner ID (for sub-section parsing)\r
891 # @param From ID from which the data comes (for !INCLUDE directive)\r
892 #\r
893 def __init__(self, FilePath, FileType, Arch, Table, Owner= -1, From= -1):\r
894 # prevent re-initialization\r
895 if hasattr(self, "_Table") and self._Table is Table:\r
896 return\r
897 MetaFileParser.__init__(self, FilePath, FileType, Arch, Table, Owner, From)\r
898 self._Version = 0x00010005 # Only EDK2 dsc file is supported\r
899 # to store conditional directive evaluation result\r
900 self._DirectiveStack = []\r
901 self._DirectiveEvalStack = []\r
902 self._Enabled = 1\r
903\r
904 #\r
905 # Specify whether current line is in uncertain condition\r
906 #\r
907 self._InDirective = -1\r
908\r
909 # Final valid replacable symbols\r
910 self._Symbols = {}\r
911 #\r
912 # Map the ID between the original table and new table to track\r
913 # the owner item\r
914 #\r
915 self._IdMapping = {-1:-1}\r
916\r
917 self._PcdCodeValue = ""\r
918 self._PcdDataTypeCODE = False\r
919 self._CurrentPcdName = ""\r
920 self._Content = None\r
921\r
922 ## Parser starter\r
923 def Start(self):\r
924 Content = ''\r
925 try:\r
926 Content = open(str(self.MetaFile), 'r').readlines()\r
927 except:\r
928 EdkLogger.error("Parser", FILE_READ_FAILURE, ExtraData=self.MetaFile)\r
929\r
930 OwnerId = {}\r
931\r
932 Content = self.ProcessMultipleLineCODEValue(Content)\r
933\r
934 for Index in range(0, len(Content)):\r
935 Line = CleanString(Content[Index])\r
936 # skip empty line\r
937 if Line == '':\r
938 continue\r
939\r
940 self._CurrentLine = Line\r
941 self._LineIndex = Index\r
942 if self._InSubsection and self._Owner[-1] == -1:\r
943 self._Owner.append(self._LastItem)\r
944\r
945 # section header\r
946 if Line[0] == TAB_SECTION_START and Line[-1] == TAB_SECTION_END:\r
947 self._SectionType = MODEL_META_DATA_SECTION_HEADER\r
948 # subsection ending\r
949 elif Line[0] == '}' and self._InSubsection:\r
950 self._InSubsection = False\r
951 self._SubsectionType = MODEL_UNKNOWN\r
952 self._SubsectionName = ''\r
953 self._Owner[-1] = -1\r
954 OwnerId.clear()\r
955 continue\r
956 # subsection header\r
957 elif Line[0] == TAB_OPTION_START and Line[-1] == TAB_OPTION_END:\r
958 self._SubsectionType = MODEL_META_DATA_SUBSECTION_HEADER\r
959 # directive line\r
960 elif Line[0] == '!':\r
961 TokenList = GetSplitValueList(Line, ' ', 1)\r
962 if TokenList[0] == TAB_INCLUDE:\r
963 for Arch, ModuleType, DefaultStore in self._Scope:\r
964 if self._SubsectionType != MODEL_UNKNOWN and Arch in OwnerId:\r
965 self._Owner[-1] = OwnerId[Arch]\r
966 self._DirectiveParser()\r
967 else:\r
968 self._DirectiveParser()\r
969 continue\r
970 if Line[0] == TAB_OPTION_START and not self._InSubsection:\r
971 EdkLogger.error("Parser", FILE_READ_FAILURE, "Missing the '{' before %s in Line %s" % (Line, Index+1), ExtraData=self.MetaFile)\r
972\r
973 if self._InSubsection:\r
974 SectionType = self._SubsectionType\r
975 else:\r
976 SectionType = self._SectionType\r
977 self._ItemType = SectionType\r
978\r
979 self._ValueList = ['', '', '']\r
980 self._SectionParser[SectionType](self)\r
981 if self._ValueList is None:\r
982 continue\r
983 #\r
984 # Model, Value1, Value2, Value3, Arch, ModuleType, BelongsToItem=-1, BelongsToFile=-1,\r
985 # LineBegin=-1, ColumnBegin=-1, LineEnd=-1, ColumnEnd=-1, Enabled=-1\r
986 #\r
987 for Arch, ModuleType, DefaultStore in self._Scope:\r
988 Owner = self._Owner[-1]\r
989 if self._SubsectionType != MODEL_UNKNOWN and Arch in OwnerId:\r
990 Owner = OwnerId[Arch]\r
991 self._LastItem = self._Store(\r
992 self._ItemType,\r
993 self._ValueList[0],\r
994 self._ValueList[1],\r
995 self._ValueList[2],\r
996 Arch,\r
997 ModuleType,\r
998 DefaultStore,\r
999 Owner,\r
1000 self._From,\r
1001 self._LineIndex + 1,\r
1002 - 1,\r
1003 self._LineIndex + 1,\r
1004 - 1,\r
1005 self._Enabled\r
1006 )\r
1007 if self._SubsectionType == MODEL_UNKNOWN and self._InSubsection:\r
1008 OwnerId[Arch] = self._LastItem\r
1009\r
1010 if self._DirectiveStack:\r
1011 Type, Line, Text = self._DirectiveStack[-1]\r
1012 EdkLogger.error('Parser', FORMAT_INVALID, "No matching '!endif' found",\r
1013 ExtraData=Text, File=self.MetaFile, Line=Line)\r
1014 self._Done()\r
1015\r
1016 ## <subsection_header> parser\r
1017 def _SubsectionHeaderParser(self):\r
1018 self._SubsectionName = self._CurrentLine[1:-1].upper()\r
1019 if self._SubsectionName in self.DataType:\r
1020 self._SubsectionType = self.DataType[self._SubsectionName]\r
1021 else:\r
1022 self._SubsectionType = MODEL_UNKNOWN\r
1023 EdkLogger.warn("Parser", "Unrecognized sub-section", File=self.MetaFile,\r
1024 Line=self._LineIndex + 1, ExtraData=self._CurrentLine)\r
1025 self._ValueList[0] = self._SubsectionName\r
1026\r
1027 ## Directive statement parser\r
1028 def _DirectiveParser(self):\r
1029 self._ValueList = ['', '', '']\r
1030 TokenList = GetSplitValueList(self._CurrentLine, ' ', 1)\r
1031 self._ValueList[0:len(TokenList)] = TokenList\r
1032\r
1033 # Syntax check\r
1034 DirectiveName = self._ValueList[0].upper()\r
1035 if DirectiveName not in self.DataType:\r
1036 EdkLogger.error("Parser", FORMAT_INVALID, "Unknown directive [%s]" % DirectiveName,\r
1037 File=self.MetaFile, Line=self._LineIndex + 1)\r
1038\r
1039 if DirectiveName in ['!IF', '!IFDEF', '!IFNDEF']:\r
1040 self._InDirective += 1\r
1041\r
1042 if DirectiveName in ['!ENDIF']:\r
1043 self._InDirective -= 1\r
1044\r
1045 if DirectiveName in ['!IF', '!IFDEF', '!INCLUDE', '!IFNDEF', '!ELSEIF'] and self._ValueList[1] == '':\r
1046 EdkLogger.error("Parser", FORMAT_INVALID, "Missing expression",\r
1047 File=self.MetaFile, Line=self._LineIndex + 1,\r
1048 ExtraData=self._CurrentLine)\r
1049\r
1050 ItemType = self.DataType[DirectiveName]\r
1051 Scope = [[TAB_COMMON, TAB_COMMON, TAB_COMMON]]\r
1052 if ItemType == MODEL_META_DATA_INCLUDE:\r
1053 Scope = self._Scope\r
1054 elif ItemType == MODEL_META_DATA_CONDITIONAL_STATEMENT_ERROR:\r
1055 Scope = self._Scope\r
1056 if ItemType == MODEL_META_DATA_CONDITIONAL_STATEMENT_ENDIF:\r
1057 # Remove all directives between !if and !endif, including themselves\r
1058 while self._DirectiveStack:\r
1059 # Remove any !else or !elseif\r
1060 DirectiveInfo = self._DirectiveStack.pop()\r
1061 if DirectiveInfo[0] in [MODEL_META_DATA_CONDITIONAL_STATEMENT_IF,\r
1062 MODEL_META_DATA_CONDITIONAL_STATEMENT_IFDEF,\r
1063 MODEL_META_DATA_CONDITIONAL_STATEMENT_IFNDEF]:\r
1064 break\r
1065 else:\r
1066 EdkLogger.error("Parser", FORMAT_INVALID, "Redundant '!endif'",\r
1067 File=self.MetaFile, Line=self._LineIndex + 1,\r
1068 ExtraData=self._CurrentLine)\r
1069 elif ItemType not in {MODEL_META_DATA_INCLUDE, MODEL_META_DATA_CONDITIONAL_STATEMENT_ERROR}:\r
1070 # Break if there's a !else is followed by a !elseif\r
1071 if ItemType == MODEL_META_DATA_CONDITIONAL_STATEMENT_ELSEIF and \\r
1072 self._DirectiveStack and \\r
1073 self._DirectiveStack[-1][0] == MODEL_META_DATA_CONDITIONAL_STATEMENT_ELSE:\r
1074 EdkLogger.error("Parser", FORMAT_INVALID, "'!elseif' after '!else'",\r
1075 File=self.MetaFile, Line=self._LineIndex + 1,\r
1076 ExtraData=self._CurrentLine)\r
1077 self._DirectiveStack.append((ItemType, self._LineIndex + 1, self._CurrentLine))\r
1078\r
1079 #\r
1080 # Model, Value1, Value2, Value3, Arch, ModuleType, BelongsToItem=-1, BelongsToFile=-1,\r
1081 # LineBegin=-1, ColumnBegin=-1, LineEnd=-1, ColumnEnd=-1, Enabled=-1\r
1082 #\r
1083 for Arch, ModuleType, DefaultStore in Scope:\r
1084 self._LastItem = self._Store(\r
1085 ItemType,\r
1086 self._ValueList[0],\r
1087 self._ValueList[1],\r
1088 self._ValueList[2],\r
1089 Arch,\r
1090 ModuleType,\r
1091 DefaultStore,\r
1092 self._Owner[-1],\r
1093 self._From,\r
1094 self._LineIndex + 1,\r
1095 - 1,\r
1096 self._LineIndex + 1,\r
1097 - 1,\r
1098 0\r
1099 )\r
1100\r
1101 ## [defines] section parser\r
1102 @ParseMacro\r
1103 def _DefineParser(self):\r
1104 TokenList = GetSplitValueList(self._CurrentLine, TAB_EQUAL_SPLIT, 1)\r
1105 self._ValueList[1:len(TokenList)] = TokenList\r
1106\r
1107 # Syntax check\r
1108 if not self._ValueList[1]:\r
1109 EdkLogger.error('Parser', FORMAT_INVALID, "No name specified",\r
1110 ExtraData=self._CurrentLine, File=self.MetaFile, Line=self._LineIndex + 1)\r
1111 if not self._ValueList[2]:\r
1112 EdkLogger.error('Parser', FORMAT_INVALID, "No value specified",\r
1113 ExtraData=self._CurrentLine, File=self.MetaFile, Line=self._LineIndex + 1)\r
1114 if (not self._ValueList[1] in self.DefineKeywords and\r
1115 (self._InSubsection and self._ValueList[1] not in self.SubSectionDefineKeywords)):\r
1116 EdkLogger.error('Parser', FORMAT_INVALID,\r
1117 "Unknown keyword found: %s. "\r
1118 "If this is a macro you must "\r
1119 "add it as a DEFINE in the DSC" % self._ValueList[1],\r
1120 ExtraData=self._CurrentLine, File=self.MetaFile, Line=self._LineIndex + 1)\r
1121 if not self._InSubsection:\r
1122 self._Defines[self._ValueList[1]] = self._ValueList[2]\r
1123 self._ItemType = self.DataType[TAB_DSC_DEFINES.upper()]\r
1124\r
1125 @ParseMacro\r
1126 def _SkuIdParser(self):\r
1127 TokenList = GetSplitValueList(self._CurrentLine, TAB_VALUE_SPLIT)\r
1128 if len(TokenList) not in (2, 3):\r
1129 EdkLogger.error('Parser', FORMAT_INVALID, "Correct format is '<Number>|<UiName>[|<UiName>]'",\r
1130 ExtraData=self._CurrentLine, File=self.MetaFile, Line=self._LineIndex + 1)\r
1131 self._ValueList[0:len(TokenList)] = TokenList\r
1132 @ParseMacro\r
1133 def _DefaultStoresParser(self):\r
1134 TokenList = GetSplitValueList(self._CurrentLine, TAB_VALUE_SPLIT)\r
1135 if len(TokenList) != 2:\r
1136 EdkLogger.error('Parser', FORMAT_INVALID, "Correct format is '<Number>|<UiName>'",\r
1137 ExtraData=self._CurrentLine, File=self.MetaFile, Line=self._LineIndex + 1)\r
1138 self._ValueList[0:len(TokenList)] = TokenList\r
1139\r
1140 ## Parse Edk style of library modules\r
1141 @ParseMacro\r
1142 def _LibraryInstanceParser(self):\r
1143 self._ValueList[0] = self._CurrentLine\r
1144\r
1145 def ProcessMultipleLineCODEValue(self,Content):\r
1146 CODEBegin = False\r
1147 CODELine = ""\r
1148 continuelinecount = 0\r
1149 newContent = []\r
1150 for Index in range(0, len(Content)):\r
1151 Line = Content[Index]\r
1152 if CODEBegin:\r
1153 CODELine = CODELine + Line\r
1154 continuelinecount +=1\r
1155 if ")}" in Line:\r
1156 newContent.append(CODELine)\r
1157 for _ in range(continuelinecount):\r
1158 newContent.append("")\r
1159 CODEBegin = False\r
1160 CODELine = ""\r
1161 continuelinecount = 0\r
1162 else:\r
1163 if not Line:\r
1164 newContent.append(Line)\r
1165 continue\r
1166 if "{CODE(" not in Line:\r
1167 newContent.append(Line)\r
1168 continue\r
1169 elif CODEPattern.findall(Line):\r
1170 newContent.append(Line)\r
1171 continue\r
1172 else:\r
1173 CODEBegin = True\r
1174 CODELine = Line\r
1175\r
1176 return newContent\r
1177\r
1178 def _DecodeCODEData(self):\r
1179 pass\r
1180 ## PCD sections parser\r
1181 #\r
1182 # [PcdsFixedAtBuild]\r
1183 # [PcdsPatchableInModule]\r
1184 # [PcdsFeatureFlag]\r
1185 # [PcdsDynamicEx\r
1186 # [PcdsDynamicExDefault]\r
1187 # [PcdsDynamicExVpd]\r
1188 # [PcdsDynamicExHii]\r
1189 # [PcdsDynamic]\r
1190 # [PcdsDynamicDefault]\r
1191 # [PcdsDynamicVpd]\r
1192 # [PcdsDynamicHii]\r
1193 #\r
1194 @ParseMacro\r
1195 def _PcdParser(self):\r
1196 if self._PcdDataTypeCODE:\r
1197 self._PcdCodeValue = self._PcdCodeValue + "\n " + self._CurrentLine\r
1198 if self._CurrentLine.endswith(")}"):\r
1199 self._CurrentLine = "|".join((self._CurrentPcdName, self._PcdCodeValue))\r
1200 self._PcdDataTypeCODE = False\r
1201 self._PcdCodeValue = ""\r
1202 else:\r
1203 self._ValueList = None\r
1204 return\r
1205 TokenList = GetSplitValueList(self._CurrentLine, TAB_VALUE_SPLIT, 1)\r
1206 self._CurrentPcdName = TokenList[0]\r
1207 if len(TokenList) == 2 and TokenList[1].strip().startswith("{CODE"):\r
1208 self._PcdDataTypeCODE = True\r
1209 self._PcdCodeValue = TokenList[1].strip()\r
1210\r
1211 if self._PcdDataTypeCODE:\r
1212 if self._CurrentLine.endswith(")}"):\r
1213 self._PcdDataTypeCODE = False\r
1214 self._PcdCodeValue = ""\r
1215 else:\r
1216 self._ValueList = None\r
1217 return\r
1218 self._ValueList[0:1] = GetSplitValueList(TokenList[0], TAB_SPLIT)\r
1219 PcdNameTockens = GetSplitValueList(TokenList[0], TAB_SPLIT)\r
1220 if len(PcdNameTockens) == 2:\r
1221 self._ValueList[0], self._ValueList[1] = PcdNameTockens[0], PcdNameTockens[1]\r
1222 elif len(PcdNameTockens) == 3:\r
1223 self._ValueList[0], self._ValueList[1] = ".".join((PcdNameTockens[0], PcdNameTockens[1])), PcdNameTockens[2]\r
1224 elif len(PcdNameTockens) > 3:\r
1225 self._ValueList[0], self._ValueList[1] = ".".join((PcdNameTockens[0], PcdNameTockens[1])), ".".join(PcdNameTockens[2:])\r
1226 if len(TokenList) == 2:\r
1227 self._ValueList[2] = TokenList[1]\r
1228 if self._ValueList[0] == '' or self._ValueList[1] == '':\r
1229 EdkLogger.error('Parser', FORMAT_INVALID, "No token space GUID or PCD name specified",\r
1230 ExtraData=self._CurrentLine + " (<TokenSpaceGuidCName>.<TokenCName>|<PcdValue>)",\r
1231 File=self.MetaFile, Line=self._LineIndex + 1)\r
1232 if self._ValueList[2] == '':\r
1233 #\r
1234 # The PCD values are optional for FIXEDATBUILD, PATCHABLEINMODULE, Dynamic/DynamicEx default\r
1235 #\r
1236 if self._SectionType in (MODEL_PCD_FIXED_AT_BUILD, MODEL_PCD_PATCHABLE_IN_MODULE, MODEL_PCD_DYNAMIC_DEFAULT, MODEL_PCD_DYNAMIC_EX_DEFAULT):\r
1237 return\r
1238 EdkLogger.error('Parser', FORMAT_INVALID, "No PCD value given",\r
1239 ExtraData=self._CurrentLine + " (<TokenSpaceGuidCName>.<TokenCName>|<PcdValue>)",\r
1240 File=self.MetaFile, Line=self._LineIndex + 1)\r
1241\r
1242 # Validate the datum type of Dynamic Defaul PCD and DynamicEx Default PCD\r
1243 ValueList = GetSplitValueList(self._ValueList[2])\r
1244 if len(ValueList) > 1 and ValueList[1] in [TAB_UINT8, TAB_UINT16, TAB_UINT32, TAB_UINT64] \\r
1245 and self._ItemType in [MODEL_PCD_DYNAMIC_DEFAULT, MODEL_PCD_DYNAMIC_EX_DEFAULT]:\r
1246 EdkLogger.error('Parser', FORMAT_INVALID, "The datum type '%s' of PCD is wrong" % ValueList[1],\r
1247 ExtraData=self._CurrentLine, File=self.MetaFile, Line=self._LineIndex + 1)\r
1248\r
1249 # Validate the VariableName of DynamicHii and DynamicExHii for PCD Entry must not be an empty string\r
1250 if self._ItemType in [MODEL_PCD_DYNAMIC_HII, MODEL_PCD_DYNAMIC_EX_HII]:\r
1251 DscPcdValueList = GetSplitValueList(TokenList[1], TAB_VALUE_SPLIT, 1)\r
1252 if len(DscPcdValueList[0].replace('L', '').replace('"', '').strip()) == 0:\r
1253 EdkLogger.error('Parser', FORMAT_INVALID, "The VariableName field in the HII format PCD entry must not be an empty string",\r
1254 ExtraData=self._CurrentLine, File=self.MetaFile, Line=self._LineIndex + 1)\r
1255\r
1256 # if value are 'True', 'true', 'TRUE' or 'False', 'false', 'FALSE', replace with integer 1 or 0.\r
1257 DscPcdValueList = GetSplitValueList(TokenList[1], TAB_VALUE_SPLIT, 1)\r
1258 if DscPcdValueList[0] in ['True', 'true', 'TRUE']:\r
1259 self._ValueList[2] = TokenList[1].replace(DscPcdValueList[0], '1', 1);\r
1260 elif DscPcdValueList[0] in ['False', 'false', 'FALSE']:\r
1261 self._ValueList[2] = TokenList[1].replace(DscPcdValueList[0], '0', 1);\r
1262\r
1263\r
1264 ## [components] section parser\r
1265 @ParseMacro\r
1266 def _ComponentParser(self):\r
1267 if self._CurrentLine[-1] == '{':\r
1268 self._ValueList[0] = self._CurrentLine[0:-1].strip()\r
1269 self._InSubsection = True\r
1270 self._SubsectionType = MODEL_UNKNOWN\r
1271 else:\r
1272 self._ValueList[0] = self._CurrentLine\r
1273\r
1274 ## [LibraryClasses] section\r
1275 @ParseMacro\r
1276 def _LibraryClassParser(self):\r
1277 TokenList = GetSplitValueList(self._CurrentLine, TAB_VALUE_SPLIT)\r
1278 if len(TokenList) < 2:\r
1279 EdkLogger.error('Parser', FORMAT_INVALID, "No library class or instance specified",\r
1280 ExtraData=self._CurrentLine + " (<LibraryClassName>|<LibraryInstancePath>)",\r
1281 File=self.MetaFile, Line=self._LineIndex + 1)\r
1282 if TokenList[0] == '':\r
1283 EdkLogger.error('Parser', FORMAT_INVALID, "No library class specified",\r
1284 ExtraData=self._CurrentLine + " (<LibraryClassName>|<LibraryInstancePath>)",\r
1285 File=self.MetaFile, Line=self._LineIndex + 1)\r
1286 if TokenList[1] == '':\r
1287 EdkLogger.error('Parser', FORMAT_INVALID, "No library instance specified",\r
1288 ExtraData=self._CurrentLine + " (<LibraryClassName>|<LibraryInstancePath>)",\r
1289 File=self.MetaFile, Line=self._LineIndex + 1)\r
1290\r
1291 self._ValueList[0:len(TokenList)] = TokenList\r
1292\r
1293 def _CompponentSourceOverridePathParser(self):\r
1294 self._ValueList[0] = self._CurrentLine\r
1295\r
1296 ## [BuildOptions] section parser\r
1297 @ParseMacro\r
1298 def _BuildOptionParser(self):\r
1299 self._CurrentLine = CleanString(self._CurrentLine, BuildOption=True)\r
1300 TokenList = GetSplitValueList(self._CurrentLine, TAB_EQUAL_SPLIT, 1)\r
1301 TokenList2 = GetSplitValueList(TokenList[0], ':', 1)\r
1302 if len(TokenList2) == 2:\r
1303 self._ValueList[0] = TokenList2[0] # toolchain family\r
1304 self._ValueList[1] = TokenList2[1] # keys\r
1305 else:\r
1306 self._ValueList[1] = TokenList[0]\r
1307 if len(TokenList) == 2: # value\r
1308 self._ValueList[2] = TokenList[1]\r
1309\r
1310 if self._ValueList[1].count('_') != 4:\r
1311 EdkLogger.error(\r
1312 'Parser',\r
1313 FORMAT_INVALID,\r
1314 "'%s' must be in format of <TARGET>_<TOOLCHAIN>_<ARCH>_<TOOL>_FLAGS" % self._ValueList[1],\r
1315 ExtraData=self._CurrentLine,\r
1316 File=self.MetaFile,\r
1317 Line=self._LineIndex + 1\r
1318 )\r
1319\r
1320 ## Override parent's method since we'll do all macro replacements in parser\r
1321 @property\r
1322 def _Macros(self):\r
1323 Macros = {}\r
1324 Macros.update(self._FileLocalMacros)\r
1325 Macros.update(self._GetApplicableSectionMacro())\r
1326 Macros.update(GlobalData.gEdkGlobal)\r
1327 Macros.update(GlobalData.gPlatformDefines)\r
1328 Macros.update(GlobalData.gCommandLineDefines)\r
1329 # PCD cannot be referenced in macro definition\r
1330 if self._ItemType not in [MODEL_META_DATA_DEFINE, MODEL_META_DATA_GLOBAL_DEFINE]:\r
1331 Macros.update(self._Symbols)\r
1332 if GlobalData.BuildOptionPcd:\r
1333 for Item in GlobalData.BuildOptionPcd:\r
1334 if isinstance(Item, tuple):\r
1335 continue\r
1336 PcdName, TmpValue = Item.split("=")\r
1337 TmpValue = BuildOptionValue(TmpValue, self._GuidDict)\r
1338 Macros[PcdName.strip()] = TmpValue\r
1339 return Macros\r
1340\r
1341 def _PostProcess(self):\r
1342 Processer = {\r
1343 MODEL_META_DATA_SECTION_HEADER : self.__ProcessSectionHeader,\r
1344 MODEL_META_DATA_SUBSECTION_HEADER : self.__ProcessSubsectionHeader,\r
1345 MODEL_META_DATA_HEADER : self.__ProcessDefine,\r
1346 MODEL_META_DATA_DEFINE : self.__ProcessDefine,\r
1347 MODEL_META_DATA_GLOBAL_DEFINE : self.__ProcessDefine,\r
1348 MODEL_META_DATA_INCLUDE : self.__ProcessDirective,\r
1349 MODEL_META_DATA_CONDITIONAL_STATEMENT_IF : self.__ProcessDirective,\r
1350 MODEL_META_DATA_CONDITIONAL_STATEMENT_ELSE : self.__ProcessDirective,\r
1351 MODEL_META_DATA_CONDITIONAL_STATEMENT_IFDEF : self.__ProcessDirective,\r
1352 MODEL_META_DATA_CONDITIONAL_STATEMENT_IFNDEF : self.__ProcessDirective,\r
1353 MODEL_META_DATA_CONDITIONAL_STATEMENT_ENDIF : self.__ProcessDirective,\r
1354 MODEL_META_DATA_CONDITIONAL_STATEMENT_ELSEIF : self.__ProcessDirective,\r
1355 MODEL_EFI_SKU_ID : self.__ProcessSkuId,\r
1356 MODEL_EFI_DEFAULT_STORES : self.__ProcessDefaultStores,\r
1357 MODEL_EFI_LIBRARY_INSTANCE : self.__ProcessLibraryInstance,\r
1358 MODEL_EFI_LIBRARY_CLASS : self.__ProcessLibraryClass,\r
1359 MODEL_PCD_FIXED_AT_BUILD : self.__ProcessPcd,\r
1360 MODEL_PCD_PATCHABLE_IN_MODULE : self.__ProcessPcd,\r
1361 MODEL_PCD_FEATURE_FLAG : self.__ProcessPcd,\r
1362 MODEL_PCD_DYNAMIC_DEFAULT : self.__ProcessPcd,\r
1363 MODEL_PCD_DYNAMIC_HII : self.__ProcessPcd,\r
1364 MODEL_PCD_DYNAMIC_VPD : self.__ProcessPcd,\r
1365 MODEL_PCD_DYNAMIC_EX_DEFAULT : self.__ProcessPcd,\r
1366 MODEL_PCD_DYNAMIC_EX_HII : self.__ProcessPcd,\r
1367 MODEL_PCD_DYNAMIC_EX_VPD : self.__ProcessPcd,\r
1368 MODEL_META_DATA_COMPONENT : self.__ProcessComponent,\r
1369 MODEL_META_DATA_COMPONENT_SOURCE_OVERRIDE_PATH : self.__ProcessSourceOverridePath,\r
1370 MODEL_META_DATA_BUILD_OPTION : self.__ProcessBuildOption,\r
1371 MODEL_UNKNOWN : self._Skip,\r
1372 MODEL_META_DATA_USER_EXTENSION : self._SkipUserExtension,\r
1373 MODEL_META_DATA_CONDITIONAL_STATEMENT_ERROR : self._ProcessError,\r
1374 }\r
1375\r
1376 self._Table = MetaFileStorage(self._RawTable.DB, self.MetaFile, MODEL_FILE_DSC, True)\r
1377 self._DirectiveStack = []\r
1378 self._DirectiveEvalStack = []\r
1379 self._FileWithError = self.MetaFile\r
1380 self._FileLocalMacros = {}\r
1381 self._SectionsMacroDict.clear()\r
1382 GlobalData.gPlatformDefines = {}\r
1383\r
1384 # Get all macro and PCD which has straitforward value\r
1385 self.__RetrievePcdValue()\r
1386 self._Content = self._RawTable.GetAll()\r
1387 self._ContentIndex = 0\r
1388 self._InSubsection = False\r
1389 while self._ContentIndex < len(self._Content) :\r
1390 Id, self._ItemType, V1, V2, V3, S1, S2, S3, Owner, self._From, \\r
1391 LineStart, ColStart, LineEnd, ColEnd, Enabled = self._Content[self._ContentIndex]\r
1392\r
1393 if self._From < 0:\r
1394 self._FileWithError = self.MetaFile\r
1395\r
1396 self._ContentIndex += 1\r
1397\r
1398 self._Scope = [[S1, S2, S3]]\r
1399 #\r
1400 # For !include directive, handle it specially,\r
1401 # merge arch and module type in case of duplicate items\r
1402 #\r
1403 while self._ItemType == MODEL_META_DATA_INCLUDE:\r
1404 if self._ContentIndex >= len(self._Content):\r
1405 break\r
1406 Record = self._Content[self._ContentIndex]\r
1407 if LineStart == Record[10] and LineEnd == Record[12]:\r
1408 if [Record[5], Record[6], Record[7]] not in self._Scope:\r
1409 self._Scope.append([Record[5], Record[6], Record[7]])\r
1410 self._ContentIndex += 1\r
1411 else:\r
1412 break\r
1413\r
1414 self._LineIndex = LineStart - 1\r
1415 self._ValueList = [V1, V2, V3]\r
1416\r
1417 if Owner > 0 and Owner in self._IdMapping:\r
1418 self._InSubsection = True\r
1419 else:\r
1420 self._InSubsection = False\r
1421 try:\r
1422 Processer[self._ItemType]()\r
1423 except EvaluationException as Excpt:\r
1424 #\r
1425 # Only catch expression evaluation error here. We need to report\r
1426 # the precise number of line on which the error occurred\r
1427 #\r
1428 if hasattr(Excpt, 'Pcd'):\r
1429 if Excpt.Pcd in GlobalData.gPlatformOtherPcds:\r
1430 Info = GlobalData.gPlatformOtherPcds[Excpt.Pcd]\r
1431 EdkLogger.error('Parser', FORMAT_INVALID, "Cannot use this PCD (%s) in an expression as"\r
1432 " it must be defined in a [PcdsFixedAtBuild] or [PcdsFeatureFlag] section"\r
1433 " of the DSC file, and it is currently defined in this section:"\r
1434 " %s, line #: %d." % (Excpt.Pcd, Info[0], Info[1]),\r
1435 File=self._FileWithError, ExtraData=' '.join(self._ValueList),\r
1436 Line=self._LineIndex + 1)\r
1437 else:\r
1438 EdkLogger.error('Parser', FORMAT_INVALID, "PCD (%s) is not defined in DSC file" % Excpt.Pcd,\r
1439 File=self._FileWithError, ExtraData=' '.join(self._ValueList),\r
1440 Line=self._LineIndex + 1)\r
1441 else:\r
1442 EdkLogger.error('Parser', FORMAT_INVALID, "Invalid expression: %s" % str(Excpt),\r
1443 File=self._FileWithError, ExtraData=' '.join(self._ValueList),\r
1444 Line=self._LineIndex + 1)\r
1445 except MacroException as Excpt:\r
1446 EdkLogger.error('Parser', FORMAT_INVALID, str(Excpt),\r
1447 File=self._FileWithError, ExtraData=' '.join(self._ValueList),\r
1448 Line=self._LineIndex + 1)\r
1449\r
1450 if self._ValueList is None:\r
1451 continue\r
1452\r
1453 NewOwner = self._IdMapping.get(Owner, -1)\r
1454 self._Enabled = int((not self._DirectiveEvalStack) or (False not in self._DirectiveEvalStack))\r
1455 self._LastItem = self._Store(\r
1456 self._ItemType,\r
1457 self._ValueList[0],\r
1458 self._ValueList[1],\r
1459 self._ValueList[2],\r
1460 S1,\r
1461 S2,\r
1462 S3,\r
1463 NewOwner,\r
1464 self._From,\r
1465 self._LineIndex + 1,\r
1466 - 1,\r
1467 self._LineIndex + 1,\r
1468 - 1,\r
1469 self._Enabled\r
1470 )\r
1471 self._IdMapping[Id] = self._LastItem\r
1472\r
1473 GlobalData.gPlatformDefines.update(self._FileLocalMacros)\r
1474 self._PostProcessed = True\r
1475 self._Content = None\r
1476 def _ProcessError(self):\r
1477 if not self._Enabled:\r
1478 return\r
1479 EdkLogger.error('Parser', ERROR_STATEMENT, self._ValueList[1], File=self.MetaFile, Line=self._LineIndex + 1)\r
1480\r
1481 def __ProcessSectionHeader(self):\r
1482 self._SectionName = self._ValueList[0]\r
1483 if self._SectionName in self.DataType:\r
1484 self._SectionType = self.DataType[self._SectionName]\r
1485 else:\r
1486 self._SectionType = MODEL_UNKNOWN\r
1487\r
1488 def __ProcessSubsectionHeader(self):\r
1489 self._SubsectionName = self._ValueList[0]\r
1490 if self._SubsectionName in self.DataType:\r
1491 self._SubsectionType = self.DataType[self._SubsectionName]\r
1492 else:\r
1493 self._SubsectionType = MODEL_UNKNOWN\r
1494\r
1495 def __RetrievePcdValue(self):\r
1496 Content = open(str(self.MetaFile), 'r').readlines()\r
1497 GlobalData.gPlatformOtherPcds['DSCFILE'] = str(self.MetaFile)\r
1498 for PcdType in (MODEL_PCD_PATCHABLE_IN_MODULE, MODEL_PCD_DYNAMIC_DEFAULT, MODEL_PCD_DYNAMIC_HII,\r
1499 MODEL_PCD_DYNAMIC_VPD, MODEL_PCD_DYNAMIC_EX_DEFAULT, MODEL_PCD_DYNAMIC_EX_HII,\r
1500 MODEL_PCD_DYNAMIC_EX_VPD):\r
1501 Records = self._RawTable.Query(PcdType, BelongsToItem= -1.0)\r
1502 for TokenSpaceGuid, PcdName, Value, Dummy2, Dummy3, Dummy4, ID, Line in Records:\r
1503 Name = TokenSpaceGuid + '.' + PcdName\r
1504 if Name not in GlobalData.gPlatformOtherPcds:\r
1505 PcdLine = Line\r
1506 while not Content[Line - 1].lstrip().startswith(TAB_SECTION_START):\r
1507 Line -= 1\r
1508 GlobalData.gPlatformOtherPcds[Name] = (CleanString(Content[Line - 1]), PcdLine, PcdType)\r
1509\r
1510 def __ProcessDefine(self):\r
1511 if not self._Enabled:\r
1512 return\r
1513\r
1514 Type, Name, Value = self._ValueList\r
1515 Value = ReplaceMacro(Value, self._Macros, False)\r
1516 #\r
1517 # If it is <Defines>, return\r
1518 #\r
1519 if self._InSubsection:\r
1520 self._ValueList = [Type, Name, Value]\r
1521 return\r
1522\r
1523 if self._ItemType == MODEL_META_DATA_DEFINE:\r
1524 if self._SectionType == MODEL_META_DATA_HEADER:\r
1525 self._FileLocalMacros[Name] = Value\r
1526 else:\r
1527 self._ConstructSectionMacroDict(Name, Value)\r
1528 elif self._ItemType == MODEL_META_DATA_GLOBAL_DEFINE:\r
1529 GlobalData.gEdkGlobal[Name] = Value\r
1530\r
1531 #\r
1532 # Keyword in [Defines] section can be used as Macros\r
1533 #\r
1534 if (self._ItemType == MODEL_META_DATA_HEADER) and (self._SectionType == MODEL_META_DATA_HEADER):\r
1535 self._FileLocalMacros[Name] = Value\r
1536\r
1537 self._ValueList = [Type, Name, Value]\r
1538\r
1539 def __ProcessDirective(self):\r
1540 Result = None\r
1541 if self._ItemType in [MODEL_META_DATA_CONDITIONAL_STATEMENT_IF,\r
1542 MODEL_META_DATA_CONDITIONAL_STATEMENT_ELSEIF]:\r
1543 Macros = self._Macros\r
1544 Macros.update(GlobalData.gGlobalDefines)\r
1545 try:\r
1546 Result = ValueExpression(self._ValueList[1], Macros)()\r
1547 except SymbolNotFound as Exc:\r
1548 EdkLogger.debug(EdkLogger.DEBUG_5, str(Exc), self._ValueList[1])\r
1549 Result = False\r
1550 except WrnExpression as Excpt:\r
1551 #\r
1552 # Catch expression evaluation warning here. We need to report\r
1553 # the precise number of line and return the evaluation result\r
1554 #\r
1555 EdkLogger.warn('Parser', "Suspicious expression: %s" % str(Excpt),\r
1556 File=self._FileWithError, ExtraData=' '.join(self._ValueList),\r
1557 Line=self._LineIndex + 1)\r
1558 Result = Excpt.result\r
1559\r
1560 if self._ItemType in [MODEL_META_DATA_CONDITIONAL_STATEMENT_IF,\r
1561 MODEL_META_DATA_CONDITIONAL_STATEMENT_IFDEF,\r
1562 MODEL_META_DATA_CONDITIONAL_STATEMENT_IFNDEF]:\r
1563 self._DirectiveStack.append(self._ItemType)\r
1564 if self._ItemType == MODEL_META_DATA_CONDITIONAL_STATEMENT_IF:\r
1565 Result = bool(Result)\r
1566 else:\r
1567 Macro = self._ValueList[1]\r
1568 Macro = Macro[2:-1] if (Macro.startswith("$(") and Macro.endswith(")")) else Macro\r
1569 Result = Macro in self._Macros\r
1570 if self._ItemType == MODEL_META_DATA_CONDITIONAL_STATEMENT_IFNDEF:\r
1571 Result = not Result\r
1572 self._DirectiveEvalStack.append(Result)\r
1573 elif self._ItemType == MODEL_META_DATA_CONDITIONAL_STATEMENT_ELSEIF:\r
1574 self._DirectiveStack.append(self._ItemType)\r
1575 self._DirectiveEvalStack[-1] = not self._DirectiveEvalStack[-1]\r
1576 self._DirectiveEvalStack.append(bool(Result))\r
1577 elif self._ItemType == MODEL_META_DATA_CONDITIONAL_STATEMENT_ELSE:\r
1578 self._DirectiveStack.append(self._ItemType)\r
1579 self._DirectiveEvalStack[-1] = not self._DirectiveEvalStack[-1]\r
1580 self._DirectiveEvalStack.append(True)\r
1581 elif self._ItemType == MODEL_META_DATA_CONDITIONAL_STATEMENT_ENDIF:\r
1582 # Back to the nearest !if/!ifdef/!ifndef\r
1583 while self._DirectiveStack:\r
1584 self._DirectiveEvalStack.pop()\r
1585 Directive = self._DirectiveStack.pop()\r
1586 if Directive in [MODEL_META_DATA_CONDITIONAL_STATEMENT_IF,\r
1587 MODEL_META_DATA_CONDITIONAL_STATEMENT_IFDEF,\r
1588 MODEL_META_DATA_CONDITIONAL_STATEMENT_IFNDEF]:\r
1589 break\r
1590 elif self._ItemType == MODEL_META_DATA_INCLUDE:\r
1591 # The included file must be relative to workspace or same directory as DSC file\r
1592 __IncludeMacros = {}\r
1593 #\r
1594 # Allow using system environment variables in path after !include\r
1595 #\r
1596 __IncludeMacros['WORKSPACE'] = GlobalData.gGlobalDefines['WORKSPACE']\r
1597 if "ECP_SOURCE" in GlobalData.gGlobalDefines:\r
1598 __IncludeMacros['ECP_SOURCE'] = GlobalData.gGlobalDefines['ECP_SOURCE']\r
1599 #\r
1600 # During GenFds phase call DSC parser, will go into this branch.\r
1601 #\r
1602 elif "ECP_SOURCE" in GlobalData.gCommandLineDefines:\r
1603 __IncludeMacros['ECP_SOURCE'] = GlobalData.gCommandLineDefines['ECP_SOURCE']\r
1604\r
1605 __IncludeMacros['EFI_SOURCE'] = GlobalData.gGlobalDefines['EFI_SOURCE']\r
1606 __IncludeMacros['EDK_SOURCE'] = GlobalData.gGlobalDefines['EDK_SOURCE']\r
1607 #\r
1608 # Allow using MACROs comes from [Defines] section to keep compatible.\r
1609 #\r
1610 __IncludeMacros.update(self._Macros)\r
1611\r
1612 IncludedFile = NormPath(ReplaceMacro(self._ValueList[1], __IncludeMacros, RaiseError=True))\r
1613 #\r
1614 # First search the include file under the same directory as DSC file\r
1615 #\r
1616 IncludedFile1 = PathClass(IncludedFile, self.MetaFile.Dir)\r
1617 ErrorCode, ErrorInfo1 = IncludedFile1.Validate()\r
1618 if ErrorCode != 0:\r
1619 #\r
1620 # Also search file under the WORKSPACE directory\r
1621 #\r
1622 IncludedFile1 = PathClass(IncludedFile, GlobalData.gWorkspace)\r
1623 ErrorCode, ErrorInfo2 = IncludedFile1.Validate()\r
1624 if ErrorCode != 0:\r
1625 EdkLogger.error('parser', ErrorCode, File=self._FileWithError,\r
1626 Line=self._LineIndex + 1, ExtraData=ErrorInfo1 + "\n" + ErrorInfo2)\r
1627\r
1628 self._FileWithError = IncludedFile1\r
1629\r
1630 FromItem = self._Content[self._ContentIndex - 1][0]\r
1631 if self._InSubsection:\r
1632 Owner = self._Content[self._ContentIndex - 1][8]\r
1633 else:\r
1634 Owner = self._Content[self._ContentIndex - 1][0]\r
1635 IncludedFileTable = MetaFileStorage(self._RawTable.DB, IncludedFile1, MODEL_FILE_DSC, False, FromItem=FromItem)\r
1636 Parser = DscParser(IncludedFile1, self._FileType, self._Arch, IncludedFileTable,\r
1637 Owner=Owner, From=FromItem)\r
1638\r
1639 self.IncludedFiles.add (IncludedFile1)\r
1640\r
1641 # set the parser status with current status\r
1642 Parser._SectionName = self._SectionName\r
1643 Parser._SubsectionType = self._SubsectionType\r
1644 Parser._InSubsection = self._InSubsection\r
1645 Parser._SectionType = self._SectionType\r
1646 Parser._Scope = self._Scope\r
1647 Parser._Enabled = self._Enabled\r
1648 # Parse the included file\r
1649 Parser.StartParse()\r
1650 # Insert all records in the table for the included file into dsc file table\r
1651 Records = IncludedFileTable.GetAll()\r
1652 if Records:\r
1653 self._Content[self._ContentIndex:self._ContentIndex] = Records\r
1654 self._Content.pop(self._ContentIndex - 1)\r
1655 self._ValueList = None\r
1656 self._ContentIndex -= 1\r
1657\r
1658 def __ProcessSkuId(self):\r
1659 self._ValueList = [ReplaceMacro(Value, self._Macros, RaiseError=True)\r
1660 for Value in self._ValueList]\r
1661 def __ProcessDefaultStores(self):\r
1662 self._ValueList = [ReplaceMacro(Value, self._Macros, RaiseError=True)\r
1663 for Value in self._ValueList]\r
1664\r
1665 def __ProcessLibraryInstance(self):\r
1666 self._ValueList = [ReplaceMacro(Value, self._Macros) for Value in self._ValueList]\r
1667\r
1668 def __ProcessLibraryClass(self):\r
1669 self._ValueList[1] = ReplaceMacro(self._ValueList[1], self._Macros, RaiseError=True)\r
1670\r
1671 def __ProcessPcd(self):\r
1672 if self._ItemType not in [MODEL_PCD_FEATURE_FLAG, MODEL_PCD_FIXED_AT_BUILD]:\r
1673 self._ValueList[2] = ReplaceMacro(self._ValueList[2], self._Macros, RaiseError=True)\r
1674 return\r
1675\r
1676 ValList, Valid, Index = AnalyzeDscPcd(self._ValueList[2], self._ItemType)\r
1677 if not Valid:\r
1678 if self._ItemType in (MODEL_PCD_DYNAMIC_DEFAULT, MODEL_PCD_DYNAMIC_EX_DEFAULT, MODEL_PCD_FIXED_AT_BUILD, MODEL_PCD_PATCHABLE_IN_MODULE):\r
1679 if ValList[1] != TAB_VOID and StructPattern.match(ValList[1]) is None and ValList[2]:\r
1680 EdkLogger.error('build', FORMAT_INVALID, "Pcd format incorrect. The datum type info should be VOID* or a valid struct name.", File=self._FileWithError,\r
1681 Line=self._LineIndex + 1, ExtraData="%s.%s|%s" % (self._ValueList[0], self._ValueList[1], self._ValueList[2]))\r
1682 EdkLogger.error('build', FORMAT_INVALID, "Pcd format incorrect.", File=self._FileWithError, Line=self._LineIndex + 1,\r
1683 ExtraData="%s.%s|%s" % (self._ValueList[0], self._ValueList[1], self._ValueList[2]))\r
1684 PcdValue = ValList[Index]\r
1685 if PcdValue and "." not in self._ValueList[0]:\r
1686 try:\r
1687 ValList[Index] = ValueExpression(PcdValue, self._Macros)(True)\r
1688 except WrnExpression as Value:\r
1689 ValList[Index] = Value.result\r
1690 except:\r
1691 pass\r
1692\r
1693 if ValList[Index] == 'True':\r
1694 ValList[Index] = '1'\r
1695 if ValList[Index] == 'False':\r
1696 ValList[Index] = '0'\r
1697\r
1698 if (not self._DirectiveEvalStack) or (False not in self._DirectiveEvalStack):\r
1699 GlobalData.gPlatformPcds[TAB_SPLIT.join(self._ValueList[0:2])] = PcdValue\r
1700 self._Symbols[TAB_SPLIT.join(self._ValueList[0:2])] = PcdValue\r
1701 try:\r
1702 self._ValueList[2] = '|'.join(ValList)\r
1703 except Exception:\r
1704 print(ValList)\r
1705\r
1706 def __ProcessComponent(self):\r
1707 self._ValueList[0] = ReplaceMacro(self._ValueList[0], self._Macros)\r
1708\r
1709 def __ProcessSourceOverridePath(self):\r
1710 self._ValueList[0] = ReplaceMacro(self._ValueList[0], self._Macros)\r
1711\r
1712 def __ProcessBuildOption(self):\r
1713 self._ValueList = [ReplaceMacro(Value, self._Macros, RaiseError=False)\r
1714 for Value in self._ValueList]\r
1715\r
1716 _SectionParser = {\r
1717 MODEL_META_DATA_HEADER : _DefineParser,\r
1718 MODEL_EFI_SKU_ID : _SkuIdParser,\r
1719 MODEL_EFI_DEFAULT_STORES : _DefaultStoresParser,\r
1720 MODEL_EFI_LIBRARY_INSTANCE : _LibraryInstanceParser,\r
1721 MODEL_EFI_LIBRARY_CLASS : _LibraryClassParser,\r
1722 MODEL_PCD_FIXED_AT_BUILD : _PcdParser,\r
1723 MODEL_PCD_PATCHABLE_IN_MODULE : _PcdParser,\r
1724 MODEL_PCD_FEATURE_FLAG : _PcdParser,\r
1725 MODEL_PCD_DYNAMIC_DEFAULT : _PcdParser,\r
1726 MODEL_PCD_DYNAMIC_HII : _PcdParser,\r
1727 MODEL_PCD_DYNAMIC_VPD : _PcdParser,\r
1728 MODEL_PCD_DYNAMIC_EX_DEFAULT : _PcdParser,\r
1729 MODEL_PCD_DYNAMIC_EX_HII : _PcdParser,\r
1730 MODEL_PCD_DYNAMIC_EX_VPD : _PcdParser,\r
1731 MODEL_META_DATA_COMPONENT : _ComponentParser,\r
1732 MODEL_META_DATA_COMPONENT_SOURCE_OVERRIDE_PATH : _CompponentSourceOverridePathParser,\r
1733 MODEL_META_DATA_BUILD_OPTION : _BuildOptionParser,\r
1734 MODEL_UNKNOWN : MetaFileParser._Skip,\r
1735 MODEL_META_DATA_USER_EXTENSION : MetaFileParser._SkipUserExtension,\r
1736 MODEL_META_DATA_SECTION_HEADER : MetaFileParser._SectionHeaderParser,\r
1737 MODEL_META_DATA_SUBSECTION_HEADER : _SubsectionHeaderParser,\r
1738 }\r
1739\r
1740## DEC file parser class\r
1741#\r
1742# @param FilePath The path of platform description file\r
1743# @param FileType The raw data of DSC file\r
1744# @param Table Database used to retrieve module/package information\r
1745# @param Macros Macros used for replacement in file\r
1746#\r
1747class DecParser(MetaFileParser):\r
1748 # DEC file supported data types (one type per section)\r
1749 DataType = {\r
1750 TAB_DEC_DEFINES.upper() : MODEL_META_DATA_HEADER,\r
1751 TAB_DSC_DEFINES_DEFINE : MODEL_META_DATA_DEFINE,\r
1752 TAB_INCLUDES.upper() : MODEL_EFI_INCLUDE,\r
1753 TAB_LIBRARY_CLASSES.upper() : MODEL_EFI_LIBRARY_CLASS,\r
1754 TAB_GUIDS.upper() : MODEL_EFI_GUID,\r
1755 TAB_PPIS.upper() : MODEL_EFI_PPI,\r
1756 TAB_PROTOCOLS.upper() : MODEL_EFI_PROTOCOL,\r
1757 TAB_PCDS_FIXED_AT_BUILD_NULL.upper() : MODEL_PCD_FIXED_AT_BUILD,\r
1758 TAB_PCDS_PATCHABLE_IN_MODULE_NULL.upper() : MODEL_PCD_PATCHABLE_IN_MODULE,\r
1759 TAB_PCDS_FEATURE_FLAG_NULL.upper() : MODEL_PCD_FEATURE_FLAG,\r
1760 TAB_PCDS_DYNAMIC_NULL.upper() : MODEL_PCD_DYNAMIC,\r
1761 TAB_PCDS_DYNAMIC_EX_NULL.upper() : MODEL_PCD_DYNAMIC_EX,\r
1762 TAB_USER_EXTENSIONS.upper() : MODEL_META_DATA_USER_EXTENSION,\r
1763 }\r
1764\r
1765 ## Constructor of DecParser\r
1766 #\r
1767 # Initialize object of DecParser\r
1768 #\r
1769 # @param FilePath The path of platform description file\r
1770 # @param FileType The raw data of DSC file\r
1771 # @param Arch Default Arch value for filtering sections\r
1772 # @param Table Database used to retrieve module/package information\r
1773 #\r
1774 def __init__(self, FilePath, FileType, Arch, Table):\r
1775 # prevent re-initialization\r
1776 if hasattr(self, "_Table"):\r
1777 return\r
1778 MetaFileParser.__init__(self, FilePath, FileType, Arch, Table, -1)\r
1779 self._Comments = []\r
1780 self._Version = 0x00010005 # Only EDK2 dec file is supported\r
1781 self._AllPCDs = [] # Only for check duplicate PCD\r
1782 self._AllPcdDict = {}\r
1783\r
1784 self._CurrentStructurePcdName = ""\r
1785 self._include_flag = False\r
1786 self._package_flag = False\r
1787\r
1788 ## Parser starter\r
1789 def Start(self):\r
1790 Content = ''\r
1791 try:\r
1792 Content = open(str(self.MetaFile), 'r').readlines()\r
1793 except:\r
1794 EdkLogger.error("Parser", FILE_READ_FAILURE, ExtraData=self.MetaFile)\r
1795\r
1796 self._DefinesCount = 0\r
1797 for Index in range(0, len(Content)):\r
1798 Line, Comment = CleanString2(Content[Index])\r
1799 self._CurrentLine = Line\r
1800 self._LineIndex = Index\r
1801\r
1802 # save comment for later use\r
1803 if Comment:\r
1804 self._Comments.append((Comment, self._LineIndex + 1))\r
1805 # skip empty line\r
1806 if Line == '':\r
1807 continue\r
1808\r
1809 # section header\r
1810 if Line[0] == TAB_SECTION_START and Line[-1] == TAB_SECTION_END:\r
1811 self._SectionHeaderParser()\r
1812 if self._SectionName == TAB_DEC_DEFINES.upper():\r
1813 self._DefinesCount += 1\r
1814 self._Comments = []\r
1815 continue\r
1816 if self._SectionType == MODEL_UNKNOWN:\r
1817 EdkLogger.error("Parser", FORMAT_INVALID,\r
1818 ""\r
1819 "Not able to determine \"%s\" in which section."%self._CurrentLine,\r
1820 self.MetaFile, self._LineIndex + 1)\r
1821 elif len(self._SectionType) == 0:\r
1822 self._Comments = []\r
1823 continue\r
1824\r
1825 # section content\r
1826 self._ValueList = ['', '', '']\r
1827 self._SectionParser[self._SectionType[0]](self)\r
1828 if self._ValueList is None or self._ItemType == MODEL_META_DATA_DEFINE:\r
1829 self._ItemType = -1\r
1830 self._Comments = []\r
1831 continue\r
1832\r
1833 #\r
1834 # Model, Value1, Value2, Value3, Arch, BelongsToItem=-1, LineBegin=-1,\r
1835 # ColumnBegin=-1, LineEnd=-1, ColumnEnd=-1, FeatureFlag='', Enabled=-1\r
1836 #\r
1837 for Arch, ModuleType, Type in self._Scope:\r
1838 self._LastItem = self._Store(\r
1839 Type,\r
1840 self._ValueList[0],\r
1841 self._ValueList[1],\r
1842 self._ValueList[2],\r
1843 Arch,\r
1844 ModuleType,\r
1845 self._Owner[-1],\r
1846 self._LineIndex + 1,\r
1847 - 1,\r
1848 self._LineIndex + 1,\r
1849 - 1,\r
1850 0\r
1851 )\r
1852 for Comment, LineNo in self._Comments:\r
1853 self._Store(\r
1854 MODEL_META_DATA_COMMENT,\r
1855 Comment,\r
1856 self._ValueList[0],\r
1857 self._ValueList[1],\r
1858 Arch,\r
1859 ModuleType,\r
1860 self._LastItem,\r
1861 LineNo,\r
1862 - 1,\r
1863 LineNo,\r
1864 - 1,\r
1865 0\r
1866 )\r
1867 self._Comments = []\r
1868 if self._DefinesCount > 1:\r
1869 EdkLogger.error('Parser', FORMAT_INVALID, 'Multiple [Defines] section is exist.', self.MetaFile )\r
1870 if self._DefinesCount == 0:\r
1871 EdkLogger.error('Parser', FORMAT_INVALID, 'No [Defines] section exist.', self.MetaFile)\r
1872 self._Done()\r
1873\r
1874\r
1875 ## Section header parser\r
1876 #\r
1877 # The section header is always in following format:\r
1878 #\r
1879 # [section_name.arch<.platform|module_type>]\r
1880 #\r
1881 def _SectionHeaderParser(self):\r
1882 self._Scope = []\r
1883 self._SectionName = ''\r
1884 self._SectionType = []\r
1885 ArchList = set()\r
1886 PrivateList = set()\r
1887 Line = re.sub(',[\s]*', TAB_COMMA_SPLIT, self._CurrentLine)\r
1888 for Item in Line[1:-1].split(TAB_COMMA_SPLIT):\r
1889 if Item == '':\r
1890 EdkLogger.error("Parser", FORMAT_UNKNOWN_ERROR,\r
1891 "section name can NOT be empty or incorrectly use separator comma",\r
1892 self.MetaFile, self._LineIndex + 1, self._CurrentLine)\r
1893 ItemList = Item.split(TAB_SPLIT)\r
1894\r
1895 # different types of PCD are permissible in one section\r
1896 self._SectionName = ItemList[0].upper()\r
1897 if self._SectionName == TAB_DEC_DEFINES.upper() and (len(ItemList) > 1 or len(Line.split(TAB_COMMA_SPLIT)) > 1):\r
1898 EdkLogger.error("Parser", FORMAT_INVALID, "Defines section format is invalid",\r
1899 self.MetaFile, self._LineIndex + 1, self._CurrentLine)\r
1900 if self._SectionName in self.DataType:\r
1901 if self.DataType[self._SectionName] not in self._SectionType:\r
1902 self._SectionType.append(self.DataType[self._SectionName])\r
1903 else:\r
1904 EdkLogger.error("Parser", FORMAT_UNKNOWN_ERROR, "%s is not a valid section name" % Item,\r
1905 self.MetaFile, self._LineIndex + 1, self._CurrentLine)\r
1906\r
1907 if MODEL_PCD_FEATURE_FLAG in self._SectionType and len(self._SectionType) > 1:\r
1908 EdkLogger.error(\r
1909 'Parser',\r
1910 FORMAT_INVALID,\r
1911 "%s must not be in the same section of other types of PCD" % TAB_PCDS_FEATURE_FLAG_NULL,\r
1912 File=self.MetaFile,\r
1913 Line=self._LineIndex + 1,\r
1914 ExtraData=self._CurrentLine\r
1915 )\r
1916 # S1 is always Arch\r
1917 if len(ItemList) > 1:\r
1918 S1 = ItemList[1].upper()\r
1919 else:\r
1920 S1 = TAB_ARCH_COMMON\r
1921 ArchList.add(S1)\r
1922 # S2 may be Platform or ModuleType\r
1923 if len(ItemList) > 2:\r
1924 S2 = ItemList[2].upper()\r
1925 # only Includes, GUIDs, PPIs, Protocols section have Private tag\r
1926 if self._SectionName in [TAB_INCLUDES.upper(), TAB_GUIDS.upper(), TAB_PROTOCOLS.upper(), TAB_PPIS.upper()]:\r
1927 if S2 != 'PRIVATE':\r
1928 EdkLogger.error("Parser", FORMAT_INVALID, 'Please use keyword "Private" as section tag modifier.',\r
1929 File=self.MetaFile, Line=self._LineIndex + 1, ExtraData=self._CurrentLine)\r
1930 else:\r
1931 S2 = TAB_COMMON\r
1932 PrivateList.add(S2)\r
1933 if [S1, S2, self.DataType[self._SectionName]] not in self._Scope:\r
1934 self._Scope.append([S1, S2, self.DataType[self._SectionName]])\r
1935\r
1936 # 'COMMON' must not be used with specific ARCHs at the same section\r
1937 if TAB_ARCH_COMMON in ArchList and len(ArchList) > 1:\r
1938 EdkLogger.error('Parser', FORMAT_INVALID, "'common' ARCH must not be used with specific ARCHs",\r
1939 File=self.MetaFile, Line=self._LineIndex + 1, ExtraData=self._CurrentLine)\r
1940\r
1941 # It is not permissible to mix section tags without the Private attribute with section tags with the Private attribute\r
1942 if TAB_COMMON in PrivateList and len(PrivateList) > 1:\r
1943 EdkLogger.error('Parser', FORMAT_INVALID, "Can't mix section tags without the Private attribute with section tags with the Private attribute",\r
1944 File=self.MetaFile, Line=self._LineIndex + 1, ExtraData=self._CurrentLine)\r
1945\r
1946 ## [guids], [ppis] and [protocols] section parser\r
1947 @ParseMacro\r
1948 def _GuidParser(self):\r
1949 TokenList = GetSplitValueList(self._CurrentLine, TAB_EQUAL_SPLIT, 1)\r
1950 if len(TokenList) < 2:\r
1951 EdkLogger.error('Parser', FORMAT_INVALID, "No GUID name or value specified",\r
1952 ExtraData=self._CurrentLine + " (<CName> = <GuidValueInCFormat>)",\r
1953 File=self.MetaFile, Line=self._LineIndex + 1)\r
1954 if TokenList[0] == '':\r
1955 EdkLogger.error('Parser', FORMAT_INVALID, "No GUID name specified",\r
1956 ExtraData=self._CurrentLine + " (<CName> = <GuidValueInCFormat>)",\r
1957 File=self.MetaFile, Line=self._LineIndex + 1)\r
1958 if TokenList[1] == '':\r
1959 EdkLogger.error('Parser', FORMAT_INVALID, "No GUID value specified",\r
1960 ExtraData=self._CurrentLine + " (<CName> = <GuidValueInCFormat>)",\r
1961 File=self.MetaFile, Line=self._LineIndex + 1)\r
1962 if TokenList[1][0] != '{' or TokenList[1][-1] != '}' or GuidStructureStringToGuidString(TokenList[1]) == '':\r
1963 EdkLogger.error('Parser', FORMAT_INVALID, "Invalid GUID value format",\r
1964 ExtraData=self._CurrentLine + \\r
1965 " (<CName> = <GuidValueInCFormat:{8,4,4,{2,2,2,2,2,2,2,2}}>)",\r
1966 File=self.MetaFile, Line=self._LineIndex + 1)\r
1967 self._ValueList[0] = TokenList[0]\r
1968 self._ValueList[1] = TokenList[1]\r
1969 if self._ValueList[0] not in self._GuidDict:\r
1970 self._GuidDict[self._ValueList[0]] = self._ValueList[1]\r
1971\r
1972 def ParsePcdName(self,namelist):\r
1973 if "[" in namelist[1]:\r
1974 pcdname = namelist[1][:namelist[1].index("[")]\r
1975 arrayindex = namelist[1][namelist[1].index("["):]\r
1976 namelist[1] = pcdname\r
1977 if len(namelist) == 2:\r
1978 namelist.append(arrayindex)\r
1979 else:\r
1980 namelist[2] = ".".join((arrayindex,namelist[2]))\r
1981 return namelist\r
1982\r
1983 ## PCD sections parser\r
1984 #\r
1985 # [PcdsFixedAtBuild]\r
1986 # [PcdsPatchableInModule]\r
1987 # [PcdsFeatureFlag]\r
1988 # [PcdsDynamicEx\r
1989 # [PcdsDynamic]\r
1990 #\r
1991 @ParseMacro\r
1992 def _PcdParser(self):\r
1993 if self._CurrentStructurePcdName:\r
1994 self._ValueList[0] = self._CurrentStructurePcdName\r
1995\r
1996 if "|" not in self._CurrentLine:\r
1997 if "<HeaderFiles>" == self._CurrentLine:\r
1998 self._include_flag = True\r
1999 self._package_flag = False\r
2000 self._ValueList = None\r
2001 return\r
2002 if "<Packages>" == self._CurrentLine:\r
2003 self._package_flag = True\r
2004 self._ValueList = None\r
2005 self._include_flag = False\r
2006 return\r
2007\r
2008 if self._include_flag:\r
2009 self._ValueList[1] = "<HeaderFiles>_" + md5(self._CurrentLine).hexdigest()\r
2010 self._ValueList[2] = self._CurrentLine\r
2011 if self._package_flag and "}" != self._CurrentLine:\r
2012 self._ValueList[1] = "<Packages>_" + md5(self._CurrentLine).hexdigest()\r
2013 self._ValueList[2] = self._CurrentLine\r
2014 if self._CurrentLine == "}":\r
2015 self._package_flag = False\r
2016 self._include_flag = False\r
2017 self._ValueList = None\r
2018 return\r
2019 else:\r
2020 PcdTockens = self._CurrentLine.split(TAB_VALUE_SPLIT)\r
2021 PcdNames = self.ParsePcdName(PcdTockens[0].split(TAB_SPLIT))\r
2022 if len(PcdNames) == 2:\r
2023 if PcdNames[1].strip().endswith("]"):\r
2024 PcdName = PcdNames[1][:PcdNames[1].index('[')]\r
2025 Index = PcdNames[1][PcdNames[1].index('['):]\r
2026 self._ValueList[0] = TAB_SPLIT.join((PcdNames[0],PcdName))\r
2027 self._ValueList[1] = Index\r
2028 self._ValueList[2] = PcdTockens[1]\r
2029 else:\r
2030 self._CurrentStructurePcdName = ""\r
2031 else:\r
2032 if self._CurrentStructurePcdName != TAB_SPLIT.join(PcdNames[:2]):\r
2033 EdkLogger.error('Parser', FORMAT_INVALID, "Pcd Name does not match: %s and %s " % (self._CurrentStructurePcdName, TAB_SPLIT.join(PcdNames[:2])),\r
2034 File=self.MetaFile, Line=self._LineIndex + 1)\r
2035 self._ValueList[1] = TAB_SPLIT.join(PcdNames[2:])\r
2036 self._ValueList[2] = PcdTockens[1]\r
2037 if not self._CurrentStructurePcdName:\r
2038 TokenList = GetSplitValueList(self._CurrentLine, TAB_VALUE_SPLIT, 1)\r
2039 self._ValueList[0:1] = GetSplitValueList(TokenList[0], TAB_SPLIT)\r
2040 ValueRe = re.compile(r'^[a-zA-Z_][a-zA-Z0-9_]*')\r
2041 # check PCD information\r
2042 if self._ValueList[0] == '' or self._ValueList[1] == '':\r
2043 EdkLogger.error('Parser', FORMAT_INVALID, "No token space GUID or PCD name specified",\r
2044 ExtraData=self._CurrentLine + \\r
2045 " (<TokenSpaceGuidCName>.<PcdCName>|<DefaultValue>|<DatumType>|<Token>)",\r
2046 File=self.MetaFile, Line=self._LineIndex + 1)\r
2047 # check format of token space GUID CName\r
2048 if not ValueRe.match(self._ValueList[0]):\r
2049 EdkLogger.error('Parser', FORMAT_INVALID, "The format of the token space GUID CName is invalid. The correct format is '(a-zA-Z_)[a-zA-Z0-9_]*'",\r
2050 ExtraData=self._CurrentLine + \\r
2051 " (<TokenSpaceGuidCName>.<PcdCName>|<DefaultValue>|<DatumType>|<Token>)",\r
2052 File=self.MetaFile, Line=self._LineIndex + 1)\r
2053 # check format of PCD CName\r
2054 if not ValueRe.match(self._ValueList[1]):\r
2055 EdkLogger.error('Parser', FORMAT_INVALID, "The format of the PCD CName is invalid. The correct format is '(a-zA-Z_)[a-zA-Z0-9_]*'",\r
2056 ExtraData=self._CurrentLine + \\r
2057 " (<TokenSpaceGuidCName>.<PcdCName>|<DefaultValue>|<DatumType>|<Token>)",\r
2058 File=self.MetaFile, Line=self._LineIndex + 1)\r
2059 # check PCD datum information\r
2060 if len(TokenList) < 2 or TokenList[1] == '':\r
2061 EdkLogger.error('Parser', FORMAT_INVALID, "No PCD Datum information given",\r
2062 ExtraData=self._CurrentLine + \\r
2063 " (<TokenSpaceGuidCName>.<PcdCName>|<DefaultValue>|<DatumType>|<Token>)",\r
2064 File=self.MetaFile, Line=self._LineIndex + 1)\r
2065\r
2066\r
2067 ValueRe = re.compile(r'^\s*L?\".*\|.*\"')\r
2068 PtrValue = ValueRe.findall(TokenList[1])\r
2069\r
2070 # Has VOID* type string, may contain "|" character in the string.\r
2071 if len(PtrValue) != 0:\r
2072 ptrValueList = re.sub(ValueRe, '', TokenList[1])\r
2073 ValueList = AnalyzePcdExpression(ptrValueList)\r
2074 ValueList[0] = PtrValue[0]\r
2075 else:\r
2076 ValueList = AnalyzePcdExpression(TokenList[1])\r
2077\r
2078\r
2079 # check if there's enough datum information given\r
2080 if len(ValueList) != 3:\r
2081 EdkLogger.error('Parser', FORMAT_INVALID, "Invalid PCD Datum information given",\r
2082 ExtraData=self._CurrentLine + \\r
2083 " (<TokenSpaceGuidCName>.<PcdCName>|<DefaultValue>|<DatumType>|<Token>)",\r
2084 File=self.MetaFile, Line=self._LineIndex + 1)\r
2085 # check default value\r
2086 if ValueList[0] == '':\r
2087 EdkLogger.error('Parser', FORMAT_INVALID, "Missing DefaultValue in PCD Datum information",\r
2088 ExtraData=self._CurrentLine + \\r
2089 " (<TokenSpaceGuidCName>.<PcdCName>|<DefaultValue>|<DatumType>|<Token>)",\r
2090 File=self.MetaFile, Line=self._LineIndex + 1)\r
2091 # check datum type\r
2092 if ValueList[1] == '':\r
2093 EdkLogger.error('Parser', FORMAT_INVALID, "Missing DatumType in PCD Datum information",\r
2094 ExtraData=self._CurrentLine + \\r
2095 " (<TokenSpaceGuidCName>.<PcdCName>|<DefaultValue>|<DatumType>|<Token>)",\r
2096 File=self.MetaFile, Line=self._LineIndex + 1)\r
2097 # check token of the PCD\r
2098 if ValueList[2] == '':\r
2099 EdkLogger.error('Parser', FORMAT_INVALID, "Missing Token in PCD Datum information",\r
2100 ExtraData=self._CurrentLine + \\r
2101 " (<TokenSpaceGuidCName>.<PcdCName>|<DefaultValue>|<DatumType>|<Token>)",\r
2102 File=self.MetaFile, Line=self._LineIndex + 1)\r
2103\r
2104 PcdValue = ValueList[0]\r
2105 if PcdValue:\r
2106 try:\r
2107 self._GuidDict.update(self._AllPcdDict)\r
2108 ValueList[0] = ValueExpressionEx(ValueList[0], ValueList[1], self._GuidDict)(True)\r
2109 except BadExpression as Value:\r
2110 EdkLogger.error('Parser', FORMAT_INVALID, Value, ExtraData=self._CurrentLine, File=self.MetaFile, Line=self._LineIndex + 1)\r
2111 # check format of default value against the datum type\r
2112 IsValid, Cause = CheckPcdDatum(ValueList[1], ValueList[0])\r
2113 if not IsValid:\r
2114 EdkLogger.error('Parser', FORMAT_INVALID, Cause, ExtraData=self._CurrentLine,\r
2115 File=self.MetaFile, Line=self._LineIndex + 1)\r
2116\r
2117 if Cause == "StructurePcd":\r
2118 self._CurrentStructurePcdName = TAB_SPLIT.join(self._ValueList[0:2])\r
2119 self._ValueList[0] = self._CurrentStructurePcdName\r
2120 self._ValueList[1] = ValueList[1].strip()\r
2121\r
2122 if ValueList[0] in ['True', 'true', 'TRUE']:\r
2123 ValueList[0] = '1'\r
2124 elif ValueList[0] in ['False', 'false', 'FALSE']:\r
2125 ValueList[0] = '0'\r
2126\r
2127 # check for duplicate PCD definition\r
2128 if (self._Scope[0], self._ValueList[0], self._ValueList[1]) in self._AllPCDs:\r
2129 EdkLogger.error('Parser', FORMAT_INVALID,\r
2130 "The same PCD name and GUID have been already defined",\r
2131 ExtraData=self._CurrentLine, File=self.MetaFile, Line=self._LineIndex + 1)\r
2132 else:\r
2133 self._AllPCDs.append((self._Scope[0], self._ValueList[0], self._ValueList[1]))\r
2134 self._AllPcdDict[TAB_SPLIT.join(self._ValueList[0:2])] = ValueList[0]\r
2135\r
2136 self._ValueList[2] = ValueList[0].strip() + '|' + ValueList[1].strip() + '|' + ValueList[2].strip()\r
2137\r
2138 _SectionParser = {\r
2139 MODEL_META_DATA_HEADER : MetaFileParser._DefineParser,\r
2140 MODEL_EFI_INCLUDE : MetaFileParser._PathParser,\r
2141 MODEL_EFI_LIBRARY_CLASS : MetaFileParser._PathParser,\r
2142 MODEL_EFI_GUID : _GuidParser,\r
2143 MODEL_EFI_PPI : _GuidParser,\r
2144 MODEL_EFI_PROTOCOL : _GuidParser,\r
2145 MODEL_PCD_FIXED_AT_BUILD : _PcdParser,\r
2146 MODEL_PCD_PATCHABLE_IN_MODULE : _PcdParser,\r
2147 MODEL_PCD_FEATURE_FLAG : _PcdParser,\r
2148 MODEL_PCD_DYNAMIC : _PcdParser,\r
2149 MODEL_PCD_DYNAMIC_EX : _PcdParser,\r
2150 MODEL_UNKNOWN : MetaFileParser._Skip,\r
2151 MODEL_META_DATA_USER_EXTENSION : MetaFileParser._SkipUserExtension,\r
2152 }\r
2153\r
2154##\r
2155#\r
2156# This acts like the main() function for the script, unless it is 'import'ed into another\r
2157# script.\r
2158#\r
2159if __name__ == '__main__':\r
2160 pass\r
2161\r
EFI Development Kit II mirror for PVE