BaseTools: Refactor python except statements

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

## @file\r
# This file is used to check PCD logical expression\r
#\r
# Copyright (c) 2011 - 2014, 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
# http://opensource.org/licenses/bsd-license.php\r
#\r
# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
\r
'''\r
ExpressionValidate\r
'''\r
\r
##\r
# Import Modules\r
#\r
import re\r
from Logger import StringTable as ST\r
\r
## IsValidBareCString\r
#\r
# Check if String is comprised by whitespace(0x20), !(0x21), 0x23 - 0x7E\r
# or '\n', '\t', '\f', '\r', '\b', '\0', '\\'\r
#\r
# @param String: string to be checked\r
#\r
def IsValidBareCString(String):\r
    EscapeList = ['n', 't', 'f', 'r', 'b', '0', '\\', '"']\r
    PreChar = ''\r
    LastChar = ''\r
    for Char in String:\r
        LastChar = Char\r
        if PreChar == '\\':\r
            if Char not in EscapeList:\r
                return False\r
            if Char == '\\':\r
                PreChar = ''\r
                continue\r
        else:\r
            IntChar = ord(Char)\r
            if IntChar != 0x20 and IntChar != 0x09 and IntChar != 0x21 \\r
                and (IntChar < 0x23 or IntChar > 0x7e):\r
                return False\r
        PreChar = Char\r
    \r
    # Last char cannot be \ if PreChar is not \\r
    if LastChar == '\\' and PreChar == LastChar:\r
        return False\r
    return True\r
\r
def _ValidateToken(Token):\r
    Token = Token.strip()\r
    Index = Token.find("\"")\r
    if Index != -1:\r
        return IsValidBareCString(Token[Index+1:-1])\r
    return True\r
\r
## _ExprError\r
#\r
# @param      Exception:    Exception\r
#\r
class _ExprError(Exception):\r
    def __init__(self, Error = ''):\r
        Exception.__init__(self)\r
        self.Error = Error\r
\r
## _ExprBase\r
#\r
class _ExprBase:\r
    HEX_PATTERN = '[\t\s]*0[xX][a-fA-F0-9]+'\r
    INT_PATTERN = '[\t\s]*[0-9]+'\r
    MACRO_PATTERN = '[\t\s]*\$\(([A-Z][_A-Z0-9]*)\)'\r
    PCD_PATTERN = \\r
    '[\t\s]*[_a-zA-Z][a-zA-Z0-9_]*[\t\s]*\.[\t\s]*[_a-zA-Z][a-zA-Z0-9_]*'\r
    QUOTED_PATTERN = '[\t\s]*L?"[^"]*"'\r
    BOOL_PATTERN = '[\t\s]*(true|True|TRUE|false|False|FALSE)'\r
    def __init__(self, Token):\r
        self.Token = Token\r
        self.Index = 0\r
        self.Len = len(Token)\r
    \r
    ## SkipWhitespace\r
    #\r
    def SkipWhitespace(self):\r
        for Char in self.Token[self.Index:]:\r
            if Char not in ' \t':\r
                break\r
            self.Index += 1\r
    \r
    ## IsCurrentOp\r
    #\r
    # @param      OpList:   option list \r
    #    \r
    def IsCurrentOp(self, OpList):\r
        self.SkipWhitespace()\r
        LetterOp = ["EQ", "NE", "GE", "LE", "GT", "LT", "NOT", "and", "AND", \r
                    "or", "OR", "XOR"]\r
        OpMap = {\r
            '|' : '|',\r
            '&' : '&',\r
            '!' : '=',\r
            '>' : '=',\r
            '<' : '='\r
        }\r
        \r
        for Operator in OpList:\r
            if not self.Token[self.Index:].startswith(Operator):\r
                continue\r
            \r
            self.Index += len(Operator)\r
            Char = self.Token[self.Index : self.Index + 1]\r
\r
            if (Operator in LetterOp and (Char == '_' or Char.isalnum())) \\r
                or (Operator in OpMap and OpMap[Operator] == Char):\r
                self.Index -= len(Operator)\r
                break\r
            \r
            return True\r
        \r
        return False\r
