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