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