\r
## _LogicalExpressionParser\r
#\r
# @param      _ExprBase:   _ExprBase object\r
#    \r
class _LogicalExpressionParser(_ExprBase):\r
    #\r
    # STRINGITEM can only be logical field according to spec\r
    #\r
    STRINGITEM = -1\r
    \r
    #\r
    # Evaluate to True or False\r
    #\r
    LOGICAL = 0\r
    REALLOGICAL = 2\r
    \r
    #\r
    # Just arithmetic expression\r
    #\r
    ARITH = 1\r
    \r
    def __init__(self, Token):\r
        _ExprBase.__init__(self, Token)\r
        self.Parens = 0\r
    \r
    def _CheckToken(self, MatchList):\r
        for Match in MatchList:\r
            if Match and Match.start() == 0:\r
                if not _ValidateToken(\r
                            self.Token[self.Index:self.Index+Match.end()]\r
                        ):\r
                    return False\r
                \r
                self.Index += Match.end()\r
                if self.Token[self.Index - 1] == '"':\r
                    return True\r
                if self.Token[self.Index:self.Index+1] == '_' or \\r
                    self.Token[self.Index:self.Index+1].isalnum():\r
                    self.Index -= Match.end()\r
                    return False\r
                \r
                Token = self.Token[self.Index - Match.end():self.Index]\r
                if Token.strip() in ["EQ", "NE", "GE", "LE", "GT", "LT",\r
                    "NOT", "and", "AND", "or", "OR", "XOR"]:\r
                    self.Index -= Match.end()\r
                    return False\r
                \r
                return True\r
        \r
        return False\r
    \r
    def IsAtomicNumVal(self):\r
        #\r
        # Hex number\r
        #\r
        Match1 = re.compile(self.HEX_PATTERN).match(self.Token[self.Index:])\r
        \r
        #\r
        # Number\r
        #\r
        Match2 = re.compile(self.INT_PATTERN).match(self.Token[self.Index:])\r
        \r
        #\r
        # Macro\r
        #\r
        Match3 = re.compile(self.MACRO_PATTERN).match(self.Token[self.Index:])\r
        \r
        #\r
        # PcdName\r
        #\r
        Match4 = re.compile(self.PCD_PATTERN).match(self.Token[self.Index:])\r
        \r
        return self._CheckToken([Match1, Match2, Match3, Match4])\r
    \r
\r
    def IsAtomicItem(self):\r
        #\r
        # Macro\r
        #\r
        Match1 = re.compile(self.MACRO_PATTERN).match(self.Token[self.Index:])\r
        \r
        #\r
        # PcdName\r
        #\r
        Match2 = re.compile(self.PCD_PATTERN).match(self.Token[self.Index:])\r
        \r
        #\r
        # Quoted string\r
        #\r
        Match3 = re.compile(self.QUOTED_PATTERN).\\r
            match(self.Token[self.Index:].replace('\\\\', '//').\\r
                  replace('\\\"', '\\\''))\r
        \r
        return self._CheckToken([Match1, Match2, Match3])\r
    \r
    ## A || B\r
    #\r
    def LogicalExpression(self):\r
        Ret = self.SpecNot()\r
        while self.IsCurrentOp(['||', 'OR', 'or', '&&', 'AND', 'and', 'XOR', 'xor', '^']):\r
            if self.Token[self.Index-1] == '|' and self.Parens <= 0:\r
                raise  _ExprError(ST.ERR_EXPR_OR % self.Token)\r
            if Ret not in [self.ARITH, self.LOGICAL, self.REALLOGICAL, self.STRINGITEM]:\r
                raise _ExprError(ST.ERR_EXPR_LOGICAL % self.Token)\r
            Ret = self.SpecNot()\r
            if Ret not in [self.ARITH, self.LOGICAL, self.REALLOGICAL, self.STRINGITEM]:\r
                raise _ExprError(ST.ERR_EXPR_LOGICAL % self.Token)\r
            Ret = self.REALLOGICAL\r
        return Ret\r
    \r
    def SpecNot(self):\r
        if self.IsCurrentOp(["NOT", "!", "not"]):\r
            return self.SpecNot()\r
        return self.Rel()\r
    \r
    ## A < B, A > B, A <= B, A >= B\r
    #\r
    def Rel(self):\r
        Ret = self.Expr()\r
        if self.IsCurrentOp(["<=", ">=", ">", "<", "GT", "LT", "GE", "LE",\r
                             "==", "EQ", "!=", "NE"]):\r
            if Ret == self.STRINGITEM:\r
                raise _ExprError(ST.ERR_EXPR_LOGICAL % self.Token)\r
            Ret = self.Expr()\r
            if Ret == self.REALLOGICAL:\r
                raise _ExprError(ST.ERR_EXPR_LOGICAL % self.Token)\r
            Ret = self.REALLOGICAL\r
        return Ret\r
    \r
    ## A + B, A - B\r
    #\r
    def Expr(self):\r
        Ret = self.Factor()\r
        while self.IsCurrentOp(["+", "-", "&", "|", "^", "XOR", "xor"]):\r
            if self.Token[self.Index-1] == '|' and self.Parens <= 0:\r
                raise  _ExprError(ST.ERR_EXPR_OR)\r
            if Ret == self.STRINGITEM or Ret == self.REALLOGICAL:\r
                raise _ExprError(ST.ERR_EXPR_LOGICAL % self.Token)\r
            Ret = self.Factor()\r
            if Ret == self.STRINGITEM or Ret == self.REALLOGICAL:\r
                raise _ExprError(ST.ERR_EXPR_LOGICAL % self.Token)\r
            Ret = self.ARITH\r
        return Ret\r
