mirror of
https://github.com/CloverHackyColor/CloverBootloader.git
synced 2024-12-28 17:08:18 +01:00
728 lines
19 KiB
Python
Executable File
728 lines
19 KiB
Python
Executable File
## @file ParserValidate.py
|
|
# Functions for parser validation
|
|
#
|
|
# Copyright (c) 2011 - 2018, Intel Corporation. All rights reserved.<BR>
|
|
#
|
|
# SPDX-License-Identifier: BSD-2-Clause-Patent
|
|
#
|
|
|
|
'''
|
|
ParserValidate
|
|
'''
|
|
|
|
import os.path
|
|
import re
|
|
import platform
|
|
|
|
from Library.DataType import MODULE_LIST
|
|
from Library.DataType import COMPONENT_TYPE_LIST
|
|
from Library.DataType import PCD_USAGE_TYPE_LIST_OF_MODULE
|
|
from Library.DataType import TAB_SPACE_SPLIT
|
|
from Library.StringUtils import GetSplitValueList
|
|
from Library.ExpressionValidate import IsValidBareCString
|
|
from Library.ExpressionValidate import IsValidFeatureFlagExp
|
|
from Common.MultipleWorkspace import MultipleWorkspace as mws
|
|
|
|
## __HexDigit() method
|
|
#
|
|
# Whether char input is a Hex data bit
|
|
#
|
|
# @param TempChar: The char to test
|
|
#
|
|
def __HexDigit(TempChar):
|
|
if (TempChar >= 'a' and TempChar <= 'f') or \
|
|
(TempChar >= 'A' and TempChar <= 'F') \
|
|
or (TempChar >= '0' and TempChar <= '9'):
|
|
return True
|
|
else:
|
|
return False
|
|
|
|
## IsValidHex() method
|
|
#
|
|
# Whether char input is a Hex data.
|
|
#
|
|
# @param TempChar: The char to test
|
|
#
|
|
def IsValidHex(HexStr):
|
|
if not HexStr.upper().startswith("0X"):
|
|
return False
|
|
CharList = [c for c in HexStr[2:] if not __HexDigit(c)]
|
|
if len(CharList) == 0:
|
|
return True
|
|
else:
|
|
return False
|
|
|
|
## Judge the input string is valid bool type or not.
|
|
#
|
|
# <TRUE> ::= {"TRUE"} {"true"} {"True"} {"0x1"} {"0x01"}
|
|
# <FALSE> ::= {"FALSE"} {"false"} {"False"} {"0x0"} {"0x00"}
|
|
# <BoolType> ::= {<TRUE>} {<FALSE>}
|
|
#
|
|
# @param BoolString: A string contained the value need to be judged.
|
|
#
|
|
def IsValidBoolType(BoolString):
|
|
#
|
|
# Valid True
|
|
#
|
|
if BoolString == 'TRUE' or \
|
|
BoolString == 'True' or \
|
|
BoolString == 'true' or \
|
|
BoolString == '0x1' or \
|
|
BoolString == '0x01':
|
|
return True
|
|
#
|
|
# Valid False
|
|
#
|
|
elif BoolString == 'FALSE' or \
|
|
BoolString == 'False' or \
|
|
BoolString == 'false' or \
|
|
BoolString == '0x0' or \
|
|
BoolString == '0x00':
|
|
return True
|
|
#
|
|
# Invalid bool type
|
|
#
|
|
else:
|
|
return False
|
|
|
|
## Is Valid Module Type List or not
|
|
#
|
|
# @param ModuleTypeList: A list contain ModuleType strings need to be
|
|
# judged.
|
|
#
|
|
def IsValidInfMoudleTypeList(ModuleTypeList):
|
|
for ModuleType in ModuleTypeList:
|
|
return IsValidInfMoudleType(ModuleType)
|
|
|
|
## Is Valid Module Type or not
|
|
#
|
|
# @param ModuleType: A string contain ModuleType need to be judged.
|
|
#
|
|
def IsValidInfMoudleType(ModuleType):
|
|
if ModuleType in MODULE_LIST:
|
|
return True
|
|
else:
|
|
return False
|
|
|
|
## Is Valid Component Type or not
|
|
#
|
|
# @param ComponentType: A string contain ComponentType need to be judged.
|
|
#
|
|
def IsValidInfComponentType(ComponentType):
|
|
if ComponentType.upper() in COMPONENT_TYPE_LIST:
|
|
return True
|
|
else:
|
|
return False
|
|
|
|
|
|
## Is valid Tool Family or not
|
|
#
|
|
# @param ToolFamily: A string contain Tool Family need to be judged.
|
|
# Family := [A-Z]([a-zA-Z0-9])*
|
|
#
|
|
def IsValidToolFamily(ToolFamily):
|
|
ReIsValidFamily = re.compile(r"^[A-Z]+[A-Za-z0-9]{0,}$", re.DOTALL)
|
|
if ReIsValidFamily.match(ToolFamily) is None:
|
|
return False
|
|
return True
|
|
|
|
## Is valid Tool TagName or not
|
|
#
|
|
# The TagName sample is MYTOOLS and VS2005.
|
|
#
|
|
# @param TagName: A string contain Tool TagName need to be judged.
|
|
#
|
|
def IsValidToolTagName(TagName):
|
|
if TagName.strip() == '':
|
|
return True
|
|
if TagName.strip() == '*':
|
|
return True
|
|
if not IsValidWord(TagName):
|
|
return False
|
|
return True
|
|
|
|
## Is valid arch or not
|
|
#
|
|
# @param Arch The arch string need to be validated
|
|
# <OA> ::= (a-zA-Z)(A-Za-z0-9){0,}
|
|
# <arch> ::= {"IA32"} {"X64"} {"IPF"} {"EBC"} {<OA>}
|
|
# {"common"}
|
|
# @param Arch: Input arch
|
|
#
|
|
def IsValidArch(Arch):
|
|
if Arch == 'common':
|
|
return True
|
|
ReIsValidArch = re.compile(r"^[a-zA-Z]+[a-zA-Z0-9]{0,}$", re.DOTALL)
|
|
if ReIsValidArch.match(Arch) is None:
|
|
return False
|
|
return True
|
|
|
|
## Is valid family or not
|
|
#
|
|
# <Family> ::= {"MSFT"} {"GCC"} {"INTEL"} {<Usr>} {"*"}
|
|
# <Usr> ::= [A-Z][A-Za-z0-9]{0,}
|
|
#
|
|
# @param family: The family string need to be validated
|
|
#
|
|
def IsValidFamily(Family):
|
|
Family = Family.strip()
|
|
if Family == '*':
|
|
return True
|
|
|
|
if Family == '':
|
|
return True
|
|
|
|
ReIsValidFamily = re.compile(r"^[A-Z]+[A-Za-z0-9]{0,}$", re.DOTALL)
|
|
if ReIsValidFamily.match(Family) is None:
|
|
return False
|
|
return True
|
|
|
|
## Is valid build option name or not
|
|
#
|
|
# @param BuildOptionName: The BuildOptionName string need to be validated
|
|
#
|
|
def IsValidBuildOptionName(BuildOptionName):
|
|
if not BuildOptionName:
|
|
return False
|
|
|
|
ToolOptionList = GetSplitValueList(BuildOptionName, '_', 4)
|
|
|
|
if len(ToolOptionList) != 5:
|
|
return False
|
|
|
|
ReIsValidBuildOption1 = re.compile(r"^\s*(\*)|([A-Z][a-zA-Z0-9]*)$")
|
|
ReIsValidBuildOption2 = re.compile(r"^\s*(\*)|([a-zA-Z][a-zA-Z0-9]*)$")
|
|
|
|
if ReIsValidBuildOption1.match(ToolOptionList[0]) is None:
|
|
return False
|
|
|
|
if ReIsValidBuildOption1.match(ToolOptionList[1]) is None:
|
|
return False
|
|
|
|
if ReIsValidBuildOption2.match(ToolOptionList[2]) is None:
|
|
return False
|
|
|
|
if ToolOptionList[3] == "*" and ToolOptionList[4] not in ['FAMILY', 'DLL', 'DPATH']:
|
|
return False
|
|
|
|
return True
|
|
|
|
## IsValidToken
|
|
#
|
|
# Check if pattern string matches total token
|
|
#
|
|
# @param ReString: regular string
|
|
# @param Token: Token to be matched
|
|
#
|
|
def IsValidToken(ReString, Token):
|
|
Match = re.compile(ReString).match(Token)
|
|
return Match and Match.start() == 0 and Match.end() == len(Token)
|
|
|
|
## IsValidPath
|
|
#
|
|
# Check if path exist
|
|
#
|
|
# @param Path: Absolute path or relative path to be checked
|
|
# @param Root: Root path
|
|
#
|
|
def IsValidPath(Path, Root):
|
|
Path = Path.strip()
|
|
OrigPath = Path.replace('\\', '/')
|
|
|
|
Path = os.path.normpath(Path).replace('\\', '/')
|
|
Root = os.path.normpath(Root).replace('\\', '/')
|
|
FullPath = mws.join(Root, Path)
|
|
|
|
if not os.path.exists(FullPath):
|
|
return False
|
|
|
|
#
|
|
# If Path is absolute path.
|
|
# It should be in Root.
|
|
#
|
|
if os.path.isabs(Path):
|
|
if not Path.startswith(Root):
|
|
return False
|
|
return True
|
|
|
|
#
|
|
# Check illegal character
|
|
#
|
|
for Rel in ['/', './', '../']:
|
|
if OrigPath.startswith(Rel):
|
|
return False
|
|
for Rel in ['//', '/./', '/../']:
|
|
if Rel in OrigPath:
|
|
return False
|
|
for Rel in ['/.', '/..', '/']:
|
|
if OrigPath.endswith(Rel):
|
|
return False
|
|
|
|
Path = Path.rstrip('/')
|
|
|
|
#
|
|
# Check relative path
|
|
#
|
|
for Word in Path.split('/'):
|
|
if not IsValidWord(Word):
|
|
return False
|
|
|
|
return True
|
|
|
|
## IsValidInstallPath
|
|
#
|
|
# Check if an install path valid or not.
|
|
#
|
|
# Absolute path or path starts with '.' or path contains '..' are invalid.
|
|
#
|
|
# @param Path: path to be checked
|
|
#
|
|
def IsValidInstallPath(Path):
|
|
if platform.platform().find("Windows") >= 0:
|
|
if os.path.isabs(Path):
|
|
return False
|
|
else:
|
|
if Path[1:2] == ':':
|
|
return False
|
|
if os.path.isabs(Path):
|
|
return False
|
|
if Path.startswith('.'):
|
|
return False
|
|
|
|
if Path.find('..') != -1:
|
|
return False
|
|
|
|
return True
|
|
|
|
|
|
## IsValidCFormatGuid
|
|
#
|
|
# Check if GUID format has the from of {8,4,4,{2,2,2,2,2,2,2,2}}
|
|
#
|
|
# @param Guid: Guid to be checked
|
|
#
|
|
def IsValidCFormatGuid(Guid):
|
|
#
|
|
# Valid: { 0xf0b11735, 0x87a0, 0x4193, {0xb2, 0x66, 0x53, 0x8c, 0x38,
|
|
# 0xaf, 0x48, 0xce }}
|
|
# Invalid: { 0xf0b11735, 0x87a0, 0x4193, {0xb2, 0x66, 0x53, 0x8c, 0x38,
|
|
# 0xaf, 0x48, 0xce }} 0x123
|
|
# Invalid: { 0xf0b1 1735, 0x87a0, 0x4193, {0xb2, 0x66, 0x53, 0x8c, 0x38,
|
|
# 0xaf, 0x48, 0xce }}
|
|
#
|
|
List = ['{', 10, ',', 6, ',', 6, ',{', 4, ',', 4, ',', 4,
|
|
',', 4, ',', 4, ',', 4, ',', 4, ',', 4, '}}']
|
|
Index = 0
|
|
Value = ''
|
|
SepValue = ''
|
|
for Char in Guid:
|
|
if Char not in '{},\t ':
|
|
Value += Char
|
|
continue
|
|
if Value:
|
|
try:
|
|
#
|
|
# Index may out of bound
|
|
#
|
|
if not SepValue or SepValue != List[Index]:
|
|
return False
|
|
Index += 1
|
|
SepValue = ''
|
|
|
|
if not Value.startswith('0x') and not Value.startswith('0X'):
|
|
return False
|
|
|
|
#
|
|
# Index may out of bound
|
|
#
|
|
if not isinstance(List[Index], type(1)) or \
|
|
len(Value) > List[Index] or len(Value) < 3:
|
|
return False
|
|
|
|
#
|
|
# Check if string can be converted to integer
|
|
# Throw exception if not
|
|
#
|
|
int(Value, 16)
|
|
except BaseException:
|
|
#
|
|
# Exception caught means invalid format
|
|
#
|
|
return False
|
|
Value = ''
|
|
Index += 1
|
|
if Char in '{},':
|
|
SepValue += Char
|
|
|
|
return SepValue == '}}' and Value == ''
|
|
|
|
## IsValidPcdType
|
|
#
|
|
# Check whether the PCD type is valid
|
|
#
|
|
# @param PcdTypeString: The PcdType string need to be checked.
|
|
#
|
|
def IsValidPcdType(PcdTypeString):
|
|
if PcdTypeString.upper() in PCD_USAGE_TYPE_LIST_OF_MODULE:
|
|
return True
|
|
else:
|
|
return False
|
|
|
|
## IsValidWord
|
|
#
|
|
# Check whether the word is valid.
|
|
# <Word> ::= (a-zA-Z0-9_)(a-zA-Z0-9_-){0,} Alphanumeric characters with
|
|
# optional
|
|
# dash "-" and/or underscore "_" characters. No whitespace
|
|
# characters are permitted.
|
|
#
|
|
# @param Word: The word string need to be checked.
|
|
#
|
|
def IsValidWord(Word):
|
|
if not Word:
|
|
return False
|
|
#
|
|
# The first char should be alpha, _ or Digit.
|
|
#
|
|
if not Word[0].isalnum() and \
|
|
not Word[0] == '_' and \
|
|
not Word[0].isdigit():
|
|
return False
|
|
|
|
LastChar = ''
|
|
for Char in Word[1:]:
|
|
if (not Char.isalpha()) and \
|
|
(not Char.isdigit()) and \
|
|
Char != '-' and \
|
|
Char != '_' and \
|
|
Char != '.':
|
|
return False
|
|
if Char == '.' and LastChar == '.':
|
|
return False
|
|
LastChar = Char
|
|
|
|
return True
|
|
|
|
|
|
## IsValidSimpleWord
|
|
#
|
|
# Check whether the SimpleWord is valid.
|
|
# <SimpleWord> ::= (a-zA-Z0-9)(a-zA-Z0-9_-){0,}
|
|
# A word that cannot contain a period character.
|
|
#
|
|
# @param Word: The word string need to be checked.
|
|
#
|
|
def IsValidSimpleWord(Word):
|
|
ReIsValidSimpleWord = \
|
|
re.compile(r"^[0-9A-Za-z][0-9A-Za-z\-_]*$", re.DOTALL)
|
|
Word = Word.strip()
|
|
if not Word:
|
|
return False
|
|
|
|
if not ReIsValidSimpleWord.match(Word):
|
|
return False
|
|
|
|
return True
|
|
|
|
## IsValidDecVersion
|
|
#
|
|
# Check whether the decimal version is valid.
|
|
# <DecVersion> ::= (0-9){1,} ["." (0-9){1,}]
|
|
#
|
|
# @param Word: The word string need to be checked.
|
|
#
|
|
def IsValidDecVersion(Word):
|
|
if Word.find('.') > -1:
|
|
ReIsValidDecVersion = re.compile(r"[0-9]+\.?[0-9]+$")
|
|
else:
|
|
ReIsValidDecVersion = re.compile(r"[0-9]+$")
|
|
if ReIsValidDecVersion.match(Word) is None:
|
|
return False
|
|
return True
|
|
|
|
## IsValidHexVersion
|
|
#
|
|
# Check whether the hex version is valid.
|
|
# <HexVersion> ::= "0x" <Major> <Minor>
|
|
# <Major> ::= <HexDigit>{4}
|
|
# <Minor> ::= <HexDigit>{4}
|
|
#
|
|
# @param Word: The word string need to be checked.
|
|
#
|
|
def IsValidHexVersion(Word):
|
|
ReIsValidHexVersion = re.compile(r"[0][xX][0-9A-Fa-f]{8}$", re.DOTALL)
|
|
if ReIsValidHexVersion.match(Word) is None:
|
|
return False
|
|
|
|
return True
|
|
|
|
## IsValidBuildNumber
|
|
#
|
|
# Check whether the BUILD_NUMBER is valid.
|
|
# ["BUILD_NUMBER" "=" <Integer>{1,4} <EOL>]
|
|
#
|
|
# @param Word: The BUILD_NUMBER string need to be checked.
|
|
#
|
|
def IsValidBuildNumber(Word):
|
|
ReIsValieBuildNumber = re.compile(r"[0-9]{1,4}$", re.DOTALL)
|
|
if ReIsValieBuildNumber.match(Word) is None:
|
|
return False
|
|
|
|
return True
|
|
|
|
## IsValidDepex
|
|
#
|
|
# Check whether the Depex is valid.
|
|
#
|
|
# @param Word: The Depex string need to be checked.
|
|
#
|
|
def IsValidDepex(Word):
|
|
Index = Word.upper().find("PUSH")
|
|
if Index > -1:
|
|
return IsValidCFormatGuid(Word[Index+4:].strip())
|
|
|
|
ReIsValidCName = re.compile(r"^[A-Za-z_][0-9A-Za-z_\s\.]*$", re.DOTALL)
|
|
if ReIsValidCName.match(Word) is None:
|
|
return False
|
|
|
|
return True
|
|
|
|
## IsValidNormalizedString
|
|
#
|
|
# Check
|
|
# <NormalizedString> ::= <DblQuote> [{<Word>} {<Space>}]{1,} <DblQuote>
|
|
# <Space> ::= 0x20
|
|
#
|
|
# @param String: string to be checked
|
|
#
|
|
def IsValidNormalizedString(String):
|
|
if String == '':
|
|
return True
|
|
|
|
for Char in String:
|
|
if Char == '\t':
|
|
return False
|
|
|
|
StringList = GetSplitValueList(String, TAB_SPACE_SPLIT)
|
|
|
|
for Item in StringList:
|
|
if not Item:
|
|
continue
|
|
if not IsValidWord(Item):
|
|
return False
|
|
|
|
return True
|
|
|
|
## IsValidIdString
|
|
#
|
|
# Check whether the IdString is valid.
|
|
#
|
|
# @param IdString: The IdString need to be checked.
|
|
#
|
|
def IsValidIdString(String):
|
|
if IsValidSimpleWord(String.strip()):
|
|
return True
|
|
|
|
if String.strip().startswith('"') and \
|
|
String.strip().endswith('"'):
|
|
String = String[1:-1]
|
|
if String.strip() == "":
|
|
return True
|
|
if IsValidNormalizedString(String):
|
|
return True
|
|
|
|
return False
|
|
|
|
## IsValidVersionString
|
|
#
|
|
# Check whether the VersionString is valid.
|
|
# <AsciiString> ::= [ [<WhiteSpace>]{0,} [<AsciiChars>]{0,} ] {0,}
|
|
# <WhiteSpace> ::= {<Tab>} {<Space>}
|
|
# <Tab> ::= 0x09
|
|
# <Space> ::= 0x20
|
|
# <AsciiChars> ::= (0x21 - 0x7E)
|
|
#
|
|
# @param VersionString: The VersionString need to be checked.
|
|
#
|
|
def IsValidVersionString(VersionString):
|
|
VersionString = VersionString.strip()
|
|
for Char in VersionString:
|
|
if not (Char >= 0x21 and Char <= 0x7E):
|
|
return False
|
|
|
|
return True
|
|
|
|
## IsValidPcdValue
|
|
#
|
|
# Check whether the PcdValue is valid.
|
|
#
|
|
# @param VersionString: The PcdValue need to be checked.
|
|
#
|
|
def IsValidPcdValue(PcdValue):
|
|
for Char in PcdValue:
|
|
if Char == '\n' or Char == '\t' or Char == '\f':
|
|
return False
|
|
|
|
#
|
|
# <Boolean>
|
|
#
|
|
if IsValidFeatureFlagExp(PcdValue, True)[0]:
|
|
return True
|
|
|
|
#
|
|
# <Number> ::= {<Integer>} {<HexNumber>}
|
|
# <Integer> ::= {(0-9)} {(1-9)(0-9){1,}}
|
|
# <HexNumber> ::= "0x" <HexDigit>{1,}
|
|
# <HexDigit> ::= (a-fA-F0-9)
|
|
#
|
|
if IsValidHex(PcdValue):
|
|
return True
|
|
|
|
ReIsValidIntegerSingle = re.compile(r"^\s*[0-9]\s*$", re.DOTALL)
|
|
if ReIsValidIntegerSingle.match(PcdValue) is not None:
|
|
return True
|
|
|
|
ReIsValidIntegerMulti = re.compile(r"^\s*[1-9][0-9]+\s*$", re.DOTALL)
|
|
if ReIsValidIntegerMulti.match(PcdValue) is not None:
|
|
return True
|
|
|
|
#
|
|
# <StringVal> ::= {<StringType>} {<Array>} {"$(" <MACRO> ")"}
|
|
# <StringType> ::= {<UnicodeString>} {<CString>}
|
|
#
|
|
ReIsValidStringType = re.compile(r"^\s*[\"L].*[\"]\s*$")
|
|
if ReIsValidStringType.match(PcdValue):
|
|
IsTrue = False
|
|
if PcdValue.strip().startswith('L\"'):
|
|
StringValue = PcdValue.strip().lstrip('L\"').rstrip('\"')
|
|
if IsValidBareCString(StringValue):
|
|
IsTrue = True
|
|
elif PcdValue.strip().startswith('\"'):
|
|
StringValue = PcdValue.strip().lstrip('\"').rstrip('\"')
|
|
if IsValidBareCString(StringValue):
|
|
IsTrue = True
|
|
if IsTrue:
|
|
return IsTrue
|
|
|
|
#
|
|
# <Array> ::= {<CArray>} {<NList>} {<CFormatGUID>}
|
|
# <CArray> ::= "{" [<NList>] <CArray>{0,} "}"
|
|
# <NList> ::= <HexByte> ["," <HexByte>]{0,}
|
|
# <HexDigit> ::= (a-fA-F0-9)
|
|
# <HexByte> ::= "0x" <HexDigit>{1,2}
|
|
#
|
|
if IsValidCFormatGuid(PcdValue):
|
|
return True
|
|
|
|
ReIsValidByteHex = re.compile(r"^\s*0x[0-9a-fA-F]{1,2}\s*$", re.DOTALL)
|
|
if PcdValue.strip().startswith('{') and PcdValue.strip().endswith('}') :
|
|
StringValue = PcdValue.strip().lstrip('{').rstrip('}')
|
|
ValueList = StringValue.split(',')
|
|
AllValidFlag = True
|
|
for ValueItem in ValueList:
|
|
if not ReIsValidByteHex.match(ValueItem.strip()):
|
|
AllValidFlag = False
|
|
|
|
if AllValidFlag:
|
|
return True
|
|
|
|
#
|
|
# NList
|
|
#
|
|
AllValidFlag = True
|
|
ValueList = PcdValue.split(',')
|
|
for ValueItem in ValueList:
|
|
if not ReIsValidByteHex.match(ValueItem.strip()):
|
|
AllValidFlag = False
|
|
|
|
if AllValidFlag:
|
|
return True
|
|
|
|
return False
|
|
|
|
## IsValidCVariableName
|
|
#
|
|
# Check whether the PcdValue is valid.
|
|
#
|
|
# @param VersionString: The PcdValue need to be checked.
|
|
#
|
|
def IsValidCVariableName(CName):
|
|
ReIsValidCName = re.compile(r"^[A-Za-z_][0-9A-Za-z_]*$", re.DOTALL)
|
|
if ReIsValidCName.match(CName) is None:
|
|
return False
|
|
|
|
return True
|
|
|
|
## IsValidIdentifier
|
|
#
|
|
# <Identifier> ::= <NonDigit> <Chars>{0,}
|
|
# <Chars> ::= (a-zA-Z0-9_)
|
|
# <NonDigit> ::= (a-zA-Z_)
|
|
#
|
|
# @param Ident: identifier to be checked
|
|
#
|
|
def IsValidIdentifier(Ident):
|
|
ReIdent = re.compile(r"^[A-Za-z_][0-9A-Za-z_]*$", re.DOTALL)
|
|
if ReIdent.match(Ident) is None:
|
|
return False
|
|
|
|
return True
|
|
|
|
## IsValidDecVersionVal
|
|
#
|
|
# {(0-9){1,} "." (0-99)}
|
|
#
|
|
# @param Ver: version to be checked
|
|
#
|
|
def IsValidDecVersionVal(Ver):
|
|
ReVersion = re.compile(r"[0-9]+(\.[0-9]{1,2})$")
|
|
|
|
if ReVersion.match(Ver) is None:
|
|
return False
|
|
|
|
return True
|
|
|
|
|
|
## IsValidLibName
|
|
#
|
|
# (A-Z)(a-zA-Z0-9){0,} and could not be "NULL"
|
|
#
|
|
def IsValidLibName(LibName):
|
|
if LibName == 'NULL':
|
|
return False
|
|
ReLibName = re.compile("^[A-Z]+[a-zA-Z0-9]*$")
|
|
if not ReLibName.match(LibName):
|
|
return False
|
|
|
|
return True
|
|
|
|
# IsValidUserId
|
|
#
|
|
# <UserId> ::= (a-zA-Z)(a-zA-Z0-9_.){0,}
|
|
# Words that contain period "." must be encapsulated in double quotation marks.
|
|
#
|
|
def IsValidUserId(UserId):
|
|
UserId = UserId.strip()
|
|
Quoted = False
|
|
if UserId.startswith('"') and UserId.endswith('"'):
|
|
Quoted = True
|
|
UserId = UserId[1:-1]
|
|
if not UserId or not UserId[0].isalpha():
|
|
return False
|
|
for Char in UserId[1:]:
|
|
if not Char.isalnum() and not Char in '_.':
|
|
return False
|
|
if Char == '.' and not Quoted:
|
|
return False
|
|
return True
|
|
|
|
#
|
|
# Check if a UTF16-LE file has a BOM header
|
|
#
|
|
def CheckUTF16FileHeader(File):
|
|
FileIn = open(File, 'rb').read(2)
|
|
if FileIn != b'\xff\xfe':
|
|
return False
|
|
|
|
return True
|