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