#\r
# Copyright (c) 2011 - 2018, Intel Corporation. All rights reserved.<BR>\r
#\r
-# This program and the accompanying materials are licensed and made available \r
-# under the terms and conditions of the BSD License which accompanies this \r
-# distribution. The full text of the license may be found at \r
+# This program and the accompanying materials are licensed and made available\r
+# under the terms and conditions of the BSD License which accompanies this\r
+# distribution. The full text of the license may be found at\r
# http://opensource.org/licenses/bsd-license.php\r
#\r
# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
return True\r
else:\r
return False\r
- \r
+\r
## IsValidHex() method\r
#\r
# Whether char input is a Hex data.\r
return False\r
\r
## Judge the input string is valid bool type or not.\r
-# \r
+#\r
# <TRUE> ::= {"TRUE"} {"true"} {"True"} {"0x1"} {"0x01"}\r
# <FALSE> ::= {"FALSE"} {"false"} {"False"} {"0x0"} {"0x00"}\r
# <BoolType> ::= {<TRUE>} {<FALSE>}\r
#\r
else:\r
return False\r
- \r
-## Is Valid Module Type List or not \r
-# \r
-# @param ModuleTypeList: A list contain ModuleType strings need to be \r
+\r
+## Is Valid Module Type List or not\r
+#\r
+# @param ModuleTypeList: A list contain ModuleType strings need to be\r
# judged.\r
#\r
def IsValidInfMoudleTypeList(ModuleTypeList):\r
for ModuleType in ModuleTypeList:\r
return IsValidInfMoudleType(ModuleType)\r
\r
-## Is Valid Module Type or not \r
-# \r
+## Is Valid Module Type or not\r
+#\r
# @param ModuleType: A string contain ModuleType need to be judged.\r
#\r
def IsValidInfMoudleType(ModuleType):\r
else:\r
return False\r
\r
-## Is Valid Component Type or not \r
-# \r
+## Is Valid Component Type or not\r
+#\r
# @param ComponentType: A string contain ComponentType need to be judged.\r
#\r
def IsValidInfComponentType(ComponentType):\r
## Is valid Tool Family or not\r
#\r
# @param ToolFamily: A string contain Tool Family need to be judged.\r
-# Famlily := [A-Z]([a-zA-Z0-9])* \r
+# Famlily := [A-Z]([a-zA-Z0-9])*\r
#\r
def IsValidToolFamily(ToolFamily):\r
ReIsValieFamily = re.compile(r"^[A-Z]+[A-Za-z0-9]{0,}$", re.DOTALL)\r
return True\r
\r
## Is valid arch or not\r
-# \r
+#\r
# @param Arch The arch string need to be validated\r
# <OA> ::= (a-zA-Z)(A-Za-z0-9){0,}\r
# <arch> ::= {"IA32"} {"X64"} {"IPF"} {"EBC"} {<OA>}\r
# {"common"}\r
# @param Arch: Input arch\r
-# \r
+#\r
def IsValidArch(Arch):\r
if Arch == 'common':\r
return True\r
return True\r
\r
## Is valid family or not\r
-# \r
+#\r
# <Family> ::= {"MSFT"} {"GCC"} {"INTEL"} {<Usr>} {"*"}\r
# <Usr> ::= [A-Z][A-Za-z0-9]{0,}\r
#\r
# @param family: The family string need to be validated\r
-# \r
+#\r
def IsValidFamily(Family):\r
Family = Family.strip()\r
if Family == '*':\r
return True\r
- \r
+\r
if Family == '':\r
return True\r
- \r
+\r
ReIsValidFamily = re.compile(r"^[A-Z]+[A-Za-z0-9]{0,}$", re.DOTALL)\r
if ReIsValidFamily.match(Family) is None:\r
return False\r
return True\r
\r
## Is valid build option name or not\r
-# \r
+#\r
# @param BuildOptionName: The BuildOptionName string need to be validated\r
#\r
def IsValidBuildOptionName(BuildOptionName):\r
if not BuildOptionName:\r
return False\r
- \r
+\r
ToolOptionList = GetSplitValueList(BuildOptionName, '_', 4)\r
- \r
+\r
if len(ToolOptionList) != 5:\r
return False\r
- \r
+\r
ReIsValidBuildOption1 = re.compile(r"^\s*(\*)|([A-Z][a-zA-Z0-9]*)$")\r
ReIsValidBuildOption2 = re.compile(r"^\s*(\*)|([a-zA-Z][a-zA-Z0-9]*)$")\r
- \r
+\r
if ReIsValidBuildOption1.match(ToolOptionList[0]) is None:\r
return False\r
- \r
+\r
if ReIsValidBuildOption1.match(ToolOptionList[1]) is None:\r
return False\r
- \r
+\r
if ReIsValidBuildOption2.match(ToolOptionList[2]) is None:\r
return False\r
- \r
+\r
if ToolOptionList[3] == "*" and ToolOptionList[4] not in ['FAMILY', 'DLL', 'DPATH']:\r
return False\r
- \r
+\r
return True\r
- \r
+\r
## IsValidToken\r
#\r
# Check if pattern string matches total token\r
def IsValidPath(Path, Root):\r
Path = Path.strip()\r
OrigPath = Path.replace('\\', '/')\r
- \r
+\r
Path = os.path.normpath(Path).replace('\\', '/')\r
Root = os.path.normpath(Root).replace('\\', '/')\r
FullPath = mws.join(Root, Path)\r
- \r
+\r
if not os.path.exists(FullPath):\r
return False\r
- \r
+\r
#\r
# If Path is absolute path.\r
# It should be in Root.\r
for Rel in ['/.', '/..', '/']:\r
if OrigPath.endswith(Rel):\r
return False\r
- \r
+\r
Path = Path.rstrip('/')\r
- \r
+\r
#\r
# Check relative path\r
#\r
for Word in Path.split('/'):\r
if not IsValidWord(Word):\r
return False\r
- \r
+\r
return True\r
\r
## IsValidInstallPath\r
return False\r
if Path.startswith('.'):\r
return False\r
- \r
+\r
if Path.find('..') != -1:\r
return False\r
- \r
+\r
return True\r
- \r
+\r
\r
## IsValidCFormatGuid\r
#\r
#\r
def IsValidCFormatGuid(Guid):\r
#\r
- # Valid: { 0xf0b11735, 0x87a0, 0x4193, {0xb2, 0x66, 0x53, 0x8c, 0x38, \r
+ # Valid: { 0xf0b11735, 0x87a0, 0x4193, {0xb2, 0x66, 0x53, 0x8c, 0x38,\r
# 0xaf, 0x48, 0xce }}\r
- # Invalid: { 0xf0b11735, 0x87a0, 0x4193, {0xb2, 0x66, 0x53, 0x8c, 0x38, \r
+ # Invalid: { 0xf0b11735, 0x87a0, 0x4193, {0xb2, 0x66, 0x53, 0x8c, 0x38,\r
# 0xaf, 0x48, 0xce }} 0x123\r
- # Invalid: { 0xf0b1 1735, 0x87a0, 0x4193, {0xb2, 0x66, 0x53, 0x8c, 0x38, \r
+ # Invalid: { 0xf0b1 1735, 0x87a0, 0x4193, {0xb2, 0x66, 0x53, 0x8c, 0x38,\r
# 0xaf, 0x48, 0xce }}\r
#\r
- List = ['{', 10, ',', 6, ',', 6, ',{', 4, ',', 4, ',', 4, \r
+ List = ['{', 10, ',', 6, ',', 6, ',{', 4, ',', 4, ',', 4,\r
',', 4, ',', 4, ',', 4, ',', 4, ',', 4, '}}']\r
Index = 0\r
Value = ''\r
\r
if not Value.startswith('0x') and not Value.startswith('0X'):\r
return False\r
- \r
+\r
#\r
# Index may out of bound\r
#\r
if not isinstance(List[Index], type(1)) or \\r
len(Value) > List[Index] or len(Value) < 3:\r
return False\r
- \r
+\r
#\r
# Check if string can be converted to integer\r
# Throw exception if not\r
# Check whether the PCD type is valid\r
#\r
# @param PcdTypeString: The PcdType string need to be checked.\r
-# \r
+#\r
def IsValidPcdType(PcdTypeString):\r
if PcdTypeString.upper() in PCD_USAGE_TYPE_LIST_OF_MODULE:\r
return True\r
else:\r
return False\r
- \r
+\r
## IsValidWord\r
#\r
# Check whether the word is valid.\r
-# <Word> ::= (a-zA-Z0-9_)(a-zA-Z0-9_-){0,} Alphanumeric characters with \r
-# optional \r
-# dash "-" and/or underscore "_" characters. No whitespace \r
+# <Word> ::= (a-zA-Z0-9_)(a-zA-Z0-9_-){0,} Alphanumeric characters with\r
+# optional\r
+# dash "-" and/or underscore "_" characters. No whitespace\r
# characters are permitted.\r
-# \r
+#\r
# @param Word: The word string need to be checked.\r
-# \r
+#\r
def IsValidWord(Word):\r
if not Word:\r
return False\r
not Word[0] == '_' and \\r
not Word[0].isdigit():\r
return False\r
- \r
+\r
LastChar = ''\r
- for Char in Word[1:]: \r
+ for Char in Word[1:]:\r
if (not Char.isalpha()) and \\r
(not Char.isdigit()) and \\r
Char != '-' and \\r
if Char == '.' and LastChar == '.':\r
return False\r
LastChar = Char\r
- \r
+\r
return True\r
\r
\r
## IsValidSimpleWord\r
#\r
# Check whether the SimpleWord is valid.\r
-# <SimpleWord> ::= (a-zA-Z0-9)(a-zA-Z0-9_-){0,} \r
+# <SimpleWord> ::= (a-zA-Z0-9)(a-zA-Z0-9_-){0,}\r
# A word that cannot contain a period character.\r
-# \r
+#\r
# @param Word: The word string need to be checked.\r
-# \r
+#\r
def IsValidSimpleWord(Word):\r
ReIsValidSimpleWord = \\r
re.compile(r"^[0-9A-Za-z][0-9A-Za-z\-_]*$", re.DOTALL)\r
Word = Word.strip()\r
if not Word:\r
return False\r
- \r
+\r
if not ReIsValidSimpleWord.match(Word):\r
return False\r
- \r
+\r
return True\r
\r
## IsValidDecVersion\r
#\r
# Check whether the decimal version is valid.\r
# <DecVersion> ::= (0-9){1,} ["." (0-9){1,}]\r
-# \r
+#\r
# @param Word: The word string need to be checked.\r
-# \r
+#\r
def IsValidDecVersion(Word):\r
if Word.find('.') > -1:\r
ReIsValidDecVersion = re.compile(r"[0-9]+\.?[0-9]+$")\r
else:\r
ReIsValidDecVersion = re.compile(r"[0-9]+$")\r
if ReIsValidDecVersion.match(Word) is None:\r
- return False \r
+ return False\r
return True\r
- \r
+\r
## IsValidHexVersion\r
#\r
# Check whether the hex version is valid.\r
# <HexVersion> ::= "0x" <Major> <Minor>\r
# <Major> ::= <HexDigit>{4}\r
# <Minor> ::= <HexDigit>{4}\r
-# \r
+#\r
# @param Word: The word string need to be checked.\r
-# \r
+#\r
def IsValidHexVersion(Word):\r
ReIsValidHexVersion = re.compile(r"[0][xX][0-9A-Fa-f]{8}$", re.DOTALL)\r
if ReIsValidHexVersion.match(Word) is None:\r
return False\r
- \r
+\r
return True\r
\r
## IsValidBuildNumber\r
#\r
# Check whether the BUILD_NUMBER is valid.\r
# ["BUILD_NUMBER" "=" <Integer>{1,4} <EOL>]\r
-# \r
+#\r
# @param Word: The BUILD_NUMBER string need to be checked.\r
-# \r
+#\r
def IsValidBuildNumber(Word):\r
ReIsValieBuildNumber = re.compile(r"[0-9]{1,4}$", re.DOTALL)\r
if ReIsValieBuildNumber.match(Word) is None:\r
return False\r
- \r
+\r
return True\r
\r
## IsValidDepex\r
#\r
# Check whether the Depex is valid.\r
-# \r
+#\r
# @param Word: The Depex string need to be checked.\r
-# \r
+#\r
def IsValidDepex(Word):\r
Index = Word.upper().find("PUSH")\r
if Index > -1:\r
ReIsValidCName = re.compile(r"^[A-Za-z_][0-9A-Za-z_\s\.]*$", re.DOTALL)\r
if ReIsValidCName.match(Word) is None:\r
return False\r
- \r
+\r
return True\r
\r
## IsValidNormalizedString\r
#\r
-# Check \r
+# Check\r
# <NormalizedString> ::= <DblQuote> [{<Word>} {<Space>}]{1,} <DblQuote>\r
# <Space> ::= 0x20\r
#\r
def IsValidNormalizedString(String):\r
if String == '':\r
return True\r
- \r
+\r
for Char in String:\r
if Char == '\t':\r
return False\r
- \r
+\r
StringList = GetSplitValueList(String, TAB_SPACE_SPLIT)\r
- \r
+\r
for Item in StringList:\r
if not Item:\r
continue\r
if not IsValidWord(Item):\r
return False\r
- \r
+\r
return True\r
\r
## IsValidIdString\r
#\r
# Check whether the IdString is valid.\r
-# \r
+#\r
# @param IdString: The IdString need to be checked.\r
-# \r
+#\r
def IsValidIdString(String):\r
if IsValidSimpleWord(String.strip()):\r
return True\r
- \r
+\r
if String.strip().startswith('"') and \\r
String.strip().endswith('"'):\r
String = String[1:-1]\r
return True\r
if IsValidNormalizedString(String):\r
return True\r
- \r
+\r
return False\r
\r
## IsValidVersionString\r
# <WhiteSpace> ::= {<Tab>} {<Space>}\r
# <Tab> ::= 0x09\r
# <Space> ::= 0x20\r
-# <AsciiChars> ::= (0x21 - 0x7E) \r
-# \r
+# <AsciiChars> ::= (0x21 - 0x7E)\r
+#\r
# @param VersionString: The VersionString need to be checked.\r
-# \r
+#\r
def IsValidVersionString(VersionString):\r
VersionString = VersionString.strip()\r
for Char in VersionString:\r
if not (Char >= 0x21 and Char <= 0x7E):\r
return False\r
- \r
+\r
return True\r
\r
## IsValidPcdValue\r
#\r
# Check whether the PcdValue is valid.\r
-# \r
+#\r
# @param VersionString: The PcdValue need to be checked.\r
-# \r
+#\r
def IsValidPcdValue(PcdValue):\r
for Char in PcdValue:\r
if Char == '\n' or Char == '\t' or Char == '\f':\r
return False\r
- \r
+\r
#\r
# <Boolean>\r
#\r
if IsValidFeatureFlagExp(PcdValue, True)[0]:\r
return True\r
- \r
+\r
#\r
# <Number> ::= {<Integer>} {<HexNumber>}\r
# <Integer> ::= {(0-9)} {(1-9)(0-9){1,}}\r
# <HexNumber> ::= "0x" <HexDigit>{1,}\r
# <HexDigit> ::= (a-fA-F0-9)\r
- # \r
+ #\r
if IsValidHex(PcdValue):\r
return True\r
- \r
+\r
ReIsValidIntegerSingle = re.compile(r"^\s*[0-9]\s*$", re.DOTALL)\r
if ReIsValidIntegerSingle.match(PcdValue) is not None:\r
return True\r
- \r
- ReIsValidIntegerMulti = re.compile(r"^\s*[1-9][0-9]+\s*$", re.DOTALL) \r
+\r
+ ReIsValidIntegerMulti = re.compile(r"^\s*[1-9][0-9]+\s*$", re.DOTALL)\r
if ReIsValidIntegerMulti.match(PcdValue) is not None:\r
return True\r
- \r
+\r
#\r
# <StringVal> ::= {<StringType>} {<Array>} {"$(" <MACRO> ")"}\r
# <StringType> ::= {<UnicodeString>} {<CString>}\r
IsTrue = True\r
if IsTrue:\r
return IsTrue\r
- \r
+\r
#\r
# <Array> ::= {<CArray>} {<NList>} {<CFormatGUID>}\r
# <CArray> ::= "{" [<NList>] <CArray>{0,} "}"\r
#\r
if IsValidCFormatGuid(PcdValue):\r
return True\r
- \r
+\r
ReIsValidByteHex = re.compile(r"^\s*0x[0-9a-fA-F]{1,2}\s*$", re.DOTALL)\r
if PcdValue.strip().startswith('{') and PcdValue.strip().endswith('}') :\r
StringValue = PcdValue.strip().lstrip('{').rstrip('}')\r
ValueList = StringValue.split(',')\r
AllValidFlag = True\r
- for ValueItem in ValueList: \r
+ for ValueItem in ValueList:\r
if not ReIsValidByteHex.match(ValueItem.strip()):\r
AllValidFlag = False\r
- \r
+\r
if AllValidFlag:\r
return True\r
- \r
- # \r
+\r
+ #\r
# NList\r
#\r
AllValidFlag = True\r
ValueList = PcdValue.split(',')\r
- for ValueItem in ValueList: \r
+ for ValueItem in ValueList:\r
if not ReIsValidByteHex.match(ValueItem.strip()):\r
AllValidFlag = False\r
- \r
+\r
if AllValidFlag:\r
return True\r
- \r
+\r
return False\r
\r
## IsValidCVariableName\r
#\r
# Check whether the PcdValue is valid.\r
-# \r
+#\r
# @param VersionString: The PcdValue need to be checked.\r
-# \r
+#\r
def IsValidCVariableName(CName):\r
ReIsValidCName = re.compile(r"^[A-Za-z_][0-9A-Za-z_]*$", re.DOTALL)\r
if ReIsValidCName.match(CName) is None:\r
return False\r
- \r
+\r
return True\r
\r
## IsValidIdentifier\r
ReIdent = re.compile(r"^[A-Za-z_][0-9A-Za-z_]*$", re.DOTALL)\r
if ReIdent.match(Ident) is None:\r
return False\r
- \r
+\r
return True\r
\r
## IsValidDecVersionVal\r
#\r
def IsValidDecVersionVal(Ver):\r
ReVersion = re.compile(r"[0-9]+(\.[0-9]{1,2})$")\r
- \r
+\r
if ReVersion.match(Ver) is None:\r
return False\r
- \r
+\r
return True\r
\r
\r
ReLibName = re.compile("^[A-Z]+[a-zA-Z0-9]*$")\r
if not ReLibName.match(LibName):\r
return False\r
- \r
+\r
return True\r
\r
# IsValidUserId\r
projects / mirror_edk2.git / blobdiff