\r
    ## Factor\r
    #    \r
    def Factor(self):\r
        if self.IsCurrentOp(["("]):\r
            self.Parens += 1\r
            Ret = self.LogicalExpression()\r
            if not self.IsCurrentOp([")"]):\r
                raise _ExprError(ST.ERR_EXPR_RIGHT_PAREN % \\r
                                 (self.Token, self.Token[self.Index:]))\r
            self.Parens -= 1\r
            return Ret\r
        \r
        if self.IsAtomicItem():\r
            if self.Token[self.Index - 1] == '"':\r
                return self.STRINGITEM\r
            return self.LOGICAL\r
        elif self.IsAtomicNumVal():\r
            return self.ARITH\r
        else:\r
            raise _ExprError(ST.ERR_EXPR_FACTOR % \\r
                             (self.Token[self.Index:], self.Token))\r
            \r
    ## IsValidLogicalExpression\r
    #\r
    def IsValidLogicalExpression(self):\r
        if self.Len == 0:\r
            return False, ST.ERR_EXPRESS_EMPTY\r
        try:\r
            if self.LogicalExpression() not in [self.ARITH, self.LOGICAL, self.REALLOGICAL, self.STRINGITEM]:\r
                return False, ST.ERR_EXPR_LOGICAL % self.Token\r
        except _ExprError as XExcept:\r
            return False, XExcept.Error\r
        self.SkipWhitespace()\r
        if self.Index != self.Len:\r
            return False, (ST.ERR_EXPR_BOOLEAN % \\r
                           (self.Token[self.Index:], self.Token))\r
        return True, ''\r
