]>
Commit | Line | Data |
---|---|---|
4234283c LG |
1 | ## @file ParserValidate.py\r |
2 | #\r | |
3 | # Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r | |
4 | #\r | |
5 | # This program and the accompanying materials are licensed and made available \r | |
6 | # under the terms and conditions of the BSD License which accompanies this \r | |
7 | # 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 | PaserValidate\r | |
16 | '''\r | |
17 | \r | |
18 | import os.path\r | |
19 | import re\r | |
0d2711a6 | 20 | import platform\r |
4234283c LG |
21 | \r |
22 | from Library.DataType import MODULE_LIST\r | |
23 | from Library.DataType import COMPONENT_TYPE_LIST\r | |
24 | from Library.DataType import PCD_USAGE_TYPE_LIST_OF_MODULE\r | |
25 | from Library.DataType import TAB_SPACE_SPLIT\r | |
26 | from Library.String import GetSplitValueList\r | |
27 | from Library.ExpressionValidate import IsValidBareCString\r | |
28 | from Library.ExpressionValidate import IsValidFeatureFlagExp\r | |
29 | \r | |
30 | ## __HexDigit() method\r | |
31 | #\r | |
32 | # Whether char input is a Hex data bit\r | |
33 | #\r | |
34 | # @param TempChar: The char to test\r | |
35 | #\r | |
36 | def __HexDigit(TempChar):\r | |
37 | if (TempChar >= 'a' and TempChar <= 'f') or \\r | |
38 | (TempChar >= 'A' and TempChar <= 'F') \\r | |
39 | or (TempChar >= '0' and TempChar <= '9'):\r | |
40 | return True\r | |
41 | else:\r | |
42 | return False\r | |
43 | \r | |
44 | ## IsValidHex() method\r | |
45 | #\r | |
46 | # Whether char input is a Hex data.\r | |
47 | #\r | |
48 | # @param TempChar: The char to test\r | |
49 | #\r | |
50 | def IsValidHex(HexStr):\r | |
51 | if not HexStr.upper().startswith("0X"):\r | |
52 | return False\r | |
53 | CharList = [c for c in HexStr[2:] if not __HexDigit(c)]\r | |
54 | if len(CharList) == 0:\r | |
55 | return True\r | |
56 | else:\r | |
57 | return False\r | |
58 | \r | |
59 | ## Judge the input string is valid bool type or not.\r | |
60 | # \r | |
61 | # <TRUE> ::= {"TRUE"} {"true"} {"True"} {"0x1"} {"0x01"}\r | |
62 | # <FALSE> ::= {"FALSE"} {"false"} {"False"} {"0x0"} {"0x00"}\r | |
63 | # <BoolType> ::= {<TRUE>} {<FALSE>}\r | |
64 | #\r | |
65 | # @param BoolString: A string contained the value need to be judged.\r | |
66 | #\r | |
67 | def IsValidBoolType(BoolString):\r | |
68 | #\r | |
69 | # Valid Ture\r | |
70 | #\r | |
71 | if BoolString == 'TRUE' or \\r | |
72 | BoolString == 'True' or \\r | |
73 | BoolString == 'true' or \\r | |
74 | BoolString == '0x1' or \\r | |
75 | BoolString == '0x01':\r | |
76 | return True\r | |
77 | #\r | |
78 | # Valid False\r | |
79 | #\r | |
80 | elif BoolString == 'FALSE' or \\r | |
81 | BoolString == 'False' or \\r | |
82 | BoolString == 'false' or \\r | |
83 | BoolString == '0x0' or \\r | |
84 | BoolString == '0x00':\r | |
85 | return True\r | |
86 | #\r | |
87 | # Invalid bool type\r | |
88 | #\r | |
89 | else:\r | |
90 | return False\r | |
91 | \r | |
92 | ## Is Valid Module Type List or not \r | |
93 | # \r | |
94 | # @param ModuleTypeList: A list contain ModuleType strings need to be \r | |
95 | # judged.\r | |
96 | #\r | |
97 | def IsValidInfMoudleTypeList(ModuleTypeList):\r | |
98 | for ModuleType in ModuleTypeList:\r | |
99 | return IsValidInfMoudleType(ModuleType)\r | |
100 | \r | |
101 | ## Is Valid Module Type or not \r | |
102 | # \r | |
103 | # @param ModuleType: A string contain ModuleType need to be judged.\r | |
104 | #\r | |
105 | def IsValidInfMoudleType(ModuleType):\r | |
106 | if ModuleType in MODULE_LIST:\r | |
107 | return True\r | |
108 | else:\r | |
109 | return False\r | |
110 | \r | |
111 | ## Is Valid Component Type or not \r | |
112 | # \r | |
113 | # @param ComponentType: A string contain ComponentType need to be judged.\r | |
114 | #\r | |
115 | def IsValidInfComponentType(ComponentType):\r | |
116 | if ComponentType.upper() in COMPONENT_TYPE_LIST:\r | |
117 | return True\r | |
118 | else:\r | |
119 | return False\r | |
120 | \r | |
121 | \r | |
122 | ## Is valid Tool Family or not\r | |
123 | #\r | |
124 | # @param ToolFamily: A string contain Tool Family need to be judged.\r | |
125 | # Famlily := [A-Z]([a-zA-Z0-9])* \r | |
126 | #\r | |
127 | def IsValidToolFamily(ToolFamily):\r | |
128 | ReIsValieFamily = re.compile(r"^[A-Z]+[A-Za-z0-9]{0,}$", re.DOTALL)\r | |
129 | if ReIsValieFamily.match(ToolFamily) == None:\r | |
130 | return False\r | |
131 | return True\r | |
132 | \r | |
133 | ## Is valid Tool TagName or not\r | |
134 | #\r | |
135 | # The TagName sample is MYTOOLS and VS2005.\r | |
136 | #\r | |
137 | # @param TagName: A string contain Tool TagName need to be judged.\r | |
138 | #\r | |
139 | def IsValidToolTagName(TagName):\r | |
140 | if TagName.strip() == '':\r | |
141 | return True\r | |
142 | if TagName.strip() == '*':\r | |
143 | return True\r | |
144 | if not IsValidWord(TagName):\r | |
145 | return False\r | |
146 | return True\r | |
147 | \r | |
148 | ## Is valid arch or not\r | |
149 | # \r | |
150 | # @param Arch The arch string need to be validated\r | |
151 | # <OA> ::= (a-zA-Z)(A-Za-z0-9){0,}\r | |
152 | # <arch> ::= {"IA32"} {"X64"} {"IPF"} {"EBC"} {<OA>}\r | |
153 | # {"common"}\r | |
154 | # @param Arch: Input arch\r | |
155 | # \r | |
156 | def IsValidArch(Arch):\r | |
157 | if Arch == 'common':\r | |
158 | return True\r | |
159 | ReIsValieArch = re.compile(r"^[a-zA-Z]+[a-zA-Z0-9]{0,}$", re.DOTALL)\r | |
160 | if ReIsValieArch.match(Arch) == None:\r | |
161 | return False\r | |
162 | return True\r | |
163 | \r | |
164 | ## Is valid family or not\r | |
165 | # \r | |
166 | # <Family> ::= {"MSFT"} {"GCC"} {"INTEL"} {<Usr>} {"*"}\r | |
167 | # <Usr> ::= [A-Z][A-Za-z0-9]{0,}\r | |
168 | #\r | |
169 | # @param family: The family string need to be validated\r | |
170 | # \r | |
171 | def IsValidFamily(Family):\r | |
172 | Family = Family.strip()\r | |
173 | if Family == '*':\r | |
174 | return True\r | |
175 | \r | |
176 | if Family == '':\r | |
177 | return True\r | |
178 | \r | |
179 | ReIsValidFamily = re.compile(r"^[A-Z]+[A-Za-z0-9]{0,}$", re.DOTALL)\r | |
180 | if ReIsValidFamily.match(Family) == None:\r | |
181 | return False\r | |
182 | return True\r | |
183 | \r | |
184 | ## Is valid build option name or not\r | |
185 | # \r | |
186 | # @param BuildOptionName: The BuildOptionName string need to be validated\r | |
187 | #\r | |
188 | def IsValidBuildOptionName(BuildOptionName):\r | |
189 | if not BuildOptionName:\r | |
190 | return False\r | |
191 | \r | |
192 | ToolOptionList = GetSplitValueList(BuildOptionName, '_', 4)\r | |
193 | \r | |
194 | if len(ToolOptionList) != 5:\r | |
195 | return False\r | |
196 | \r | |
197 | ReIsValidBuildOption1 = re.compile(r"^\s*(\*)|([A-Z][a-zA-Z0-9]*)$")\r | |
198 | ReIsValidBuildOption2 = re.compile(r"^\s*(\*)|([a-zA-Z][a-zA-Z0-9]*)$")\r | |
199 | \r | |
200 | if ReIsValidBuildOption1.match(ToolOptionList[0]) == None:\r | |
201 | return False\r | |
202 | \r | |
203 | if ReIsValidBuildOption1.match(ToolOptionList[1]) == None:\r | |
204 | return False\r | |
205 | \r | |
206 | if ReIsValidBuildOption2.match(ToolOptionList[2]) == None:\r | |
207 | return False\r | |
208 | \r | |
209 | if ToolOptionList[3] == "*" and ToolOptionList[4] not in ['FAMILY', 'DLL', 'DPATH']:\r | |
210 | return False\r | |
211 | \r | |
212 | return True\r | |
213 | \r | |
214 | ## IsValidToken\r | |
215 | #\r | |
216 | # Check if pattern string matches total token\r | |
217 | #\r | |
218 | # @param ReString: regular string\r | |
219 | # @param Token: Token to be matched\r | |
220 | #\r | |
221 | def IsValidToken(ReString, Token):\r | |
222 | Match = re.compile(ReString).match(Token)\r | |
223 | return Match and Match.start() == 0 and Match.end() == len(Token)\r | |
224 | \r | |
225 | ## IsValidPath\r | |
226 | #\r | |
227 | # Check if path exist\r | |
228 | #\r | |
229 | # @param Path: Absolute path or relative path to be checked\r | |
230 | # @param Root: Root path\r | |
231 | #\r | |
232 | def IsValidPath(Path, Root):\r | |
233 | Path = Path.strip()\r | |
234 | OrigPath = Path.replace('\\', '/')\r | |
235 | \r | |
236 | Path = os.path.normpath(Path).replace('\\', '/')\r | |
237 | Root = os.path.normpath(Root).replace('\\', '/')\r | |
238 | FullPath = os.path.normpath(os.path.join(Root, Path)).replace('\\', '/')\r | |
239 | \r | |
240 | if not os.path.exists(FullPath):\r | |
241 | return False\r | |
242 | \r | |
243 | #\r | |
244 | # If Path is absolute path.\r | |
245 | # It should be in Root.\r | |
246 | #\r | |
247 | if os.path.isabs(Path):\r | |
248 | if not Path.startswith(Root):\r | |
249 | return False\r | |
250 | return True\r | |
251 | \r | |
252 | #\r | |
253 | # Check illegal character\r | |
254 | #\r | |
255 | for Rel in ['/', './', '../']:\r | |
256 | if OrigPath.startswith(Rel):\r | |
257 | return False\r | |
258 | for Rel in ['//', '/./', '/../']:\r | |
259 | if Rel in OrigPath:\r | |
260 | return False\r | |
261 | for Rel in ['/.', '/..', '/']:\r | |
262 | if OrigPath.endswith(Rel):\r | |
263 | return False\r | |
264 | \r | |
265 | Path = Path.rstrip('/')\r | |
266 | \r | |
267 | #\r | |
268 | # Check relative path\r | |
269 | #\r | |
270 | for Word in Path.split('/'):\r | |
271 | if not IsValidWord(Word):\r | |
272 | return False\r | |
273 | \r | |
274 | return True\r | |
275 | \r | |
276 | ## IsValidInstallPath\r | |
277 | #\r | |
278 | # Check if an install path valid or not.\r | |
279 | #\r | |
280 | # Absolute path or path starts with '.' or path contains '..' are invalid.\r | |
281 | #\r | |
282 | # @param Path: path to be checked\r | |
283 | #\r | |
284 | def IsValidInstallPath(Path):\r | |
0d2711a6 LG |
285 | if platform.platform().find("Windows") >= 0:\r |
286 | if os.path.isabs(Path):\r | |
287 | return False\r | |
288 | else:\r | |
9508d0fa | 289 | if Path[1:2] == ':':\r |
0d2711a6 LG |
290 | return False\r |
291 | if os.path.isabs(Path):\r | |
292 | return False\r | |
4234283c LG |
293 | if Path.startswith('.'):\r |
294 | return False\r | |
295 | \r | |
296 | if Path.find('..') != -1:\r | |
297 | return False\r | |
298 | \r | |
299 | return True\r | |
300 | \r | |
301 | \r | |
302 | ## IsValidCFormatGuid\r | |
303 | #\r | |
304 | # Check if GUID format has the from of {8,4,4,{2,2,2,2,2,2,2,2}}\r | |
305 | #\r | |
306 | # @param Guid: Guid to be checked\r | |
307 | #\r | |
308 | def IsValidCFormatGuid(Guid):\r | |
309 | #\r | |
310 | # Valid: { 0xf0b11735, 0x87a0, 0x4193, {0xb2, 0x66, 0x53, 0x8c, 0x38, \r | |
311 | # 0xaf, 0x48, 0xce }}\r | |
312 | # Invalid: { 0xf0b11735, 0x87a0, 0x4193, {0xb2, 0x66, 0x53, 0x8c, 0x38, \r | |
313 | # 0xaf, 0x48, 0xce }} 0x123\r | |
314 | # Invalid: { 0xf0b1 1735, 0x87a0, 0x4193, {0xb2, 0x66, 0x53, 0x8c, 0x38, \r | |
315 | # 0xaf, 0x48, 0xce }}\r | |
316 | #\r | |
317 | List = ['{', 10, ',', 6, ',', 6, ',{', 4, ',', 4, ',', 4, \r | |
318 | ',', 4, ',', 4, ',', 4, ',', 4, ',', 4, '}}']\r | |
319 | Index = 0\r | |
320 | Value = ''\r | |
321 | SepValue = ''\r | |
322 | for Char in Guid:\r | |
323 | if Char not in '{},\t ':\r | |
324 | Value += Char\r | |
325 | continue\r | |
326 | if Value:\r | |
327 | try:\r | |
328 | #\r | |
329 | # Index may out of bound\r | |
330 | #\r | |
331 | if not SepValue or SepValue != List[Index]:\r | |
332 | return False\r | |
333 | Index += 1\r | |
334 | SepValue = ''\r | |
335 | \r | |
336 | if not Value.startswith('0x') and not Value.startswith('0X'):\r | |
337 | return False\r | |
338 | \r | |
339 | #\r | |
340 | # Index may out of bound\r | |
341 | #\r | |
342 | if type(List[Index]) != type(1) or \\r | |
343 | len(Value) > List[Index] or len(Value) < 3:\r | |
344 | return False\r | |
345 | \r | |
346 | #\r | |
347 | # Check if string can be converted to integer\r | |
348 | # Throw exception if not\r | |
349 | #\r | |
350 | int(Value, 16)\r | |
351 | except BaseException:\r | |
352 | #\r | |
353 | # Exception caught means invalid format\r | |
354 | #\r | |
355 | return False\r | |
356 | Value = ''\r | |
357 | Index += 1\r | |
358 | if Char in '{},':\r | |
359 | SepValue += Char\r | |
360 | \r | |
361 | return SepValue == '}}' and Value == ''\r | |
362 | \r | |
363 | ## IsValidPcdType\r | |
364 | #\r | |
365 | # Check whether the PCD type is valid\r | |
366 | #\r | |
367 | # @param PcdTypeString: The PcdType string need to be checked.\r | |
368 | # \r | |
369 | def IsValidPcdType(PcdTypeString):\r | |
370 | if PcdTypeString.upper() in PCD_USAGE_TYPE_LIST_OF_MODULE:\r | |
371 | return True\r | |
372 | else:\r | |
373 | return False\r | |
374 | \r | |
375 | ## IsValidWord\r | |
376 | #\r | |
377 | # Check whether the word is valid.\r | |
378 | # <Word> ::= (a-zA-Z0-9_)(a-zA-Z0-9_-){0,} Alphanumeric characters with \r | |
379 | # optional \r | |
380 | # dash "-" and/or underscore "_" characters. No whitespace \r | |
381 | # characters are permitted.\r | |
382 | # \r | |
383 | # @param Word: The word string need to be checked.\r | |
384 | # \r | |
385 | def IsValidWord(Word):\r | |
386 | if not Word:\r | |
387 | return False\r | |
388 | #\r | |
389 | # The first char should be alpha, _ or Digit.\r | |
390 | #\r | |
391 | if not Word[0].isalnum() and \\r | |
392 | not Word[0] == '_' and \\r | |
393 | not Word[0].isdigit():\r | |
394 | return False\r | |
395 | \r | |
396 | LastChar = ''\r | |
397 | for Char in Word[1:]: \r | |
398 | if (not Char.isalpha()) and \\r | |
399 | (not Char.isdigit()) and \\r | |
400 | Char != '-' and \\r | |
401 | Char != '_' and \\r | |
402 | Char != '.':\r | |
403 | return False\r | |
404 | if Char == '.' and LastChar == '.':\r | |
405 | return False\r | |
406 | LastChar = Char\r | |
407 | \r | |
408 | return True\r | |
409 | \r | |
410 | \r | |
411 | ## IsValidSimpleWord\r | |
412 | #\r | |
413 | # Check whether the SimpleWord is valid.\r | |
414 | # <SimpleWord> ::= (a-zA-Z0-9)(a-zA-Z0-9_-){0,} \r | |
415 | # A word that cannot contain a period character.\r | |
416 | # \r | |
417 | # @param Word: The word string need to be checked.\r | |
418 | # \r | |
419 | def IsValidSimpleWord(Word):\r | |
420 | ReIsValidSimpleWord = \\r | |
421 | re.compile(r"^[0-9A-Za-z][0-9A-Za-z\-_]*$", re.DOTALL)\r | |
422 | Word = Word.strip()\r | |
423 | if not Word:\r | |
424 | return False\r | |
425 | \r | |
426 | if not ReIsValidSimpleWord.match(Word):\r | |
427 | return False\r | |
428 | \r | |
429 | return True\r | |
430 | \r | |
431 | ## IsValidDecVersion\r | |
432 | #\r | |
433 | # Check whether the decimal version is valid.\r | |
434 | # <DecVersion> ::= (0-9){1,} ["." (0-9){1,}]\r | |
435 | # \r | |
436 | # @param Word: The word string need to be checked.\r | |
437 | # \r | |
438 | def IsValidDecVersion(Word):\r | |
439 | if Word.find('.') > -1:\r | |
440 | ReIsValidDecVersion = re.compile(r"[0-9]+\.?[0-9]+$")\r | |
441 | else:\r | |
442 | ReIsValidDecVersion = re.compile(r"[0-9]+$")\r | |
443 | if ReIsValidDecVersion.match(Word) == None:\r | |
444 | return False \r | |
445 | return True\r | |
446 | \r | |
447 | ## IsValidHexVersion\r | |
448 | #\r | |
449 | # Check whether the hex version is valid.\r | |
450 | # <HexVersion> ::= "0x" <Major> <Minor>\r | |
451 | # <Major> ::= <HexDigit>{4}\r | |
452 | # <Minor> ::= <HexDigit>{4}\r | |
453 | # \r | |
454 | # @param Word: The word string need to be checked.\r | |
455 | # \r | |
456 | def IsValidHexVersion(Word):\r | |
457 | ReIsValidHexVersion = re.compile(r"[0][xX][0-9A-Fa-f]{8}$", re.DOTALL)\r | |
458 | if ReIsValidHexVersion.match(Word) == None:\r | |
459 | return False\r | |
460 | \r | |
461 | return True\r | |
462 | \r | |
463 | ## IsValidBuildNumber\r | |
464 | #\r | |
465 | # Check whether the BUILD_NUMBER is valid.\r | |
466 | # ["BUILD_NUMBER" "=" <Integer>{1,4} <EOL>]\r | |
467 | # \r | |
468 | # @param Word: The BUILD_NUMBER string need to be checked.\r | |
469 | # \r | |
470 | def IsValidBuildNumber(Word):\r | |
471 | ReIsValieBuildNumber = re.compile(r"[0-9]{1,4}$", re.DOTALL)\r | |
472 | if ReIsValieBuildNumber.match(Word) == None:\r | |
473 | return False\r | |
474 | \r | |
475 | return True\r | |
476 | \r | |
477 | ## IsValidDepex\r | |
478 | #\r | |
479 | # Check whether the Depex is valid.\r | |
480 | # \r | |
481 | # @param Word: The Depex string need to be checked.\r | |
482 | # \r | |
483 | def IsValidDepex(Word):\r | |
484 | Index = Word.upper().find("PUSH")\r | |
485 | if Index > -1:\r | |
486 | return IsValidCFormatGuid(Word[Index+4:].strip())\r | |
487 | \r | |
488 | ReIsValidCName = re.compile(r"^[A-Za-z_][0-9A-Za-z_\s\.]*$", re.DOTALL)\r | |
489 | if ReIsValidCName.match(Word) == None:\r | |
490 | return False\r | |
491 | \r | |
492 | return True\r | |
493 | \r | |
494 | ## IsValidNormalizedString\r | |
495 | #\r | |
496 | # Check \r | |
497 | # <NormalizedString> ::= <DblQuote> [{<Word>} {<Space>}]{1,} <DblQuote>\r | |
498 | # <Space> ::= 0x20\r | |
499 | #\r | |
500 | # @param String: string to be checked\r | |
501 | #\r | |
502 | def IsValidNormalizedString(String):\r | |
503 | if String == '':\r | |
504 | return True\r | |
505 | \r | |
506 | for Char in String:\r | |
507 | if Char == '\t':\r | |
508 | return False\r | |
509 | \r | |
510 | StringList = GetSplitValueList(String, TAB_SPACE_SPLIT)\r | |
511 | \r | |
512 | for Item in StringList:\r | |
513 | if not Item:\r | |
514 | continue\r | |
515 | if not IsValidWord(Item):\r | |
516 | return False\r | |
517 | \r | |
518 | return True\r | |
519 | \r | |
520 | ## IsValidIdString\r | |
521 | #\r | |
522 | # Check whether the IdString is valid.\r | |
523 | # \r | |
524 | # @param IdString: The IdString need to be checked.\r | |
525 | # \r | |
526 | def IsValidIdString(String):\r | |
527 | if IsValidSimpleWord(String.strip()):\r | |
528 | return True\r | |
529 | \r | |
530 | if String.strip().startswith('"') and \\r | |
531 | String.strip().endswith('"'):\r | |
532 | String = String[1:-1]\r | |
533 | if String.strip() == "":\r | |
534 | return True\r | |
535 | if IsValidNormalizedString(String):\r | |
536 | return True\r | |
537 | \r | |
538 | return False\r | |
539 | \r | |
540 | ## IsValidVersionString\r | |
541 | #\r | |
542 | # Check whether the VersionString is valid.\r | |
543 | # <AsciiString> ::= [ [<WhiteSpace>]{0,} [<AsciiChars>]{0,} ] {0,}\r | |
544 | # <WhiteSpace> ::= {<Tab>} {<Space>}\r | |
545 | # <Tab> ::= 0x09\r | |
546 | # <Space> ::= 0x20\r | |
547 | # <AsciiChars> ::= (0x21 - 0x7E) \r | |
548 | # \r | |
549 | # @param VersionString: The VersionString need to be checked.\r | |
550 | # \r | |
551 | def IsValidVersionString(VersionString):\r | |
552 | VersionString = VersionString.strip()\r | |
553 | for Char in VersionString:\r | |
554 | if not (Char >= 0x21 and Char <= 0x7E):\r | |
555 | return False\r | |
556 | \r | |
557 | return True\r | |
558 | \r | |
559 | ## IsValidPcdValue\r | |
560 | #\r | |
561 | # Check whether the PcdValue is valid.\r | |
562 | # \r | |
563 | # @param VersionString: The PcdValue need to be checked.\r | |
564 | # \r | |
565 | def IsValidPcdValue(PcdValue):\r | |
566 | for Char in PcdValue:\r | |
567 | if Char == '\n' or Char == '\t' or Char == '\f':\r | |
568 | return False\r | |
569 | \r | |
570 | #\r | |
571 | # <Boolean>\r | |
572 | #\r | |
573 | if IsValidFeatureFlagExp(PcdValue, True)[0]:\r | |
574 | return True\r | |
575 | \r | |
576 | #\r | |
577 | # <Number> ::= {<Integer>} {<HexNumber>}\r | |
578 | # <Integer> ::= {(0-9)} {(1-9)(0-9){1,}}\r | |
579 | # <HexNumber> ::= "0x" <HexDigit>{1,}\r | |
580 | # <HexDigit> ::= (a-fA-F0-9)\r | |
581 | # \r | |
582 | if IsValidHex(PcdValue):\r | |
583 | return True\r | |
584 | \r | |
585 | ReIsValidIntegerSingle = re.compile(r"^\s*[0-9]\s*$", re.DOTALL) \r | |
586 | if ReIsValidIntegerSingle.match(PcdValue) != None:\r | |
587 | return True\r | |
588 | \r | |
589 | ReIsValidIntegerMulti = re.compile(r"^\s*[1-9][0-9]+\s*$", re.DOTALL) \r | |
590 | if ReIsValidIntegerMulti.match(PcdValue) != None:\r | |
591 | return True\r | |
592 | \r | |
593 | \r | |
594 | #\r | |
595 | # <StringVal> ::= {<StringType>} {<Array>} {"$(" <MACRO> ")"}\r | |
596 | # <StringType> ::= {<UnicodeString>} {<CString>}\r | |
597 | #\r | |
598 | ReIsValidStringType = re.compile(r"^\s*[\"L].*[\"]\s*$")\r | |
599 | if ReIsValidStringType.match(PcdValue):\r | |
600 | IsTrue = False\r | |
601 | if PcdValue.strip().startswith('L\"'):\r | |
602 | StringValue = PcdValue.strip().lstrip('L\"').rstrip('\"')\r | |
603 | if IsValidBareCString(StringValue):\r | |
604 | IsTrue = True\r | |
605 | elif PcdValue.strip().startswith('\"'):\r | |
606 | StringValue = PcdValue.strip().lstrip('\"').rstrip('\"')\r | |
607 | if IsValidBareCString(StringValue):\r | |
608 | IsTrue = True\r | |
609 | if IsTrue:\r | |
610 | return IsTrue\r | |
611 | \r | |
612 | #\r | |
613 | # <Array> ::= {<CArray>} {<NList>} {<CFormatGUID>}\r | |
614 | # <CArray> ::= "{" [<NList>] <CArray>{0,} "}"\r | |
615 | # <NList> ::= <HexByte> ["," <HexByte>]{0,}\r | |
616 | # <HexDigit> ::= (a-fA-F0-9)\r | |
617 | # <HexByte> ::= "0x" <HexDigit>{1,2}\r | |
618 | #\r | |
619 | if IsValidCFormatGuid(PcdValue):\r | |
620 | return True\r | |
621 | \r | |
622 | ReIsValidByteHex = re.compile(r"^\s*0x[0-9a-fA-F]{1,2}\s*$", re.DOTALL)\r | |
623 | if PcdValue.strip().startswith('{') and PcdValue.strip().endswith('}') :\r | |
624 | StringValue = PcdValue.strip().lstrip('{').rstrip('}')\r | |
625 | ValueList = StringValue.split(',')\r | |
626 | AllValidFlag = True\r | |
627 | for ValueItem in ValueList: \r | |
628 | if not ReIsValidByteHex.match(ValueItem.strip()):\r | |
629 | AllValidFlag = False\r | |
630 | \r | |
631 | if AllValidFlag:\r | |
632 | return True\r | |
633 | \r | |
634 | # \r | |
635 | # NList\r | |
636 | #\r | |
637 | AllValidFlag = True\r | |
638 | ValueList = PcdValue.split(',')\r | |
639 | for ValueItem in ValueList: \r | |
640 | if not ReIsValidByteHex.match(ValueItem.strip()):\r | |
641 | AllValidFlag = False\r | |
642 | \r | |
643 | if AllValidFlag:\r | |
644 | return True\r | |
645 | \r | |
646 | return False\r | |
647 | \r | |
648 | ## IsValidCVariableName\r | |
649 | #\r | |
650 | # Check whether the PcdValue is valid.\r | |
651 | # \r | |
652 | # @param VersionString: The PcdValue need to be checked.\r | |
653 | # \r | |
654 | def IsValidCVariableName(CName):\r | |
655 | ReIsValidCName = re.compile(r"^[A-Za-z_][0-9A-Za-z_]*$", re.DOTALL)\r | |
656 | if ReIsValidCName.match(CName) == None:\r | |
657 | return False\r | |
658 | \r | |
659 | return True\r | |
660 | \r | |
661 | ## IsValidIdentifier\r | |
662 | #\r | |
663 | # <Identifier> ::= <NonDigit> <Chars>{0,}\r | |
664 | # <Chars> ::= (a-zA-Z0-9_)\r | |
665 | # <NonDigit> ::= (a-zA-Z_)\r | |
666 | #\r | |
667 | # @param Ident: identifier to be checked\r | |
668 | #\r | |
669 | def IsValidIdentifier(Ident):\r | |
670 | ReIdent = re.compile(r"^[A-Za-z_][0-9A-Za-z_]*$", re.DOTALL)\r | |
671 | if ReIdent.match(Ident) == None:\r | |
672 | return False\r | |
673 | \r | |
674 | return True\r | |
675 | \r | |
676 | ## IsValidDecVersionVal\r | |
677 | #\r | |
678 | # {(0-9){1,} "." (0-99)}\r | |
679 | #\r | |
680 | # @param Ver: version to be checked\r | |
681 | #\r | |
682 | def IsValidDecVersionVal(Ver):\r | |
683 | ReVersion = re.compile(r"[0-9]+(\.[0-9]{1,2})$")\r | |
684 | \r | |
685 | if ReVersion.match(Ver) == None:\r | |
686 | return False\r | |
687 | \r | |
688 | return True\r | |
689 | \r | |
690 | \r | |
691 | ## IsValidLibName\r | |
692 | #\r | |
693 | # (A-Z)(a-zA-Z0-9){0,} and could not be "NULL"\r | |
694 | #\r | |
695 | def IsValidLibName(LibName):\r | |
696 | if LibName == 'NULL':\r | |
697 | return False\r | |
698 | ReLibName = re.compile("^[A-Z]+[a-zA-Z0-9]*$")\r | |
699 | if not ReLibName.match(LibName):\r | |
700 | return False\r | |
701 | \r | |
702 | return True\r | |
703 | \r | |
704 | # IsValidUserId\r | |
705 | #\r | |
706 | # <UserId> ::= (a-zA-Z)(a-zA-Z0-9_.){0,}\r | |
707 | # Words that contain period "." must be encapsulated in double quotation marks.\r | |
708 | #\r | |
709 | def IsValidUserId(UserId):\r | |
710 | UserId = UserId.strip()\r | |
711 | Quoted = False\r | |
712 | if UserId.startswith('"') and UserId.endswith('"'):\r | |
713 | Quoted = True\r | |
714 | UserId = UserId[1:-1]\r | |
715 | if not UserId or not UserId[0].isalpha():\r | |
716 | return False\r | |
717 | for Char in UserId[1:]:\r | |
718 | if not Char.isalnum() and not Char in '_.':\r | |
719 | return False\r | |
720 | if Char == '.' and not Quoted:\r | |
721 | return False\r | |
722 | return True\r | |
723 | \r |