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