\r
## _ValidRangeExpressionParser\r
#\r
class _ValidRangeExpressionParser(_ExprBase):\r
    INT_RANGE_PATTERN = '[\t\s]*[0-9]+[\t\s]*-[\t\s]*[0-9]+'\r
    HEX_RANGE_PATTERN = \\r
        '[\t\s]*0[xX][a-fA-F0-9]+[\t\s]*-[\t\s]*0[xX][a-fA-F0-9]+'\r
    def __init__(self, Token):\r
        _ExprBase.__init__(self, Token)\r
        self.Parens = 0\r
        self.HEX = 1\r
        self.INT = 2\r
        self.IsParenHappen = False\r
        self.IsLogicalOpHappen = False\r
    \r
    ## IsValidRangeExpression\r
    #\r
    def IsValidRangeExpression(self):\r
        if self.Len == 0:\r
            return False, ST.ERR_EXPR_RANGE_EMPTY\r
        try:\r
            if self.RangeExpression() not in [self.HEX, self.INT]:\r
                return False, ST.ERR_EXPR_RANGE % self.Token\r
        except _ExprError as XExcept:\r
            return False, XExcept.Error\r
        \r
        self.SkipWhitespace()\r
        if self.Index != self.Len:\r
            return False, (ST.ERR_EXPR_RANGE % self.Token)\r
        return True, ''\r
    \r
    ## RangeExpression\r
    #\r
    def RangeExpression(self):\r
        Ret = self.Unary()\r
        while self.IsCurrentOp(['OR', 'AND', 'and', 'or']):\r
            self.IsLogicalOpHappen = True\r
            if not self.IsParenHappen:\r
                raise _ExprError(ST.ERR_PAREN_NOT_USED % self.Token)\r
            self.IsParenHappen = False\r
            Ret = self.Unary()\r
        \r
        if self.IsCurrentOp(['XOR']):\r
            Ret = self.Unary()\r
        \r
        return Ret\r
    \r
    ## Unary\r
    #\r
    def Unary(self):\r
        if self.IsCurrentOp(["NOT"]):\r
            return self.Unary()\r
        \r
        return self.ValidRange()\r
    \r
    ## ValidRange\r
    #    \r
    def ValidRange(self):\r
        Ret = -1\r
        if self.IsCurrentOp(["("]):\r
            self.IsLogicalOpHappen = False\r
            self.IsParenHappen = True\r
            self.Parens += 1\r
            if self.Parens > 1:\r
                raise _ExprError(ST.ERR_EXPR_RANGE_DOUBLE_PAREN_NESTED % self.Token)\r
            Ret = self.RangeExpression()\r
            if not self.IsCurrentOp([")"]):\r
                raise _ExprError(ST.ERR_EXPR_RIGHT_PAREN % self.Token)\r
            self.Parens -= 1\r
            return Ret\r
        \r
        if self.IsLogicalOpHappen:\r
            raise _ExprError(ST.ERR_PAREN_NOT_USED % self.Token)\r
        \r
        if self.IsCurrentOp(["LT", "GT", "LE", "GE", "EQ", "XOR"]):\r
            IntMatch = \\r
                re.compile(self.INT_PATTERN).match(self.Token[self.Index:])\r
            HexMatch = \\r
                re.compile(self.HEX_PATTERN).match(self.Token[self.Index:])\r
            if HexMatch and HexMatch.start() == 0:\r
                self.Index += HexMatch.end()\r
                Ret = self.HEX\r
            elif IntMatch and IntMatch.start() == 0:\r
                self.Index += IntMatch.end()\r
                Ret = self.INT\r
            else:\r
                raise _ExprError(ST.ERR_EXPR_RANGE_FACTOR % (self.Token[self.Index:], self.Token))\r
        else:\r
            IntRangeMatch = re.compile(\r
                self.INT_RANGE_PATTERN).match(self.Token[self.Index:]\r
            )\r
            HexRangeMatch = re.compile(\r
                self.HEX_RANGE_PATTERN).match(self.Token[self.Index:]\r
            )\r
            if HexRangeMatch and HexRangeMatch.start() == 0:\r
                self.Index += HexRangeMatch.end()\r
                Ret = self.HEX\r
            elif IntRangeMatch and IntRangeMatch.start() == 0:\r
                self.Index += IntRangeMatch.end()\r
                Ret = self.INT\r
            else:\r
                raise _ExprError(ST.ERR_EXPR_RANGE % self.Token)\r
\r
        return Ret\r
\r
## _ValidListExpressionParser\r
#\r
class _ValidListExpressionParser(_ExprBase):\r
    VALID_LIST_PATTERN = '(0[xX][0-9a-fA-F]+|[0-9]+)([\t\s]*,[\t\s]*(0[xX][0-9a-fA-F]+|[0-9]+))*'\r
    def __init__(self, Token):\r
        _ExprBase.__init__(self, Token)\r
        self.NUM = 1\r
        \r
    def IsValidListExpression(self):\r
        if self.Len == 0:\r
            return False, ST.ERR_EXPR_LIST_EMPTY\r
        try:\r
            if self.ListExpression() not in [self.NUM]:\r
                return False, ST.ERR_EXPR_LIST % self.Token\r
        except _ExprError as XExcept:\r
            return False, XExcept.Error\r
\r
        self.SkipWhitespace()\r
        if self.Index != self.Len:\r
            return False, (ST.ERR_EXPR_LIST % self.Token)\r
\r
        return True, ''\r
        \r
    def ListExpression(self):\r
        Ret = -1\r
        self.SkipWhitespace()\r
        ListMatch = re.compile(self.VALID_LIST_PATTERN).match(self.Token[self.Index:])\r
        if ListMatch and ListMatch.start() == 0:\r
            self.Index += ListMatch.end()\r
            Ret = self.NUM\r
        else:\r
            raise _ExprError(ST.ERR_EXPR_LIST % self.Token)\r
\r
        return Ret\r
    \r
## _StringTestParser\r
#\r
class _StringTestParser(_ExprBase):\r
    def __init__(self, Token):\r
        _ExprBase.__init__(self, Token)\r
