1. Add a switch to enable/disable error raise for EdkLogger
[people/mcb30/basetools.git] / Source / Python / Common / String.py
1 ## @file\r
2 # This file is used to define common string related functions used in parsing process \r
3 #\r
4 # Copyright (c) 2007 ~ 2008, Intel Corporation\r
5 # All rights reserved. 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
17 import re\r
18 import DataType\r
19 import os.path\r
20 import string\r
21 import EdkLogger as EdkLogger\r
22 \r
23 from BuildToolError import *\r
24 \r
25 ## Regular expression for matching macro used in DSC/DEC/INF file inclusion\r
26 gMacroPattern = re.compile("\$\(([_A-Z][_A-Z0-9]*)\)", re.UNICODE)\r
27 \r
28 ## GetSplitValueList\r
29 #\r
30 # Get a value list from a string with multiple values splited with SplitTag\r
31 # The default SplitTag is DataType.TAB_VALUE_SPLIT\r
32 # 'AAA|BBB|CCC' -> ['AAA', 'BBB', 'CCC']\r
33 #\r
34 # @param String:    The input string to be splitted\r
35 # @param SplitTag:  The split key, default is DataType.TAB_VALUE_SPLIT\r
36 # @param MaxSplit:  The max number of split values, default is -1\r
37 #\r
38 # @retval list() A list for splitted string\r
39 #\r
40 def GetSplitValueList(String, SplitTag = DataType.TAB_VALUE_SPLIT, MaxSplit = -1):\r
41     return map(lambda l: l.strip(), String.split(SplitTag, MaxSplit))\r
42 \r
43 ## MergeArches\r
44 #\r
45 # Find a key's all arches in dict, add the new arch to the list\r
46 # If not exist any arch, set the arch directly\r
47 #\r
48 # @param Dict:  The input value for Dict\r
49 # @param Key:   The input value for Key\r
50 # @param Arch:  The Arch to be added or merged\r
51 #\r
52 def MergeArches(Dict, Key, Arch):\r
53     if Key in Dict.keys():\r
54         Dict[Key].append(Arch)\r
55     else:\r
56         Dict[Key] = Arch.split()\r
57 \r
58 ## GenDefines\r
59 #\r
60 # Parse a string with format "DEFINE <VarName> = <PATH>"\r
61 # Generate a map Defines[VarName] = PATH\r
62 # Return False if invalid format\r
63 #\r
64 # @param String:   String with DEFINE statement\r
65 # @param Arch:     Supportted Arch\r
66 # @param Defines:  DEFINE statement to be parsed\r
67 #\r
68 # @retval 0   DEFINE statement found, and valid\r
69 # @retval 1   DEFINE statement found, but not valid\r
70 # @retval -1  DEFINE statement not found\r
71 #\r
72 def GenDefines(String, Arch, Defines):\r
73     if String.find(DataType.TAB_DEFINE + ' ') > -1:\r
74         List = String.replace(DataType.TAB_DEFINE + ' ', '').split(DataType.TAB_EQUAL_SPLIT)\r
75         if len(List) == 2:\r
76             Defines[(CleanString(List[0]), Arch)] = CleanString(List[1])\r
77             return 0\r
78         else:\r
79             return -1\r
80 \r
81     return 1\r
82 \r
83 ## GenInclude\r
84 #\r
85 # Parse a string with format "!include <Filename>"\r
86 # Return the file path\r
87 # Return False if invalid format or NOT FOUND\r
88 #\r
89 # @param String:        String with INCLUDE statement\r
90 # @param IncludeFiles:  INCLUDE statement to be parsed\r
91 # @param Arch:          Supportted Arch\r
92 #\r
93 # @retval True\r
94 # @retval False\r
95 #\r
96 def GenInclude(String, IncludeFiles, Arch):\r
97     if String.upper().find(DataType.TAB_INCLUDE.upper() + ' ') > -1:\r
98         IncludeFile = CleanString(String[String.upper().find(DataType.TAB_INCLUDE.upper() + ' ') + len(DataType.TAB_INCLUDE + ' ') : ])\r
99         MergeArches(IncludeFiles, IncludeFile, Arch)\r
100         return True\r
101     else:\r
102         return False\r
103 \r
104 ## GetLibraryClassesWithModuleType\r
105 #\r
106 # Get Library Class definition when no module type defined\r
107 #\r
108 # @param Lines:             The content to be parsed\r
109 # @param Key:               Reserved \r
110 # @param KeyValues:         To store data after parsing\r
111 # @param CommentCharacter:  Comment char, used to ignore comment content\r
112 #\r
113 # @retval True Get library classes successfully\r
114 #\r
115 def GetLibraryClassesWithModuleType(Lines, Key, KeyValues, CommentCharacter):\r
116     newKey = SplitModuleType(Key)\r
117     Lines = Lines.split(DataType.TAB_SECTION_END, 1)[1]\r
118     LineList = Lines.splitlines()\r
119     for Line in LineList:\r
120         Line = CleanString(Line, CommentCharacter)\r
121         if Line != '' and Line[0] != CommentCharacter:\r
122             KeyValues.append([CleanString(Line, CommentCharacter), newKey[1]])\r
123 \r
124     return True\r
125 \r
126 ## GetDynamics\r
127 #\r
128 # Get Dynamic Pcds\r
129 #\r
130 # @param Lines:             The content to be parsed\r
131 # @param Key:               Reserved \r
132 # @param KeyValues:         To store data after parsing\r
133 # @param CommentCharacter:  Comment char, used to ignore comment content\r
134 #\r
135 # @retval True Get Dynamic Pcds successfully\r
136 #\r
137 def GetDynamics(Lines, Key, KeyValues, CommentCharacter):\r
138     #\r
139     # Get SkuId Name List\r
140     #\r
141     SkuIdNameList = SplitModuleType(Key)\r
142 \r
143     Lines = Lines.split(DataType.TAB_SECTION_END, 1)[1]\r
144     LineList = Lines.splitlines()\r
145     for Line in LineList:\r
146         Line = CleanString(Line, CommentCharacter)\r
147         if Line != '' and Line[0] != CommentCharacter:\r
148             KeyValues.append([CleanString(Line, CommentCharacter), SkuIdNameList[1]])\r
149 \r
150     return True\r
151 \r
152 ## SplitModuleType\r
153 #\r
154 # Split ModuleType out of section defien to get key\r
155 # [LibraryClass.Arch.ModuleType|ModuleType|ModuleType] -> [ 'LibraryClass.Arch', ['ModuleType', 'ModuleType', 'ModuleType'] ]\r
156 #\r
157 # @param Key:  String to be parsed\r
158 #\r
159 # @retval ReturnValue A list for module types\r
160 #\r
161 def SplitModuleType(Key):\r
162     KeyList = Key.split(DataType.TAB_SPLIT)\r
163     #\r
164     # Fill in for arch\r
165     #\r
166     KeyList.append('')\r
167     #\r
168     # Fill in for moduletype\r
169     #\r
170     KeyList.append('')\r
171     ReturnValue = []\r
172     KeyValue = KeyList[0]\r
173     if KeyList[1] != '':\r
174         KeyValue = KeyValue + DataType.TAB_SPLIT + KeyList[1]\r
175     ReturnValue.append(KeyValue)\r
176     ReturnValue.append(GetSplitValueList(KeyList[2]))\r
177 \r
178     return ReturnValue\r
179 \r
180 ## Replace macro in string\r
181 #\r
182 # This method replace macros used in given string. The macros are given in a\r
183 # dictionary.\r
184\r
185 # @param String             String to be processed\r
186 # @param MacroDefinitions   The macro definitions in the form of dictionary\r
187 #\r
188 # @retval string            The string whose macros are replaced\r
189 #\r
190 def ReplaceMacro(String, MacroDefinitions={}):\r
191     LastString = String\r
192     while MacroDefinitions != None and len(MacroDefinitions) > 0:\r
193         MacroUsed = gMacroPattern.findall(String)\r
194         # no macro found in String, stop replacing\r
195         if len(MacroUsed) == 0:\r
196             break\r
197 \r
198         for Macro in MacroUsed:\r
199             if Macro not in MacroDefinitions:\r
200                 continue\r
201             String = String.replace("$(%s)" % Macro, MacroDefinitions[Macro])\r
202         # in case there's macro not defined\r
203         if String == LastString:\r
204             break\r
205         LastString = String\r
206 \r
207     return String\r
208 \r
209 ## NormPath\r
210 #\r
211 # Create a normal path\r
212 # And replace DFEINE in the path\r
213 #\r
214 # @param Path:     The input value for Path to be converted\r
215 # @param Defines:  A set for DEFINE statement\r
216 #\r
217 # @retval Path Formatted path\r
218 #\r
219 def NormPath(Path, Defines = {}):\r
220     IsRelativePath = False\r
221     if Path != '':\r
222         if Path[0] == '.':\r
223             IsRelativePath = True\r
224     \r
225         #\r
226         # Replace with Define\r
227         #\r
228         if len(Defines) > 0:\r
229             Path = ReplaceMacro(Path, Defines)\r
230             # Remove leading path separator\r
231             if len(Path) > 0 and Path[0] in [DataType.TAB_SLASH, DataType.TAB_BACK_SLASH] == 0:\r
232                 Path = Path[1:]\r
233         #\r
234         # To local path format\r
235         #\r
236         Path = os.path.normpath(Path)\r
237 \r
238     if IsRelativePath and Path[0] != '.':\r
239         Path = os.path.join('.', Path)\r
240 \r
241     return Path\r
242 \r
243 ## CleanString\r
244 #\r
245 # Remove comments in a string\r
246 # Remove spaces\r
247 #\r
248 # @param Line:              The string to be cleaned\r
249 # @param CommentCharacter:  Comment char, used to ignore comment content, default is DataType.TAB_COMMENT_SPLIT\r
250 #\r
251 # @retval Path Formatted path\r
252 #\r
253 def CleanString(Line, CommentCharacter = DataType.TAB_COMMENT_SPLIT):\r
254     #\r
255     # remove whitespace\r
256     #\r
257     Line = Line.strip();\r
258     #\r
259     # Replace R8's comment character\r
260     #\r
261     Line = Line.replace(DataType.TAB_COMMENT_R8_SPLIT, CommentCharacter)\r
262     #\r
263     # remove comments\r
264     #\r
265     Line = Line.split(CommentCharacter, 1)[0];\r
266     #\r
267     # remove whitespace again\r
268     #\r
269     Line = Line.strip();\r
270 \r
271     return Line\r
272 \r
273 ## GetMultipleValuesOfKeyFromLines\r
274 #\r
275 # Parse multiple strings to clean comment and spaces\r
276 # The result is saved to KeyValues\r
277 #\r
278 # @param Lines:             The content to be parsed\r
279 # @param Key:               Reserved \r
280 # @param KeyValues:         To store data after parsing\r
281 # @param CommentCharacter:  Comment char, used to ignore comment content\r
282 #\r
283 # @retval True Successfully executed\r
284 #\r
285 def GetMultipleValuesOfKeyFromLines(Lines, Key, KeyValues, CommentCharacter):\r
286     Lines = Lines.split(DataType.TAB_SECTION_END, 1)[1]\r
287     LineList = Lines.split('\n')\r
288     for Line in LineList:\r
289         Line = CleanString(Line, CommentCharacter)\r
290         if Line != '' and Line[0] != CommentCharacter:\r
291             KeyValues += [Line]\r
292 \r
293     return True\r
294 \r
295 ## GetDefineValue\r
296 #\r
297 # Parse a DEFINE statement to get defined value\r
298 # DEFINE Key Value\r
299 #\r
300 # @param String:            The content to be parsed\r
301 # @param Key:               The key of DEFINE statement\r
302 # @param CommentCharacter:  Comment char, used to ignore comment content\r
303 #\r
304 # @retval string The defined value\r
305 #\r
306 def GetDefineValue(String, Key, CommentCharacter):\r
307     String = CleanString(String)\r
308     return String[String.find(Key + ' ') + len(Key + ' ') : ]\r
309 \r
310 ## GetSingleValueOfKeyFromLines\r
311 #\r
312 # Parse multiple strings as below to get value of each definition line\r
313 # Key1 = Value1\r
314 # Key2 = Value2\r
315 # The result is saved to Dictionary\r
316 #\r
317 # @param Lines:                The content to be parsed\r
318 # @param Dictionary:           To store data after parsing\r
319 # @param CommentCharacter:     Comment char, be used to ignore comment content\r
320 # @param KeySplitCharacter:    Key split char, between key name and key value. Key1 = Value1, '=' is the key split char\r
321 # @param ValueSplitFlag:       Value split flag, be used to decide if has multiple values\r
322 # @param ValueSplitCharacter:  Value split char, be used to split multiple values. Key1 = Value1|Value2, '|' is the value split char\r
323 #\r
324 # @retval True Successfully executed\r
325 #\r
326 def GetSingleValueOfKeyFromLines(Lines, Dictionary, CommentCharacter, KeySplitCharacter, ValueSplitFlag, ValueSplitCharacter):\r
327     Lines = Lines.split('\n')\r
328     Keys = []\r
329     Value = ''\r
330     DefineValues = ['']\r
331     SpecValues = ['']\r
332 \r
333     for Line in Lines:\r
334         #\r
335         # Handle DEFINE and SPEC\r
336         #\r
337         if Line.find(DataType.TAB_INF_DEFINES_DEFINE + ' ') > -1:\r
338             if '' in DefineValues:\r
339                 DefineValues.remove('')\r
340             DefineValues.append(GetDefineValue(Line, DataType.TAB_INF_DEFINES_DEFINE, CommentCharacter))\r
341             continue\r
342         if Line.find(DataType.TAB_INF_DEFINES_SPEC + ' ') > -1:\r
343             if '' in SpecValues:\r
344                 SpecValues.remove('')\r
345             SpecValues.append(GetDefineValue(Line, DataType.TAB_INF_DEFINES_SPEC, CommentCharacter))\r
346             continue\r
347 \r
348         #\r
349         # Handle Others\r
350         #\r
351         LineList = Line.split(KeySplitCharacter, 1)\r
352         if len(LineList) >= 2:\r
353             Key = LineList[0].split()\r
354             if len(Key) == 1 and Key[0][0] != CommentCharacter:\r
355                 #\r
356                 # Remove comments and white spaces\r
357                 #\r
358                 LineList[1] = CleanString(LineList[1], CommentCharacter)\r
359                 if ValueSplitFlag:\r
360                     Value = map(string.strip, LineList[1].split(ValueSplitCharacter))\r
361                 else:\r
362                     Value = CleanString(LineList[1], CommentCharacter).splitlines()\r
363 \r
364                 if Key[0] in Dictionary:\r
365                     if Key[0] not in Keys:\r
366                         Dictionary[Key[0]] = Value\r
367                         Keys.append(Key[0])\r
368                     else:\r
369                         Dictionary[Key[0]].extend(Value)\r
370                 else:\r
371                     Dictionary[DataType.TAB_INF_DEFINES_MACRO][Key[0]] = Value[0]\r
372 \r
373     if DefineValues == []:\r
374         DefineValues = ['']\r
375     if SpecValues == []:\r
376         SpecValues = ['']\r
377     Dictionary[DataType.TAB_INF_DEFINES_DEFINE] = DefineValues\r
378     Dictionary[DataType.TAB_INF_DEFINES_SPEC] = SpecValues\r
379 \r
380     return True\r
381 \r
382 ## The content to be parsed\r
383 #\r
384 # Do pre-check for a file before it is parsed\r
385 # Check $()\r
386 # Check []\r
387 #\r
388 # @param FileName:       Used for error report\r
389 # @param FileContent:    File content to be parsed\r
390 # @param SupSectionTag:  Used for error report\r
391 #\r
392 def PreCheck(FileName, FileContent, SupSectionTag):\r
393     LineNo = 0\r
394     IsFailed = False\r
395     NewFileContent = ''\r
396     for Line in FileContent.splitlines():\r
397         LineNo = LineNo + 1\r
398         #\r
399         # Clean current line\r
400         #\r
401         Line = CleanString(Line)\r
402         \r
403         #\r
404         # Remove commented line\r
405         #\r
406         if Line.find(DataType.TAB_COMMA_SPLIT) == 0:\r
407             Line = ''\r
408         #\r
409         # Check $()\r
410         #\r
411         if Line.find('$') > -1:\r
412             if Line.find('$(') < 0 or Line.find(')') < 0:\r
413                 EdkLogger.error("Parser", FORMAT_INVALID, Line=LineNo, File=FileName, RaiseError = EdkLogger.IsRaiseError)\r
414 \r
415         #\r
416         # Check []\r
417         #\r
418         if Line.find('[') > -1 or Line.find(']') > -1:\r
419             #\r
420             # Only get one '[' or one ']'\r
421             #\r
422             if not (Line.find('[') > -1 and Line.find(']') > -1):\r
423                 EdkLogger.error("Parser", FORMAT_INVALID, Line=LineNo, File=FileName, RaiseError = EdkLogger.IsRaiseError)\r
424         \r
425         #\r
426         # Regenerate FileContent\r
427         #\r
428         NewFileContent = NewFileContent + Line + '\r\n'\r
429 \r
430     if IsFailed:\r
431        EdkLogger.error("Parser", FORMAT_INVALID, Line=LineNo, File=FileName, RaiseError = EdkLogger.IsRaiseError)\r
432     \r
433     return NewFileContent\r
434 \r
435 ## CheckFileType\r
436 #\r
437 # Check if the Filename is including ExtName\r
438 # Return True if it exists\r
439 # Raise a error message if it not exists\r
440 #\r
441 # @param CheckFilename:      Name of the file to be checked\r
442 # @param ExtName:            Ext name of the file to be checked\r
443 # @param ContainerFilename:  The container file which describes the file to be checked, used for error report\r
444 # @param SectionName:        Used for error report\r
445 # @param Line:               The line in container file which defines the file to be checked\r
446 #\r
447 # @retval True The file type is correct\r
448 #\r
449 def CheckFileType(CheckFilename, ExtName, ContainerFilename, SectionName, Line, LineNo = -1):\r
450     if CheckFilename != '' and CheckFilename != None:\r
451         (Root, Ext) = os.path.splitext(CheckFilename)\r
452         if Ext.upper() != ExtName.upper():\r
453             ContainerFile = open(ContainerFilename, 'r').read()\r
454             if LineNo == -1:\r
455                 LineNo = GetLineNo(ContainerFile, Line)\r
456             ErrorMsg = "Invalid %s. '%s' is found, but '%s' file is needed" % (SectionName, CheckFilename, ExtName)\r
457             EdkLogger.error("Parser", PARSER_ERROR, ErrorMsg, Line=LineNo,\r
458                             File=ContainerFilename, RaiseError = EdkLogger.IsRaiseError)\r
459 \r
460     return True\r
461 \r
462 ## CheckFileExist\r
463 #\r
464 # Check if the file exists\r
465 # Return True if it exists\r
466 # Raise a error message if it not exists\r
467 #\r
468 # @param CheckFilename:      Name of the file to be checked\r
469 # @param WorkspaceDir:       Current workspace dir\r
470 # @param ContainerFilename:  The container file which describes the file to be checked, used for error report\r
471 # @param SectionName:        Used for error report\r
472 # @param Line:               The line in container file which defines the file to be checked\r
473 #\r
474 # @retval The file full path if the file exists\r
475 #\r
476 def CheckFileExist(WorkspaceDir, CheckFilename, ContainerFilename, SectionName, Line, LineNo = -1):\r
477     CheckFile = ''\r
478     if CheckFilename != '' and CheckFilename != None:\r
479         CheckFile = WorkspaceFile(WorkspaceDir, CheckFilename)\r
480         if not os.path.isfile(CheckFile):\r
481             ContainerFile = open(ContainerFilename, 'r').read()\r
482             if LineNo == -1:\r
483                 LineNo = GetLineNo(ContainerFile, Line)\r
484             ErrorMsg = "Can't find file '%s' defined in section '%s'" % (CheckFile, SectionName)\r
485             EdkLogger.error("Parser", PARSER_ERROR, ErrorMsg,\r
486                             File=ContainerFilename, Line = LineNo, RaiseError = EdkLogger.IsRaiseError)\r
487 \r
488     return CheckFile\r
489 \r
490 ## GetLineNo\r
491 #\r
492 # Find the index of a line in a file\r
493 #\r
494 # @param FileContent:  Search scope\r
495 # @param Line:         Search key\r
496 #\r
497 # @retval int  Index of the line\r
498 # @retval -1     The line is not found\r
499 #\r
500 def GetLineNo(FileContent, Line, IsIgnoreComment = True):\r
501     LineList = FileContent.splitlines()\r
502     for Index in range(len(LineList)):\r
503         if LineList[Index].find(Line) > -1:\r
504             #\r
505             # Ignore statement in comment\r
506             #\r
507             if IsIgnoreComment:\r
508                 if LineList[Index].strip()[0] == DataType.TAB_COMMENT_SPLIT:\r
509                     continue\r
510             return Index + 1\r
511 \r
512     return -1\r
513 \r
514 ## RaiseParserError\r
515 #\r
516 # Raise a parser error\r
517 #\r
518 # @param Line:     String which has error\r
519 # @param Section:  Used for error report\r
520 # @param File:     File which has the string\r
521 # @param Format:   Correct format\r
522 #\r
523 def RaiseParserError(Line, Section, File, Format = '', LineNo = -1):\r
524     if LineNo == -1:\r
525         LineNo = GetLineNo(open(os.path.normpath(File), 'r').read(), Line)\r
526     ErrorMsg = "Invalid statement '%s' is found in section '%s'" % (Line, Section)\r
527     if Format != '':\r
528         Format = "Correct format is " + Format\r
529     EdkLogger.error("Parser", PARSER_ERROR, ErrorMsg, File=File, Line=LineNo, ExtraData=Format, RaiseError = EdkLogger.IsRaiseError)\r
530 \r
531 ## WorkspaceFile\r
532 #\r
533 # Return a full path with workspace dir\r
534 #\r
535 # @param WorkspaceDir:  Workspace dir\r
536 # @param Filename:      Relative file name\r
537 #\r
538 # @retval string A full path\r
539\r
540 def WorkspaceFile(WorkspaceDir, Filename):\r
541     return os.path.join(NormPath(WorkspaceDir), NormPath(Filename))\r
542 \r
543 ## Split string\r
544 #\r
545 # Revmove '"' which startswith and endswith string\r
546 #\r
547 # @param String:  The string need to be splited \r
548 #\r
549 # @retval String: The string after removed '""'\r
550 #\r
551 def SplitString(String):\r
552     if String.startswith('\"'):\r
553         String = String[1:]\r
554     if String.endswith('\"'):\r
555         String = String[:-1]\r
556         \r
557     return String\r
558 \r
559 ## Convert To Sql String\r
560 #\r
561 # 1. Replace "'" with "''" in each item of StringList\r
562\r
563 # @param StringList:  A list for strings to be converted\r
564 #\r
565 def ConvertToSqlString(StringList):\r
566     return map(lambda s: s.replace("'", "''") , StringList)\r
567 \r
568 ## Convert To Sql String\r
569 #\r
570 # 1. Replace "'" with "''" in the String\r
571\r
572 # @param String:  A String to be converted\r
573 #\r
574 def ConvertToSqlString2(String):\r
575     return String.replace("'", "''")\r
576 \r
577 ##\r
578 #\r
579 # This acts like the main() function for the script, unless it is 'import'ed into another\r
580 # script.\r
581 #\r
582 if __name__ == '__main__':\r
583     print SplitModuleType('LibraryClasses.common.DXE_RUNTIME_DRIVER')\r
584     print SplitModuleType('Library.common')\r
585     print SplitModuleType('Librarsdsfwe')\r
586     print NormPath('sdfas//dsfsadf//dsfsd')\r
587     print NormPath('\\dsfsdf\\\\sd\\fsd\\dsfsdfsdf\\\\')\r
588     print ConvertToSqlString(("'sdf,'sdf'", "aaaaa'bbbbb"))\r