]> git.proxmox.com Git - mirror_edk2.git/blame - BaseTools/Source/Python/UPT/Parser/DecParser.py
projects / mirror_edk2.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
MdeModulePkg: Change BootLogoEnableLogo use INTN for minus value
[mirror_edk2.git] / BaseTools / Source / Python / UPT / Parser / DecParser.py
CommitLineData
4234283c
LG		 1## @file\r
2# This file is used to parse DEC file. It will consumed by DecParser\r
3#\r
421ccda3 4# Copyright (c) 2011 - 2014, Intel Corporation. All rights reserved.<BR>\r
4234283c
LG		 5#\r
6# This program and the accompanying materials are licensed and made available \r
7# under the terms and conditions of the BSD License which accompanies this \r
8# 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
14DecParser\r
15'''\r
16## Import modules\r
17#\r
18import Logger.Log as Logger\r
19from Logger.ToolError import FILE_PARSE_FAILURE\r
20from Logger.ToolError import FILE_OPEN_FAILURE\r
21from Logger import StringTable as ST\r
2bc3256c 22from Logger.ToolError import FORMAT_INVALID\r
4234283c
LG		 23\r
24import Library.DataType as DT\r
25from Library.ParserValidate import IsValidToken\r
26from Library.ParserValidate import IsValidPath\r
27from Library.ParserValidate import IsValidCFormatGuid\r
28from Library.ParserValidate import IsValidIdString\r
29from Library.ParserValidate import IsValidUserId\r
30from Library.ParserValidate import IsValidArch\r
31from Library.ParserValidate import IsValidWord\r
32from Parser.DecParserMisc import TOOL_NAME\r
33from Parser.DecParserMisc import CleanString\r
34from Parser.DecParserMisc import IsValidPcdDatum\r
35from Parser.DecParserMisc import ParserHelper\r
36from Parser.DecParserMisc import StripRoot\r
37from Parser.DecParserMisc import VERSION_PATTERN\r
38from Parser.DecParserMisc import CVAR_PATTERN\r
39from Parser.DecParserMisc import PCD_TOKEN_PATTERN\r
40from Parser.DecParserMisc import MACRO_PATTERN\r
41from Parser.DecParserMisc import FileContent\r
42from Object.Parser.DecObject import _DecComments\r
43from Object.Parser.DecObject import DecDefineObject\r
44from Object.Parser.DecObject import DecDefineItemObject\r
45from Object.Parser.DecObject import DecIncludeObject\r
46from Object.Parser.DecObject import DecIncludeItemObject\r
47from Object.Parser.DecObject import DecLibraryclassObject\r
48from Object.Parser.DecObject import DecLibraryclassItemObject\r
49from Object.Parser.DecObject import DecGuidObject\r
50from Object.Parser.DecObject import DecPpiObject\r
51from Object.Parser.DecObject import DecProtocolObject\r
52from Object.Parser.DecObject import DecGuidItemObject\r
53from Object.Parser.DecObject import DecUserExtensionObject\r
54from Object.Parser.DecObject import DecUserExtensionItemObject\r
55from Object.Parser.DecObject import DecPcdObject\r
56from Object.Parser.DecObject import DecPcdItemObject\r
57from Library.Misc import GuidStructureStringToGuidString\r
58from Library.Misc import CheckGuidRegFormat\r
59from Library.String import ReplaceMacro\r
60from Library.String import GetSplitValueList\r
61from Library.String import gMACRO_PATTERN\r
62from Library.String import ConvertSpecialChar\r
421ccda3 63from Library.CommentParsing import ParsePcdErrorCode\r
4234283c
LG		 64\r
65##\r
66# _DecBase class for parsing\r
67#\r
68class _DecBase:\r
69 def __init__(self, RawData):\r
70 self._RawData = RawData\r
71 self._ItemDict = {}\r
72 self._LocalMacro = {}\r
73 #\r
74 # Data parsed by 'self' are saved to this object\r
75 #\r
76 self.ItemObject = None\r
77 \r
78 def GetDataObject(self):\r
79 return self.ItemObject\r
80 \r
421ccda3
HC		 81 def GetLocalMacro(self):\r
82 return self._LocalMacro\r
83 \r
4234283c
LG		 84 ## BlockStart\r
85 #\r
86 # Called if a new section starts\r
87 #\r
88 def BlockStart(self):\r
89 self._LocalMacro = {}\r
90 \r
91 ## _CheckReDefine\r
92 #\r
93 # @param Key: to be checked if multi-defined\r
94 # @param Scope: Format: [[SectionName, Arch], ...]. \r
95 # If scope is none, use global scope\r
96 #\r
97 def _CheckReDefine(self, Key, Scope = None):\r
98 if not Scope:\r
99 Scope = self._RawData.CurrentScope\r
100 return\r
101 \r
102 SecArch = []\r
103 #\r
104 # Copy scope to SecArch, avoid Scope be changed outside\r
105 #\r
106 SecArch[0:1] = Scope[:]\r
107 if Key not in self._ItemDict:\r
108 self._ItemDict[Key] = [[SecArch, self._RawData.LineIndex]]\r
109 return\r
110 \r
111 for Value in self._ItemDict[Key]:\r
112 for SubValue in Scope:\r
113 #\r
114 # If current is common section\r
115 #\r
116 if SubValue[-1] == 'COMMON':\r
117 for Other in Value[0]:\r
118 # Key in common cannot be redefined in other arches\r
119 # [:-1] means stripping arch info\r
120 if Other[:-1] == SubValue[:-1]:\r
121 self._LoggerError(ST.ERR_DECPARSE_REDEFINE % (Key, Value[1]))\r
122 return\r
123 continue\r
124 CommonScope = []\r
125 CommonScope[0:1] = SubValue\r
126 CommonScope[-1] = 'COMMON'\r
127 #\r
128 # Cannot be redefined if this key already defined in COMMON Or defined in same arch\r
129 #\r
130 if SubValue in Value[0] or CommonScope in Value[0]:\r
131 self._LoggerError(ST.ERR_DECPARSE_REDEFINE % (Key, Value[1]))\r
132 return\r
133 self._ItemDict[Key].append([SecArch, self._RawData.LineIndex])\r
134 \r
135 ## CheckRequiredFields\r
136 # Some sections need to check if some fields exist, define section for example\r
137 # Derived class can re-implement, top parser will call this function after all parsing done\r
138 # \r
139 def CheckRequiredFields(self):\r
140 if self._RawData:\r
141 pass\r
142 return True\r
143 \r
144 ## IsItemRequired\r
145 # In DEC spec, sections must have at least one statement except user \r
146 # extension.\r
147 # For example: "[guids" [<attribs>] "]" <EOL> <statements>+\r
148 # sub class can override this method to indicate if statement is a must.\r
149 #\r
150 def _IsStatementRequired(self):\r
151 if self._RawData:\r
152 pass\r
153 return False\r
154 \r
155 def _LoggerError(self, ErrorString):\r
156 Logger.Error(TOOL_NAME, FILE_PARSE_FAILURE, File=self._RawData.Filename, \r
157 Line = self._RawData.LineIndex,\r
158 ExtraData=ErrorString + ST.ERR_DECPARSE_LINE % self._RawData.CurrentLine)\r
159 \r
160 def _ReplaceMacro(self, String):\r
161 if gMACRO_PATTERN.findall(String):\r
162 String = ReplaceMacro(String, self._LocalMacro, False,\r
163 FileName = self._RawData.Filename,\r
164 Line = ['', self._RawData.LineIndex])\r
165 String = ReplaceMacro(String, self._RawData.Macros, False,\r
166 FileName = self._RawData.Filename,\r
167 Line = ['', self._RawData.LineIndex])\r
168 MacroUsed = gMACRO_PATTERN.findall(String)\r
169 if MacroUsed:\r
170 Logger.Error(TOOL_NAME, FILE_PARSE_FAILURE,\r
171 File=self._RawData.Filename, \r
172 Line = self._RawData.LineIndex,\r
173 ExtraData = ST.ERR_DECPARSE_MACRO_RESOLVE % (str(MacroUsed), String))\r
174 return String\r
175 \r
176 def _MacroParser(self, String):\r
177 TokenList = GetSplitValueList(String, ' ', 1)\r
178 if len(TokenList) < 2 or TokenList[1] == '':\r
179 self._LoggerError(ST.ERR_DECPARSE_MACRO_PAIR)\r
180\r
181 TokenList = GetSplitValueList(TokenList[1], DT.TAB_EQUAL_SPLIT, 1)\r
182 if TokenList[0] == '':\r
183 self._LoggerError(ST.ERR_DECPARSE_MACRO_NAME)\r
184 elif not IsValidToken(MACRO_PATTERN, TokenList[0]):\r
185 self._LoggerError(ST.ERR_DECPARSE_MACRO_NAME_UPPER % TokenList[0])\r
186 \r
187 if len(TokenList) == 1:\r
188 self._LocalMacro[TokenList[0]] = ''\r
189 else:\r
190 self._LocalMacro[TokenList[0]] = self._ReplaceMacro(TokenList[1])\r
421ccda3 191\r
4234283c
LG		 192 ## _ParseItem\r
193 #\r
194 # Parse specified item, this function must be derived by subclass\r
195 #\r
196 def _ParseItem(self):\r
197 if self._RawData:\r
198 pass\r
199 #\r
200 # Should never be called\r
201 #\r
202 return None\r
203\r
204 \r
205 ## _TailCommentStrategy\r
206 #\r
207 # This function can be derived to parse tail comment\r
208 # default is it will not consume any lines\r
209 #\r
210 # @param Comment: Comment of current line\r
211 #\r
212 def _TailCommentStrategy(self, Comment):\r
213 if Comment:\r
214 pass\r
215 if self._RawData:\r
216 pass\r
217 return False\r
218 \r
219 ## _StopCurrentParsing\r
220 #\r
221 # Called in Parse if current parsing should be stopped when encounter some\r
222 # keyword\r
223 # Default is section start and end\r
224 #\r
225 # @param Line: Current line\r
226 #\r
227 def _StopCurrentParsing(self, Line):\r
228 if self._RawData:\r
229 pass\r
230 return Line[0] == DT.TAB_SECTION_START and Line[-1] == DT.TAB_SECTION_END\r
231 \r
232 ## _TryBackSlash\r
233 #\r
234 # Split comment and DEC content, concatenate lines if end of char is '\'\r
235 #\r
236 # @param ProcessedLine: ProcessedLine line\r
237 # @param ProcessedComments: ProcessedComments line\r
238 #\r
239 def _TryBackSlash(self, ProcessedLine, ProcessedComments):\r
240 CatLine = ''\r
241 Comment = ''\r
242 Line = ProcessedLine\r
243 CommentList = ProcessedComments\r
244 while not self._RawData.IsEndOfFile():\r
245 if Line == '':\r
246 self._LoggerError(ST.ERR_DECPARSE_BACKSLASH_EMPTY)\r
247 break\r
248 \r
249 if Comment:\r
250 CommentList.append((Comment, self._RawData.LineIndex))\r
251 if Line[-1] != DT.TAB_SLASH:\r
252 CatLine += Line\r
253 break\r
254 elif len(Line) < 2 or Line[-2] != ' ':\r
255 self._LoggerError(ST.ERR_DECPARSE_BACKSLASH)\r
256 else:\r
257 CatLine += Line[:-1]\r
258 Line, Comment = CleanString(self._RawData.GetNextLine())\r
259 #\r
260 # Reach end of content\r
261 #\r
262 if self._RawData.IsEndOfFile():\r
263 if not CatLine:\r
264 if ProcessedLine[-1] == DT.TAB_SLASH:\r
265 self._LoggerError(ST.ERR_DECPARSE_BACKSLASH_EMPTY)\r
266 CatLine = ProcessedLine\r
267 else:\r
268 if not Line or Line[-1] == DT.TAB_SLASH:\r
269 self._LoggerError(ST.ERR_DECPARSE_BACKSLASH_EMPTY)\r
270 CatLine += Line\r
271 \r
272 self._RawData.CurrentLine = self._ReplaceMacro(CatLine)\r
273 return CatLine, CommentList\r
274 \r
275 ## Parse\r
276 # This is a template method in which other member functions which might \r
277 # override by sub class are called. It is responsible for reading file \r
278 # line by line, and call other member functions to parse. This function\r
279 # should not be re-implement by sub class.\r
280 #\r
281 def Parse(self):\r
282 HeadComments = []\r
283 TailComments = []\r
284 \r
285 #======================================================================\r
286 # CurComments may pointer to HeadComments or TailComments\r
287 #======================================================================\r
288 CurComments = HeadComments\r
289 CurObj = None\r
290 ItemNum = 0\r
291 FromBuf = False\r
292 \r
293 #======================================================================\r
294 # Used to report error information if empty section found\r
295 #======================================================================\r
296 Index = self._RawData.LineIndex\r
297 LineStr = self._RawData.CurrentLine\r
298 while not self._RawData.IsEndOfFile() or self._RawData.NextLine:\r
299 if self._RawData.NextLine:\r
300 #==============================================================\r
301 # Have processed line in buffer\r
302 #==============================================================\r
303 Line = self._RawData.NextLine\r
304 HeadComments.extend(self._RawData.HeadComment)\r
305 TailComments.extend(self._RawData.TailComment)\r
306 self._RawData.ResetNext()\r
307 Comment = ''\r
308 FromBuf = True\r
309 else:\r
310 #==============================================================\r
311 # No line in buffer, read next line\r
312 #==============================================================\r
313 Line, Comment = CleanString(self._RawData.GetNextLine())\r
314 FromBuf = False\r
315 if Line:\r
316 if not FromBuf and CurObj and TailComments:\r
317 #==========================================================\r
318 # Set tail comments to previous statement if not empty.\r
319 #==========================================================\r
320 CurObj.SetTailComment(CurObj.GetTailComment()+TailComments)\r
321 \r
322 if not FromBuf:\r
323 del TailComments[:]\r
324 CurComments = TailComments\r
325 Comments = []\r
326 if Comment:\r
327 Comments = [(Comment, self._RawData.LineIndex)]\r
328 \r
329 #==============================================================\r
330 # Try if last char of line has backslash\r
331 #==============================================================\r
332 Line, Comments = self._TryBackSlash(Line, Comments)\r
333 CurComments.extend(Comments)\r
334 \r
335 #==============================================================\r
336 # Macro found\r
337 #==============================================================\r
338 if Line.startswith('DEFINE '):\r
339 self._MacroParser(Line)\r
340 del HeadComments[:]\r
341 del TailComments[:]\r
342 CurComments = HeadComments\r
343 continue\r
344 \r
345 if self._StopCurrentParsing(Line):\r
346 #==========================================================\r
347 # This line does not belong to this parse,\r
348 # Save it, can be used by next parse\r
349 #==========================================================\r
350 self._RawData.SetNext(Line, HeadComments, TailComments)\r
351 break\r
352 \r
353 Obj = self._ParseItem()\r
354 ItemNum += 1\r
355 if Obj:\r
356 Obj.SetHeadComment(Obj.GetHeadComment()+HeadComments)\r
357 Obj.SetTailComment(Obj.GetTailComment()+TailComments)\r
358 del HeadComments[:]\r
359 del TailComments[:]\r
360 CurObj = Obj\r
361 else:\r
362 CurObj = None\r
363 else:\r
364 if id(CurComments) == id(TailComments):\r
365 #==========================================================\r
366 # Check if this comment belongs to tail comment\r
367 #==========================================================\r
368 if not self._TailCommentStrategy(Comment):\r
369 CurComments = HeadComments\r
370\r
371 if Comment:\r
372 CurComments.append(((Comment, self._RawData.LineIndex)))\r
373 else:\r
374 del CurComments[:]\r
375 \r
376 if self._IsStatementRequired() and ItemNum == 0:\r
377 Logger.Error(\r
378 TOOL_NAME, FILE_PARSE_FAILURE,\r
379 File=self._RawData.Filename,\r
380 Line=Index,\r
381 ExtraData=ST.ERR_DECPARSE_STATEMENT_EMPTY % LineStr\r
382 )\r
383\r
384## _DecDefine\r
385# Parse define section\r
386#\r
387class _DecDefine(_DecBase):\r
388 def __init__(self, RawData):\r
389 _DecBase.__init__(self, RawData)\r
390 self.ItemObject = DecDefineObject(RawData.Filename)\r
391 self._LocalMacro = self._RawData.Macros\r
392 self._DefSecNum = 0\r
393 \r
394 #\r
395 # Each field has a function to validate\r
396 #\r
397 self.DefineValidation = {\r
398 DT.TAB_DEC_DEFINES_DEC_SPECIFICATION : self._SetDecSpecification,\r
399 DT.TAB_DEC_DEFINES_PACKAGE_NAME : self._SetPackageName,\r
400 DT.TAB_DEC_DEFINES_PACKAGE_GUID : self._SetPackageGuid,\r
401 DT.TAB_DEC_DEFINES_PACKAGE_VERSION : self._SetPackageVersion,\r
421ccda3 402 DT.TAB_DEC_DEFINES_PKG_UNI_FILE : self._SetPackageUni,\r
4234283c
LG		 403 }\r
404 \r
405 def BlockStart(self):\r
406 self._DefSecNum += 1\r
407 if self._DefSecNum > 1:\r
408 self._LoggerError(ST.ERR_DECPARSE_DEFINE_MULTISEC)\r
409 \r
410 ## CheckRequiredFields\r
411 #\r
412 # Check required fields: DEC_SPECIFICATION, PACKAGE_NAME\r
413 # PACKAGE_GUID, PACKAGE_VERSION\r
414 #\r
415 def CheckRequiredFields(self):\r
416 Ret = False\r
417 if self.ItemObject.GetPackageSpecification() == '':\r
418 Logger.Error(TOOL_NAME, FILE_PARSE_FAILURE, File=self._RawData.Filename, \r
419 ExtraData=ST.ERR_DECPARSE_DEFINE_REQUIRED % DT.TAB_DEC_DEFINES_DEC_SPECIFICATION)\r
420 elif self.ItemObject.GetPackageName() == '':\r
421 Logger.Error(TOOL_NAME, FILE_PARSE_FAILURE, File=self._RawData.Filename, \r
422 ExtraData=ST.ERR_DECPARSE_DEFINE_REQUIRED % DT.TAB_DEC_DEFINES_PACKAGE_NAME)\r
423 elif self.ItemObject.GetPackageGuid() == '':\r
424 Logger.Error(TOOL_NAME, FILE_PARSE_FAILURE, File=self._RawData.Filename, \r
425 ExtraData=ST.ERR_DECPARSE_DEFINE_REQUIRED % DT.TAB_DEC_DEFINES_PACKAGE_GUID)\r
426 elif self.ItemObject.GetPackageVersion() == '':\r
427 Logger.Error(TOOL_NAME, FILE_PARSE_FAILURE, File=self._RawData.Filename, \r
428 ExtraData=ST.ERR_DECPARSE_DEFINE_REQUIRED % DT.TAB_DEC_DEFINES_PACKAGE_VERSION)\r
429 else:\r
430 Ret = True\r
431 return Ret\r
432 \r
433 def _ParseItem(self):\r
434 Line = self._RawData.CurrentLine\r
435 TokenList = GetSplitValueList(Line, DT.TAB_EQUAL_SPLIT, 1)\r
436 if TokenList[0] == DT.TAB_DEC_DEFINES_PKG_UNI_FILE:\r
421ccda3 437 self.DefineValidation[TokenList[0]](TokenList[1])\r
4234283c
LG		 438 elif len(TokenList) < 2:\r
439 self._LoggerError(ST.ERR_DECPARSE_DEFINE_FORMAT)\r
440 elif TokenList[0] not in self.DefineValidation:\r
441 self._LoggerError(ST.ERR_DECPARSE_DEFINE_UNKNOWKEY % TokenList[0])\r
442 else:\r
443 self.DefineValidation[TokenList[0]](TokenList[1])\r
444 \r
445 DefineItem = DecDefineItemObject()\r
421ccda3
HC		 446 DefineItem.Key = TokenList[0]\r
447 DefineItem.Value = TokenList[1]\r
448 self.ItemObject.AddItem(DefineItem, self._RawData.CurrentScope)\r
4234283c
LG		 449 return DefineItem\r
450 \r
451 def _SetDecSpecification(self, Token):\r
452 if self.ItemObject.GetPackageSpecification():\r
453 self._LoggerError(ST.ERR_DECPARSE_DEFINE_DEFINED % DT.TAB_DEC_DEFINES_DEC_SPECIFICATION)\r
454 if not IsValidToken('0[xX][0-9a-fA-F]{8}', Token):\r
455 self._LoggerError(ST.ERR_DECPARSE_DEFINE_SPEC)\r
456 self.ItemObject.SetPackageSpecification(Token)\r
457 \r
458 def _SetPackageName(self, Token):\r
459 if self.ItemObject.GetPackageName():\r
460 self._LoggerError(ST.ERR_DECPARSE_DEFINE_DEFINED % DT.TAB_DEC_DEFINES_PACKAGE_NAME)\r
461 if not IsValidWord(Token):\r
462 self._LoggerError(ST.ERR_DECPARSE_DEFINE_PKGNAME)\r
463 self.ItemObject.SetPackageName(Token)\r
464 \r
465 def _SetPackageGuid(self, Token):\r
466 if self.ItemObject.GetPackageGuid():\r
467 self._LoggerError(ST.ERR_DECPARSE_DEFINE_DEFINED % DT.TAB_DEC_DEFINES_PACKAGE_GUID)\r
468 if not CheckGuidRegFormat(Token):\r
469 self._LoggerError(ST.ERR_DECPARSE_DEFINE_PKGGUID)\r
470 self.ItemObject.SetPackageGuid(Token)\r
471 \r
472 def _SetPackageVersion(self, Token):\r
473 if self.ItemObject.GetPackageVersion():\r
474 self._LoggerError(ST.ERR_DECPARSE_DEFINE_DEFINED % DT.TAB_DEC_DEFINES_PACKAGE_VERSION)\r
475 if not IsValidToken(VERSION_PATTERN, Token):\r
476 self._LoggerError(ST.ERR_DECPARSE_DEFINE_PKGVERSION)\r
477 else:\r
478 if not DT.TAB_SPLIT in Token:\r
479 Token = Token + '.0'\r
421ccda3
HC		 480 self.ItemObject.SetPackageVersion(Token)\r
481 \r
482 def _SetPackageUni(self, Token):\r
483 if self.ItemObject.GetPackageUniFile():\r
484 self._LoggerError(ST.ERR_DECPARSE_DEFINE_DEFINED % DT.TAB_DEC_DEFINES_PKG_UNI_FILE)\r
485 self.ItemObject.SetPackageUniFile(Token)\r
4234283c
LG		 486\r
487## _DecInclude\r
488#\r
489# Parse include section\r
490#\r
491class _DecInclude(_DecBase):\r
492 def __init__(self, RawData):\r
493 _DecBase.__init__(self, RawData)\r
494 self.ItemObject = DecIncludeObject(RawData.Filename)\r
495 \r
496 def _ParseItem(self):\r
497 Line = self._RawData.CurrentLine\r
498 \r
499 if not IsValidPath(Line, self._RawData.PackagePath):\r
500 self._LoggerError(ST.ERR_DECPARSE_INCLUDE % Line) \r
501 \r
502 Item = DecIncludeItemObject(StripRoot(self._RawData.PackagePath, Line), self._RawData.PackagePath)\r
503 self.ItemObject.AddItem(Item, self._RawData.CurrentScope)\r
504 return Item\r
505\r
506## _DecLibraryclass\r
507#\r
508# Parse library class section\r
509#\r
510class _DecLibraryclass(_DecBase):\r
511 def __init__(self, RawData):\r
512 _DecBase.__init__(self, RawData)\r
513 self.ItemObject = DecLibraryclassObject(RawData.Filename)\r
514 \r
515 def _ParseItem(self):\r
516 Line = self._RawData.CurrentLine\r
517 TokenList = GetSplitValueList(Line, DT.TAB_VALUE_SPLIT)\r
518 if len(TokenList) != 2:\r
519 self._LoggerError(ST.ERR_DECPARSE_LIBCLASS_SPLIT) \r
520 if TokenList[0] == '' or TokenList[1] == '':\r
521 self._LoggerError(ST.ERR_DECPARSE_LIBCLASS_EMPTY)\r
522 if not IsValidToken('[A-Z][0-9A-Za-z]*', TokenList[0]):\r
523 self._LoggerError(ST.ERR_DECPARSE_LIBCLASS_LIB)\r
524 \r
525 self._CheckReDefine(TokenList[0])\r
526 \r
527 Value = TokenList[1]\r
528 #\r
529 # Must end with .h\r
530 #\r
531 if not Value.endswith('.h'):\r
532 self._LoggerError(ST.ERR_DECPARSE_LIBCLASS_PATH_EXT)\r
533 \r
534 #\r
535 # Path must be existed\r
536 #\r
537 if not IsValidPath(Value, self._RawData.PackagePath):\r
538 self._LoggerError(ST.ERR_DECPARSE_INCLUDE % Value)\r
539 \r
540 Item = DecLibraryclassItemObject(TokenList[0], StripRoot(self._RawData.PackagePath, Value),\r
541 self._RawData.PackagePath)\r
542 self.ItemObject.AddItem(Item, self._RawData.CurrentScope)\r
543 return Item\r
544\r
545## _DecPcd\r
546#\r
547# Parse PCD section\r
548#\r
549class _DecPcd(_DecBase):\r
550 def __init__(self, RawData):\r
551 _DecBase.__init__(self, RawData)\r
552 self.ItemObject = DecPcdObject(RawData.Filename)\r
553 #\r
554 # Used to check duplicate token\r
555 # Key is token space and token number (integer), value is C name\r
556 #\r
557 self.TokenMap = {}\r
558 \r
559 def _ParseItem(self):\r
560 Line = self._RawData.CurrentLine\r
561 TokenList = Line.split(DT.TAB_VALUE_SPLIT)\r
562 if len(TokenList) < 4:\r
563 self._LoggerError(ST.ERR_DECPARSE_PCD_SPLIT)\r
564 \r
565 #\r
566 # Token space guid C name\r
567 #\r
568 PcdName = GetSplitValueList(TokenList[0], DT.TAB_SPLIT)\r
569 if len(PcdName) != 2 or PcdName[0] == '' or PcdName[1] == '':\r
570 self._LoggerError(ST.ERR_DECPARSE_PCD_NAME)\r
571 \r
572 Guid = PcdName[0]\r
573 if not IsValidToken(CVAR_PATTERN, Guid):\r
574 self._LoggerError(ST.ERR_DECPARSE_PCD_CVAR_GUID)\r
575 \r
576 #\r
577 # PCD C name\r
578 #\r
579 CName = PcdName[1]\r
580 if not IsValidToken(CVAR_PATTERN, CName):\r
581 self._LoggerError(ST.ERR_DECPARSE_PCD_CVAR_PCDCNAME)\r
582 \r
583 self._CheckReDefine(Guid + DT.TAB_SPLIT + CName)\r
584 \r
585 #\r
586 # Default value, may be C array, string or number\r
587 #\r
588 Data = DT.TAB_VALUE_SPLIT.join(TokenList[1:-2]).strip()\r
589 \r
590 #\r
591 # PCD data type\r
592 #\r
593 DataType = TokenList[-2].strip()\r
594 Valid, Cause = IsValidPcdDatum(DataType, Data)\r
595 if not Valid:\r
596 self._LoggerError(Cause)\r
597 PcdType = self._RawData.CurrentScope[0][0]\r
598 if PcdType == DT.TAB_PCDS_FEATURE_FLAG_NULL.upper() and DataType != 'BOOLEAN':\r
599 self._LoggerError(ST.ERR_DECPARSE_PCD_FEATUREFLAG)\r
600 #\r
601 # Token value is the last element in list.\r
602 #\r
603 Token = TokenList[-1].strip()\r
604 if not IsValidToken(PCD_TOKEN_PATTERN, Token):\r
605 self._LoggerError(ST.ERR_DECPARSE_PCD_TOKEN % Token)\r
606 elif not Token.startswith('0x') and not Token.startswith('0X'):\r
607 if long(Token) > 4294967295:\r
608 self._LoggerError(ST.ERR_DECPARSE_PCD_TOKEN_INT % Token)\r
609 Token = hex(long(Token))[:-1]\r
610 \r
611 IntToken = long(Token, 0)\r
612 if (Guid, IntToken) in self.TokenMap:\r
613 if self.TokenMap[Guid, IntToken] != CName:\r
614 self._LoggerError(ST.ERR_DECPARSE_PCD_TOKEN_UNIQUE%(Token))\r
615 else:\r
616 self.TokenMap[Guid, IntToken] = CName\r
617 \r
618 Item = DecPcdItemObject(Guid, CName, Data, DataType, Token)\r
619 self.ItemObject.AddItem(Item, self._RawData.CurrentScope)\r
620 return Item\r
621 \r
622## _DecGuid\r
623#\r
624# Parse GUID, PPI, Protocol section\r
625#\r
626class _DecGuid(_DecBase):\r
627 def __init__(self, RawData):\r
628 _DecBase.__init__(self, RawData)\r
629 self.GuidObj = DecGuidObject(RawData.Filename)\r
630 self.PpiObj = DecPpiObject(RawData.Filename)\r
631 self.ProtocolObj = DecProtocolObject(RawData.Filename)\r
632 self.ObjectDict = \\r
633 {\r
634 DT.TAB_GUIDS.upper() : self.GuidObj,\r
635 DT.TAB_PPIS.upper() : self.PpiObj,\r
636 DT.TAB_PROTOCOLS.upper() : self.ProtocolObj\r
637 }\r
638 \r
639 def GetDataObject(self):\r
640 if self._RawData.CurrentScope:\r
641 return self.ObjectDict[self._RawData.CurrentScope[0][0]]\r
642 return None\r
643 \r
644 def GetGuidObject(self):\r
645 return self.GuidObj\r
646 \r
647 def GetPpiObject(self):\r
648 return self.PpiObj\r
649 \r
650 def GetProtocolObject(self):\r
651 return self.ProtocolObj\r
652 \r
653 def _ParseItem(self):\r
654 Line = self._RawData.CurrentLine\r
655 TokenList = GetSplitValueList(Line, DT.TAB_EQUAL_SPLIT, 1)\r
656 if len(TokenList) < 2:\r
657 self._LoggerError(ST.ERR_DECPARSE_CGUID)\r
658 if TokenList[0] == '':\r
659 self._LoggerError(ST.ERR_DECPARSE_CGUID_NAME)\r
660 if TokenList[1] == '':\r
661 self._LoggerError(ST.ERR_DECPARSE_CGUID_GUID)\r
662 if not IsValidToken(CVAR_PATTERN, TokenList[0]):\r
663 self._LoggerError(ST.ERR_DECPARSE_PCD_CVAR_GUID)\r
664 \r
665 self._CheckReDefine(TokenList[0])\r
666 \r
667 if TokenList[1][0] != '{':\r
668 if not CheckGuidRegFormat(TokenList[1]):\r
669 self._LoggerError(ST.ERR_DECPARSE_DEFINE_PKGGUID)\r
670 GuidString = TokenList[1]\r
671 else:\r
672 #\r
673 # Convert C format GUID to GUID string and Simple error check\r
674 #\r
675 GuidString = GuidStructureStringToGuidString(TokenList[1])\r
676 if TokenList[1][0] != '{' or TokenList[1][-1] != '}' or GuidString == '':\r
677 self._LoggerError(ST.ERR_DECPARSE_CGUID_GUIDFORMAT)\r
678 \r
679 #\r
680 # Check C format GUID\r
681 #\r
682 if not IsValidCFormatGuid(TokenList[1]):\r
683 self._LoggerError(ST.ERR_DECPARSE_CGUID_GUIDFORMAT)\r
684\r
685 Item = DecGuidItemObject(TokenList[0], TokenList[1], GuidString)\r
686 ItemObject = self.ObjectDict[self._RawData.CurrentScope[0][0]]\r
687 ItemObject.AddItem(Item, self._RawData.CurrentScope)\r
688 return Item\r
689\r
690## _DecUserExtension\r
691#\r
692# Parse user extention section\r
693#\r
694class _DecUserExtension(_DecBase):\r
695 def __init__(self, RawData):\r
696 _DecBase.__init__(self, RawData)\r
697 self.ItemObject = DecUserExtensionObject(RawData.Filename)\r
698 self._Headers = []\r
699 self._CurItems = []\r
700 \r
701 def BlockStart(self):\r
702 self._CurItems = []\r
703 for Header in self._RawData.CurrentScope:\r
704 if Header in self._Headers:\r
705 self._LoggerError(ST.ERR_DECPARSE_UE_DUPLICATE)\r
706 else:\r
707 self._Headers.append(Header)\r
708 \r
709 for Item in self._CurItems:\r
710 if Item.UserId == Header[1] and Item.IdString == Header[2]:\r
711 Item.ArchAndModuleType.append(Header[3])\r
712 break\r
713 else:\r
714 Item = DecUserExtensionItemObject()\r
715 Item.UserId = Header[1]\r
716 Item.IdString = Header[2]\r
717 Item.ArchAndModuleType.append(Header[3])\r
718 self._CurItems.append(Item)\r
719 self.ItemObject.AddItem(Item, None)\r
720 self._LocalMacro = {}\r
721 \r
722 def _ParseItem(self):\r
723 Line = self._RawData.CurrentLine\r
724 Item = None\r
725 for Item in self._CurItems:\r
726 if Item.UserString:\r
727 Item.UserString = '\n'.join([Item.UserString, Line])\r
728 else:\r
729 Item.UserString = Line\r
730 return Item\r
731\r
732## Dec\r
733#\r
734# Top dec parser\r
735#\r
736class Dec(_DecBase, _DecComments): \r
737 def __init__(self, DecFile, Parse = True): \r
738 try:\r
421ccda3 739 Content = ConvertSpecialChar(open(DecFile, 'rb').readlines())\r
4234283c
LG		 740 except BaseException:\r
741 Logger.Error(TOOL_NAME, FILE_OPEN_FAILURE, File=DecFile,\r
742 ExtraData=ST.ERR_DECPARSE_FILEOPEN % DecFile)\r
743 RawData = FileContent(DecFile, Content)\r
744 \r
745 _DecComments.__init__(self)\r
746 _DecBase.__init__(self, RawData)\r
747 \r
421ccda3
HC		 748 self.BinaryHeadComment = []\r
749 self.PcdErrorCommentDict = {}\r
750 \r
4234283c
LG		 751 self._Define = _DecDefine(RawData)\r
752 self._Include = _DecInclude(RawData)\r
753 self._Guid = _DecGuid(RawData)\r
754 self._LibClass = _DecLibraryclass(RawData)\r
755 self._Pcd = _DecPcd(RawData)\r
756 self._UserEx = _DecUserExtension(RawData)\r
757 \r
758 #\r
759 # DEC file supported data types (one type per section)\r
760 #\r
761 self._SectionParser = {\r
762 DT.TAB_DEC_DEFINES.upper() : self._Define,\r
763 DT.TAB_INCLUDES.upper() : self._Include,\r
764 DT.TAB_LIBRARY_CLASSES.upper() : self._LibClass,\r
765 DT.TAB_GUIDS.upper() : self._Guid,\r
766 DT.TAB_PPIS.upper() : self._Guid,\r
767 DT.TAB_PROTOCOLS.upper() : self._Guid,\r
768 DT.TAB_PCDS_FIXED_AT_BUILD_NULL.upper() : self._Pcd,\r
769 DT.TAB_PCDS_PATCHABLE_IN_MODULE_NULL.upper() : self._Pcd,\r
770 DT.TAB_PCDS_FEATURE_FLAG_NULL.upper() : self._Pcd,\r
771 DT.TAB_PCDS_DYNAMIC_NULL.upper() : self._Pcd,\r
772 DT.TAB_PCDS_DYNAMIC_EX_NULL.upper() : self._Pcd,\r
773 DT.TAB_USER_EXTENSIONS.upper() : self._UserEx\r
774 }\r
775\r
776 if Parse:\r
777 self.ParseDecComment()\r
778 self.Parse()\r
779 #\r
780 # Parsing done, check required fields\r
781 #\r
782 self.CheckRequiredFields()\r
783 \r
784 def CheckRequiredFields(self):\r
785 for SectionParser in self._SectionParser.values():\r
786 if not SectionParser.CheckRequiredFields():\r
787 return False\r
788 return True\r
421ccda3 789\r
4234283c
LG		 790 ##\r
791 # Parse DEC file\r
792 #\r
793 def ParseDecComment(self):\r
2bc3256c
LG		 794 IsFileHeader = False\r
795 IsBinaryHeader = False\r
796 FileHeaderLineIndex = -1\r
797 BinaryHeaderLineIndex = -1\r
421ccda3
HC		 798 TokenSpaceGuidCName = ''\r
799 \r
800 #\r
801 # Parse PCD error comment section\r
802 #\r
4234283c 803 while not self._RawData.IsEndOfFile():\r
421ccda3
HC		 804 self._RawData.CurrentLine = self._RawData.GetNextLine()\r
805 if self._RawData.CurrentLine.startswith(DT.TAB_COMMENT_SPLIT) and \\r
806 DT.TAB_SECTION_START in self._RawData.CurrentLine and \\r
807 DT.TAB_SECTION_END in self._RawData.CurrentLine:\r
808 self._RawData.CurrentLine = self._RawData.CurrentLine.replace(DT.TAB_COMMENT_SPLIT, '').strip()\r
2bc3256c 809\r
421ccda3
HC		 810 if self._RawData.CurrentLine[0] == DT.TAB_SECTION_START and \\r
811 self._RawData.CurrentLine[-1] == DT.TAB_SECTION_END:\r
812 RawSection = self._RawData.CurrentLine[1:-1].strip()\r
813 if RawSection.upper().startswith(DT.TAB_PCD_ERROR.upper()+'.'):\r
814 TokenSpaceGuidCName = RawSection.split(DT.TAB_PCD_ERROR+'.')[1].strip()\r
815 continue\r
816\r
817 if TokenSpaceGuidCName and self._RawData.CurrentLine.startswith(DT.TAB_COMMENT_SPLIT):\r
818 self._RawData.CurrentLine = self._RawData.CurrentLine.replace(DT.TAB_COMMENT_SPLIT, '').strip()\r
819 if self._RawData.CurrentLine != '':\r
820 if DT.TAB_VALUE_SPLIT not in self._RawData.CurrentLine:\r
821 self._LoggerError(ST.ERR_DECPARSE_PCDERRORMSG_MISS_VALUE_SPLIT) \r
822 \r
823 PcdErrorNumber, PcdErrorMsg = GetSplitValueList(self._RawData.CurrentLine, DT.TAB_VALUE_SPLIT, 1)\r
824 PcdErrorNumber = ParsePcdErrorCode(PcdErrorNumber, self._RawData.Filename, self._RawData.LineIndex)\r
825 if not PcdErrorMsg.strip():\r
826 self._LoggerError(ST.ERR_DECPARSE_PCD_MISS_ERRORMSG)\r
827 \r
828 self.PcdErrorCommentDict[(TokenSpaceGuidCName, PcdErrorNumber)] = PcdErrorMsg.strip()\r
829 else:\r
830 TokenSpaceGuidCName = ''\r
831\r
832 self._RawData.LineIndex = 0\r
833 self._RawData.CurrentLine = ''\r
834 self._RawData.NextLine = ''\r
835\r
836 while not self._RawData.IsEndOfFile():\r
837 Line, Comment = CleanString(self._RawData.GetNextLine())\r
838 \r
4234283c
LG		 839 #\r
840 # Header must be pure comment\r
841 #\r
842 if Line != '':\r
843 self._RawData.UndoNextLine()\r
844 break\r
845 \r
2bc3256c
LG		 846 if Comment and Comment.startswith(DT.TAB_SPECIAL_COMMENT) and Comment.find(DT.TAB_HEADER_COMMENT) > 0 \\r
847 and not Comment[2:Comment.find(DT.TAB_HEADER_COMMENT)].strip():\r
848 IsFileHeader = True\r
849 IsBinaryHeader = False\r
850 FileHeaderLineIndex = self._RawData.LineIndex\r
851 \r
852 #\r
853 # Get license information before '@file' \r
854 # \r
855 if not IsFileHeader and not IsBinaryHeader and Comment and Comment.startswith(DT.TAB_COMMENT_SPLIT) and \\r
856 DT.TAB_BINARY_HEADER_COMMENT not in Comment:\r
4234283c 857 self._HeadComment.append((Comment, self._RawData.LineIndex))\r
2bc3256c
LG		 858 \r
859 if Comment and IsFileHeader and \\r
860 not(Comment.startswith(DT.TAB_SPECIAL_COMMENT) \\r
861 and Comment.find(DT.TAB_BINARY_HEADER_COMMENT) > 0):\r
862 self._HeadComment.append((Comment, self._RawData.LineIndex))\r
863 #\r
864 # Double '#' indicates end of header comments\r
865 #\r
866 if (not Comment or Comment == DT.TAB_SPECIAL_COMMENT) and IsFileHeader:\r
867 IsFileHeader = False \r
868 continue\r
869 \r
870 if Comment and Comment.startswith(DT.TAB_SPECIAL_COMMENT) \\r
871 and Comment.find(DT.TAB_BINARY_HEADER_COMMENT) > 0:\r
872 IsBinaryHeader = True\r
873 IsFileHeader = False\r
874 BinaryHeaderLineIndex = self._RawData.LineIndex\r
875 \r
876 if Comment and IsBinaryHeader:\r
877 self.BinaryHeadComment.append((Comment, self._RawData.LineIndex))\r
4234283c
LG		 878 #\r
879 # Double '#' indicates end of header comments\r
880 #\r
2bc3256c
LG		 881 if (not Comment or Comment == DT.TAB_SPECIAL_COMMENT) and IsBinaryHeader:\r
882 IsBinaryHeader = False\r
4234283c 883 break\r
2bc3256c
LG		 884 \r
885 if FileHeaderLineIndex > -1 and not IsFileHeader and not IsBinaryHeader:\r
886 break\r
887\r
888 if FileHeaderLineIndex > BinaryHeaderLineIndex and FileHeaderLineIndex > -1 and BinaryHeaderLineIndex > -1:\r
889 self._LoggerError(ST.ERR_BINARY_HEADER_ORDER)\r
890 \r
891 if FileHeaderLineIndex == -1:\r
421ccda3 892# self._LoggerError(ST.ERR_NO_SOURCE_HEADER)\r
2bc3256c
LG		 893 Logger.Error(TOOL_NAME, FORMAT_INVALID, \r
894 ST.ERR_NO_SOURCE_HEADER,\r
421ccda3 895 File=self._RawData.Filename)\r
4234283c
LG		 896 return\r
897 \r
898 def _StopCurrentParsing(self, Line):\r
899 return False\r
900 \r
901 def _ParseItem(self):\r
902 self._SectionHeaderParser()\r
903 if len(self._RawData.CurrentScope) == 0:\r
904 self._LoggerError(ST.ERR_DECPARSE_SECTION_EMPTY)\r
4234283c 905 SectionObj = self._SectionParser[self._RawData.CurrentScope[0][0]]\r
4234283c
LG		 906 SectionObj.BlockStart()\r
907 SectionObj.Parse()\r
4234283c
LG		 908 return SectionObj.GetDataObject()\r
909\r
910 def _UserExtentionSectionParser(self):\r
911 self._RawData.CurrentScope = []\r
912 ArchList = set()\r
913 Section = self._RawData.CurrentLine[1:-1]\r
4234283c
LG		 914 Par = ParserHelper(Section, self._RawData.Filename)\r
915 while not Par.End():\r
916 #\r
917 # User extention\r
918 #\r
919 Token = Par.GetToken()\r
920 if Token.upper() != DT.TAB_USER_EXTENSIONS.upper():\r
921 self._LoggerError(ST.ERR_DECPARSE_SECTION_UE)\r
922 UserExtension = Token.upper()\r
421ccda3
HC		 923 Par.AssertChar(DT.TAB_SPLIT, ST.ERR_DECPARSE_SECTION_UE, self._RawData.LineIndex) \r
924 \r
4234283c
LG		 925 #\r
926 # UserID\r
927 #\r
928 Token = Par.GetToken()\r
929 if not IsValidUserId(Token):\r
930 self._LoggerError(ST.ERR_DECPARSE_SECTION_UE_USERID)\r
931 UserId = Token\r
4234283c
LG		 932 Par.AssertChar(DT.TAB_SPLIT, ST.ERR_DECPARSE_SECTION_UE, self._RawData.LineIndex)\r
933 #\r
934 # IdString\r
935 #\r
936 Token = Par.GetToken()\r
937 if not IsValidIdString(Token):\r
938 self._LoggerError(ST.ERR_DECPARSE_SECTION_UE_IDSTRING)\r
939 IdString = Token\r
4234283c
LG		 940 Arch = 'COMMON'\r
941 if Par.Expect(DT.TAB_SPLIT):\r
942 Token = Par.GetToken()\r
943 Arch = Token.upper()\r
944 if not IsValidArch(Arch):\r
945 self._LoggerError(ST.ERR_DECPARSE_ARCH)\r
946 ArchList.add(Arch)\r
4234283c
LG		 947 if [UserExtension, UserId, IdString, Arch] not in \\r
948 self._RawData.CurrentScope:\r
949 self._RawData.CurrentScope.append(\r
950 [UserExtension, UserId, IdString, Arch]\r
951 )\r
4234283c
LG		 952 if not Par.Expect(DT.TAB_COMMA_SPLIT):\r
953 break\r
954 elif Par.End():\r
955 self._LoggerError(ST.ERR_DECPARSE_SECTION_COMMA)\r
4234283c 956 Par.AssertEnd(ST.ERR_DECPARSE_SECTION_UE, self._RawData.LineIndex)\r
4234283c
LG		 957 if 'COMMON' in ArchList and len(ArchList) > 1:\r
958 self._LoggerError(ST.ERR_DECPARSE_SECTION_COMMON)\r
959 \r
960 ## Section header parser\r
961 #\r
962 # The section header is always in following format:\r
963 #\r
964 # [section_name.arch<.platform|module_type>]\r
965 #\r
966 def _SectionHeaderParser(self):\r
967 if self._RawData.CurrentLine[0] != DT.TAB_SECTION_START or self._RawData.CurrentLine[-1] != DT.TAB_SECTION_END:\r
968 self._LoggerError(ST.ERR_DECPARSE_SECTION_IDENTIFY)\r
969 \r
970 RawSection = self._RawData.CurrentLine[1:-1].strip().upper()\r
4234283c
LG		 971 #\r
972 # Check defines section which is only allowed to occur once and\r
973 # no arch can be followed\r
974 #\r
975 if RawSection.startswith(DT.TAB_DEC_DEFINES.upper()):\r
976 if RawSection != DT.TAB_DEC_DEFINES.upper():\r
977 self._LoggerError(ST.ERR_DECPARSE_DEFINE_SECNAME)\r
4234283c
LG		 978 #\r
979 # Check user extension section\r
980 #\r
981 if RawSection.startswith(DT.TAB_USER_EXTENSIONS.upper()):\r
982 return self._UserExtentionSectionParser()\r
4234283c
LG		 983 self._RawData.CurrentScope = []\r
984 SectionNames = []\r
985 ArchList = set()\r
986 for Item in GetSplitValueList(RawSection, DT.TAB_COMMA_SPLIT):\r
987 if Item == '':\r
988 self._LoggerError(ST.ERR_DECPARSE_SECTION_SUBEMPTY % self._RawData.CurrentLine)\r
989\r
990 ItemList = GetSplitValueList(Item, DT.TAB_SPLIT)\r
4234283c
LG		 991 #\r
992 # different types of PCD are permissible in one section\r
993 #\r
994 SectionName = ItemList[0]\r
995 if SectionName not in self._SectionParser:\r
996 self._LoggerError(ST.ERR_DECPARSE_SECTION_UNKNOW % SectionName)\r
4234283c
LG		 997 if SectionName not in SectionNames:\r
998 SectionNames.append(SectionName)\r
4234283c
LG		 999 #\r
1000 # In DEC specification, all section headers have at most two part:\r
1001 # SectionName.Arch except UserExtention\r
1002 #\r
1003 if len(ItemList) > 2:\r
1004 self._LoggerError(ST.ERR_DECPARSE_SECTION_SUBTOOMANY % Item)\r
1005\r
1006 if DT.TAB_PCDS_FEATURE_FLAG_NULL.upper() in SectionNames and len(SectionNames) > 1:\r
1007 self._LoggerError(ST.ERR_DECPARSE_SECTION_FEATUREFLAG % DT.TAB_PCDS_FEATURE_FLAG_NULL) \r
1008 #\r
1009 # S1 is always Arch\r
1010 #\r
1011 if len(ItemList) > 1:\r
1012 Str1 = ItemList[1]\r
1013 if not IsValidArch(Str1):\r
1014 self._LoggerError(ST.ERR_DECPARSE_ARCH)\r
1015 else:\r
1016 Str1 = 'COMMON'\r
1017 ArchList.add(Str1)\r
1018\r
1019 if [SectionName, Str1] not in self._RawData.CurrentScope:\r
1020 self._RawData.CurrentScope.append([SectionName, Str1])\r
1021 #\r
1022 # 'COMMON' must not be used with specific ARCHs at the same section\r
1023 #\r
1024 if 'COMMON' in ArchList and len(ArchList) > 1:\r
1025 self._LoggerError(ST.ERR_DECPARSE_SECTION_COMMON)\r
4234283c
LG		 1026 if len(SectionNames) == 0:\r
1027 self._LoggerError(ST.ERR_DECPARSE_SECTION_SUBEMPTY % self._RawData.CurrentLine)\r
1028 if len(SectionNames) != 1:\r
1029 for Sec in SectionNames:\r
1030 if not Sec.startswith(DT.TAB_PCDS.upper()):\r
1031 self._LoggerError(ST.ERR_DECPARSE_SECTION_NAME % str(SectionNames))\r
1032 \r
421ccda3
HC		 1033 def GetDefineSectionMacro(self):\r
1034 return self._Define.GetLocalMacro()\r
4234283c
LG		 1035 def GetDefineSectionObject(self):\r
1036 return self._Define.GetDataObject()\r
4234283c
LG		 1037 def GetIncludeSectionObject(self):\r
1038 return self._Include.GetDataObject()\r
4234283c
LG		 1039 def GetGuidSectionObject(self):\r
1040 return self._Guid.GetGuidObject()\r
4234283c
LG		 1041 def GetProtocolSectionObject(self):\r
1042 return self._Guid.GetProtocolObject()\r
4234283c
LG		 1043 def GetPpiSectionObject(self):\r
1044 return self._Guid.GetPpiObject()\r
4234283c
LG		 1045 def GetLibraryClassSectionObject(self):\r
1046 return self._LibClass.GetDataObject()\r
4234283c
LG		 1047 def GetPcdSectionObject(self):\r
1048 return self._Pcd.GetDataObject()\r
4234283c
LG		 1049 def GetUserExtensionSectionObject(self):\r
1050 return self._UserEx.GetDataObject()\r
4234283c 1051 def GetPackageSpecification(self):\r
421ccda3 1052 return self._Define.GetDataObject().GetPackageSpecification() \r
4234283c 1053 def GetPackageName(self):\r
421ccda3 1054 return self._Define.GetDataObject().GetPackageName() \r
4234283c 1055 def GetPackageGuid(self):\r
421ccda3 1056 return self._Define.GetDataObject().GetPackageGuid() \r
4234283c
LG		 1057 def GetPackageVersion(self):\r
1058 return self._Define.GetDataObject().GetPackageVersion()\r
4234283c
LG		 1059 def GetPackageUniFile(self):\r
1060 return self._Define.GetDataObject().GetPackageUniFile()\r
EFI Development Kit II mirror for PVE