\r
    ## IsValidStringTest\r
    #        \r
    def IsValidStringTest(self):\r
        if self.Len == 0:\r
            return False, ST.ERR_EXPR_EMPTY\r
        try:\r
            self.StringTest()\r
        except _ExprError as XExcept:\r
            return False, XExcept.Error\r
        return True, ''\r
\r
    ## StringItem\r
    #        \r
    def StringItem(self):\r
        Match1 = re.compile(self.QUOTED_PATTERN)\\r
            .match(self.Token[self.Index:].replace('\\\\', '//')\\r
                   .replace('\\\"', '\\\''))\r
        Match2 = re.compile(self.MACRO_PATTERN).match(self.Token[self.Index:])\r
        Match3 = re.compile(self.PCD_PATTERN).match(self.Token[self.Index:])\r
        MatchList = [Match1, Match2, Match3]\r
        for Match in MatchList:\r
            if Match and Match.start() == 0:\r
                if not _ValidateToken(\r
                            self.Token[self.Index:self.Index+Match.end()]\r
                        ):\r
                    raise _ExprError(ST.ERR_EXPR_STRING_ITEM % \\r
                                     (self.Token, self.Token[self.Index:]))\r
                self.Index += Match.end()\r
                Token = self.Token[self.Index - Match.end():self.Index]\r
                if Token.strip() in ["EQ", "NE"]:\r
                    raise _ExprError(ST.ERR_EXPR_STRING_ITEM % \\r
                             (self.Token, self.Token[self.Index:]))\r
                return\r
        else:\r
            raise _ExprError(ST.ERR_EXPR_STRING_ITEM % \\r
                             (self.Token, self.Token[self.Index:]))\r
\r
    ## StringTest\r
    #        \r
    def StringTest(self):\r
        self.StringItem()\r
        if not self.IsCurrentOp(["==", "EQ", "!=", "NE"]):\r
            raise _ExprError(ST.ERR_EXPR_EQUALITY % \\r
                             (self.Token[self.Index:], self.Token))\r
        self.StringItem()\r
        if self.Index != self.Len:\r
            raise _ExprError(ST.ERR_EXPR_BOOLEAN % \\r
                             (self.Token[self.Index:], self.Token))\r
\r
##\r
# Check syntax of string test\r
#\r
# @param Token: string test token\r
#\r
def IsValidStringTest(Token, Flag=False):\r
    #\r
    # Not do the check right now, keep the implementation for future enhancement.\r
    #\r
    if not Flag:\r
        return True, ""\r
    return _StringTestParser(Token).IsValidStringTest()\r
\r
\r
##\r
# Check syntax of logical expression\r
#\r
# @param Token: expression token\r
#\r
def IsValidLogicalExpr(Token, Flag=False):\r
    #\r
    # Not do the check right now, keep the implementation for future enhancement.\r
    #\r
    if not Flag:\r
        return True, ""\r
    return _LogicalExpressionParser(Token).IsValidLogicalExpression()\r
\r
##\r
# Check syntax of range expression\r
#\r
# @param Token: range expression token\r
#\r
def IsValidRangeExpr(Token):\r
    return _ValidRangeExpressionParser(Token).IsValidRangeExpression()\r
\r
##\r
# Check syntax of value list expression token\r
#\r
# @param Token: value list expression token \r
#\r
def IsValidListExpr(Token):\r
    return _ValidListExpressionParser(Token).IsValidListExpression()\r
\r
##\r
# Check whether the feature flag expression is valid or not\r
#\r
# @param Token: feature flag expression\r
#\r
def IsValidFeatureFlagExp(Token, Flag=False):\r
    #\r
    # Not do the check right now, keep the implementation for future enhancement.\r
    #\r
    if not Flag:\r
        return True, "", Token\r
    else:\r
        if Token in ['TRUE', 'FALSE', 'true', 'false', 'True', 'False',\r
                     '0x1', '0x01', '0x0', '0x00']:\r
            return True, ""\r
        Valid, Cause = IsValidStringTest(Token, Flag)\r
        if not Valid:\r
            Valid, Cause = IsValidLogicalExpr(Token, Flag)\r
        if not Valid:\r
            return False, Cause   \r
        return True, ""\r
\r
if __name__ == '__main__':\r
#    print IsValidRangeExpr('LT 9')\r
    print _LogicalExpressionParser('gCrownBayTokenSpaceGuid.PcdPciDevice1BridgeAddressLE0').IsValidLogicalExpression()\r
\r
\r
    \r