BaseTools: Replace BSD License with BSD+Patent License

[mirror_edk2.git] / BaseTools / Source / Python / UPT / Library / ParserValidate.py

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