[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 - 2018, Intel Corporation. All rights reserved.<BR>\r
#\r
# SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
'''\r
ExpressionValidate\r
'''\r
from __future__ import print_function\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
Commit	Line	Data
4234283c LG	1	## @file\r
	2	# This file is used to check PCD logical expression\r
	3	#\r
f7496d71	4	# Copyright (c) 2011 - 2018, Intel Corporation. All rights reserved.<BR>\r
4234283c	5	#\r
2e351cbe	6	# SPDX-License-Identifier: BSD-2-Clause-Patent\r
4234283c LG	7	\r
	8	'''\r
	9	ExpressionValidate\r
	10	'''\r
1ccc4d89	11	from __future__ import print_function\r
4234283c LG	12	\r
	13	##\r
	14	# Import Modules\r
	15	#\r
	16	import re\r
	17	from Logger import StringTable as ST\r
	18	\r
	19	## IsValidBareCString\r
	20	#\r
	21	# Check if String is comprised by whitespace(0x20), !(0x21), 0x23 - 0x7E\r
	22	# or '\n', '\t', '\f', '\r', '\b', '\0', '\\'\r
	23	#\r
	24	# @param String: string to be checked\r
	25	#\r
	26	def IsValidBareCString(String):\r
	27	EscapeList = ['n', 't', 'f', 'r', 'b', '0', '\\', '"']\r
	28	PreChar = ''\r
	29	LastChar = ''\r
	30	for Char in String:\r
	31	LastChar = Char\r
	32	if PreChar == '\\':\r
	33	if Char not in EscapeList:\r
	34	return False\r
	35	if Char == '\\':\r
	36	PreChar = ''\r
	37	continue\r
	38	else:\r
	39	IntChar = ord(Char)\r
	40	if IntChar != 0x20 and IntChar != 0x09 and IntChar != 0x21 \\r
	41	and (IntChar < 0x23 or IntChar > 0x7e):\r
	42	return False\r
	43	PreChar = Char\r
f7496d71	44	\r
4234283c LG	45	# Last char cannot be \ if PreChar is not \\r
	46	if LastChar == '\\' and PreChar == LastChar:\r
	47	return False\r
	48	return True\r
	49	\r
	50	def _ValidateToken(Token):\r
	51	Token = Token.strip()\r
	52	Index = Token.find("\"")\r
	53	if Index != -1:\r
	54	return IsValidBareCString(Token[Index+1:-1])\r
	55	return True\r
	56	\r
	57	## _ExprError\r
	58	#\r
	59	# @param Exception: Exception\r
	60	#\r
	61	class _ExprError(Exception):\r
	62	def __init__(self, Error = ''):\r
	63	Exception.__init__(self)\r
	64	self.Error = Error\r
	65	\r
	66	## _ExprBase\r
	67	#\r
	68	class _ExprBase:\r
	69	HEX_PATTERN = '[\t\s]*0[xX][a-fA-F0-9]+'\r
	70	INT_PATTERN = '[\t\s]*[0-9]+'\r
	71	MACRO_PATTERN = '[\t\s]\$\(([A-Z][_A-Z0-9])\)'\r
	72	PCD_PATTERN = \\r
	73	'[\t\s][_a-zA-Z][a-zA-Z0-9_][\t\s]\.[\t\s][_a-zA-Z][a-zA-Z0-9_]*'\r
	74	QUOTED_PATTERN = '[\t\s]L?"[^"]"'\r
	75	BOOL_PATTERN = '[\t\s]*(true\|True\|TRUE\|false\|False\|FALSE)'\r
	76	def __init__(self, Token):\r
	77	self.Token = Token\r
	78	self.Index = 0\r
	79	self.Len = len(Token)\r
f7496d71	80	\r
4234283c LG	81	## SkipWhitespace\r
	82	#\r
	83	def SkipWhitespace(self):\r
	84	for Char in self.Token[self.Index:]:\r
	85	if Char not in ' \t':\r
	86	break\r
	87	self.Index += 1\r
f7496d71	88	\r
4234283c LG	89	## IsCurrentOp\r
4234283c LG	90	#\r
f7496d71 LG	91	# @param OpList: option list\r
f7496d71 LG	92	#\r
4234283c LG	93	def IsCurrentOp(self, OpList):\r
4234283c LG	94	self.SkipWhitespace()\r
f7496d71	95	LetterOp = ["EQ", "NE", "GE", "LE", "GT", "LT", "NOT", "and", "AND",\r
4234283c LG	96	"or", "OR", "XOR"]\r
	97	OpMap = {\r
	98	'\|' : '\|',\r
	99	'&' : '&',\r
	100	'!' : '=',\r
	101	'>' : '=',\r
	102	'<' : '='\r
	103	}\r
f7496d71	104	\r
4234283c LG	105	for Operator in OpList:\r
	106	if not self.Token[self.Index:].startswith(Operator):\r
	107	continue\r
f7496d71	108	\r
4234283c LG	109	self.Index += len(Operator)\r
4234283c LG	110	Char = self.Token[self.Index : self.Index + 1]\r
421ccda3	111	\r
4234283c LG	112	if (Operator in LetterOp and (Char == '_' or Char.isalnum())) \\r
	113	or (Operator in OpMap and OpMap[Operator] == Char):\r
	114	self.Index -= len(Operator)\r
	115	break\r
f7496d71	116	\r
4234283c	117	return True\r
f7496d71	118	\r
4234283c LG	119	return False\r
	120	\r
	121	## _LogicalExpressionParser\r
	122	#\r
	123	# @param _ExprBase: _ExprBase object\r
f7496d71	124	#\r
4234283c LG	125	class _LogicalExpressionParser(_ExprBase):\r
	126	#\r
	127	# STRINGITEM can only be logical field according to spec\r
	128	#\r
	129	STRINGITEM = -1\r
f7496d71	130	\r
4234283c LG	131	#\r
	132	# Evaluate to True or False\r
	133	#\r
	134	LOGICAL = 0\r
	135	REALLOGICAL = 2\r
f7496d71	136	\r
4234283c LG	137	#\r
	138	# Just arithmetic expression\r
	139	#\r
	140	ARITH = 1\r
f7496d71	141	\r
4234283c LG	142	def __init__(self, Token):\r
	143	_ExprBase.__init__(self, Token)\r
	144	self.Parens = 0\r
f7496d71	145	\r
4234283c LG	146	def _CheckToken(self, MatchList):\r
	147	for Match in MatchList:\r
	148	if Match and Match.start() == 0:\r
	149	if not _ValidateToken(\r
	150	self.Token[self.Index:self.Index+Match.end()]\r
	151	):\r
	152	return False\r
f7496d71	153	\r
4234283c LG	154	self.Index += Match.end()\r
	155	if self.Token[self.Index - 1] == '"':\r
	156	return True\r
	157	if self.Token[self.Index:self.Index+1] == '_' or \\r
	158	self.Token[self.Index:self.Index+1].isalnum():\r
	159	self.Index -= Match.end()\r
	160	return False\r
f7496d71	161	\r
4234283c LG	162	Token = self.Token[self.Index - Match.end():self.Index]\r
	163	if Token.strip() in ["EQ", "NE", "GE", "LE", "GT", "LT",\r
	164	"NOT", "and", "AND", "or", "OR", "XOR"]:\r
	165	self.Index -= Match.end()\r
	166	return False\r
f7496d71	167	\r
4234283c	168	return True\r
f7496d71	169	\r
4234283c	170	return False\r
f7496d71	171	\r
4234283c LG	172	def IsAtomicNumVal(self):\r
	173	#\r
	174	# Hex number\r
	175	#\r
	176	Match1 = re.compile(self.HEX_PATTERN).match(self.Token[self.Index:])\r
f7496d71	177	\r
4234283c LG	178	#\r
	179	# Number\r
	180	#\r
	181	Match2 = re.compile(self.INT_PATTERN).match(self.Token[self.Index:])\r
f7496d71	182	\r
4234283c LG	183	#\r
	184	# Macro\r
	185	#\r
	186	Match3 = re.compile(self.MACRO_PATTERN).match(self.Token[self.Index:])\r
f7496d71	187	\r
4234283c LG	188	#\r
	189	# PcdName\r
	190	#\r
	191	Match4 = re.compile(self.PCD_PATTERN).match(self.Token[self.Index:])\r
f7496d71	192	\r
4234283c	193	return self._CheckToken([Match1, Match2, Match3, Match4])\r
f7496d71	194	\r
4234283c LG	195	\r
	196	def IsAtomicItem(self):\r
	197	#\r
	198	# Macro\r
	199	#\r
	200	Match1 = re.compile(self.MACRO_PATTERN).match(self.Token[self.Index:])\r
f7496d71	201	\r
4234283c LG	202	#\r
	203	# PcdName\r
	204	#\r
	205	Match2 = re.compile(self.PCD_PATTERN).match(self.Token[self.Index:])\r
f7496d71	206	\r
4234283c LG	207	#\r
	208	# Quoted string\r
	209	#\r
	210	Match3 = re.compile(self.QUOTED_PATTERN).\\r
	211	match(self.Token[self.Index:].replace('\\\\', '//').\\r
	212	replace('\\\"', '\\\''))\r
f7496d71	213	\r
4234283c	214	return self._CheckToken([Match1, Match2, Match3])\r
f7496d71	215	\r
4234283c LG	216	## A \|\| B\r
	217	#\r
	218	def LogicalExpression(self):\r
	219	Ret = self.SpecNot()\r
421ccda3	220	while self.IsCurrentOp(['\|\|', 'OR', 'or', '&&', 'AND', 'and', 'XOR', 'xor', '^']):\r
4234283c	221	if self.Token[self.Index-1] == '\|' and self.Parens <= 0:\r
421ccda3 HC	222	raise _ExprError(ST.ERR_EXPR_OR % self.Token)\r
421ccda3 HC	223	if Ret not in [self.ARITH, self.LOGICAL, self.REALLOGICAL, self.STRINGITEM]:\r
4234283c LG	224	raise _ExprError(ST.ERR_EXPR_LOGICAL % self.Token)\r
4234283c LG	225	Ret = self.SpecNot()\r
421ccda3	226	if Ret not in [self.ARITH, self.LOGICAL, self.REALLOGICAL, self.STRINGITEM]:\r
4234283c LG	227	raise _ExprError(ST.ERR_EXPR_LOGICAL % self.Token)\r
	228	Ret = self.REALLOGICAL\r
	229	return Ret\r
f7496d71	230	\r
4234283c	231	def SpecNot(self):\r
421ccda3	232	if self.IsCurrentOp(["NOT", "!", "not"]):\r
4234283c LG	233	return self.SpecNot()\r
4234283c LG	234	return self.Rel()\r
f7496d71	235	\r
421ccda3	236	## A < B, A > B, A <= B, A >= B\r
4234283c LG	237	#\r
	238	def Rel(self):\r
	239	Ret = self.Expr()\r
	240	if self.IsCurrentOp(["<=", ">=", ">", "<", "GT", "LT", "GE", "LE",\r
	241	"==", "EQ", "!=", "NE"]):\r
421ccda3	242	if Ret == self.STRINGITEM:\r
4234283c LG	243	raise _ExprError(ST.ERR_EXPR_LOGICAL % self.Token)\r
4234283c LG	244	Ret = self.Expr()\r
421ccda3	245	if Ret == self.REALLOGICAL:\r
4234283c LG	246	raise _ExprError(ST.ERR_EXPR_LOGICAL % self.Token)\r
	247	Ret = self.REALLOGICAL\r
	248	return Ret\r
f7496d71	249	\r
4234283c LG	250	## A + B, A - B\r
	251	#\r
	252	def Expr(self):\r
	253	Ret = self.Factor()\r
421ccda3	254	while self.IsCurrentOp(["+", "-", "&", "\|", "^", "XOR", "xor"]):\r
4234283c LG	255	if self.Token[self.Index-1] == '\|' and self.Parens <= 0:\r
	256	raise _ExprError(ST.ERR_EXPR_OR)\r
	257	if Ret == self.STRINGITEM or Ret == self.REALLOGICAL:\r
	258	raise _ExprError(ST.ERR_EXPR_LOGICAL % self.Token)\r
	259	Ret = self.Factor()\r
	260	if Ret == self.STRINGITEM or Ret == self.REALLOGICAL:\r
	261	raise _ExprError(ST.ERR_EXPR_LOGICAL % self.Token)\r
	262	Ret = self.ARITH\r
	263	return Ret\r
	264	\r
	265	## Factor\r
f7496d71	266	#\r
4234283c LG	267	def Factor(self):\r
	268	if self.IsCurrentOp(["("]):\r
	269	self.Parens += 1\r
	270	Ret = self.LogicalExpression()\r
	271	if not self.IsCurrentOp([")"]):\r
	272	raise _ExprError(ST.ERR_EXPR_RIGHT_PAREN % \\r
	273	(self.Token, self.Token[self.Index:]))\r
	274	self.Parens -= 1\r
	275	return Ret\r
f7496d71	276	\r
4234283c LG	277	if self.IsAtomicItem():\r
	278	if self.Token[self.Index - 1] == '"':\r
	279	return self.STRINGITEM\r
	280	return self.LOGICAL\r
	281	elif self.IsAtomicNumVal():\r
	282	return self.ARITH\r
	283	else:\r
	284	raise _ExprError(ST.ERR_EXPR_FACTOR % \\r
421ccda3	285	(self.Token[self.Index:], self.Token))\r
f7496d71	286	\r
4234283c LG	287	## IsValidLogicalExpression\r
	288	#\r
	289	def IsValidLogicalExpression(self):\r
	290	if self.Len == 0:\r
421ccda3	291	return False, ST.ERR_EXPRESS_EMPTY\r
4234283c	292	try:\r
421ccda3	293	if self.LogicalExpression() not in [self.ARITH, self.LOGICAL, self.REALLOGICAL, self.STRINGITEM]:\r
4234283c	294	return False, ST.ERR_EXPR_LOGICAL % self.Token\r
5b0671c1	295	except _ExprError as XExcept:\r
4234283c LG	296	return False, XExcept.Error\r
	297	self.SkipWhitespace()\r
	298	if self.Index != self.Len:\r
	299	return False, (ST.ERR_EXPR_BOOLEAN % \\r
	300	(self.Token[self.Index:], self.Token))\r
	301	return True, ''\r
	302	\r
	303	## _ValidRangeExpressionParser\r
	304	#\r
	305	class _ValidRangeExpressionParser(_ExprBase):\r
	306	INT_RANGE_PATTERN = '[\t\s][0-9]+[\t\s]-[\t\s]*[0-9]+'\r
	307	HEX_RANGE_PATTERN = \\r
	308	'[\t\s]0[xX][a-fA-F0-9]+[\t\s]-[\t\s]*0[xX][a-fA-F0-9]+'\r
	309	def __init__(self, Token):\r
	310	_ExprBase.__init__(self, Token)\r
421ccda3 HC	311	self.Parens = 0\r
	312	self.HEX = 1\r
	313	self.INT = 2\r
	314	self.IsParenHappen = False\r
	315	self.IsLogicalOpHappen = False\r
f7496d71	316	\r
4234283c LG	317	## IsValidRangeExpression\r
	318	#\r
	319	def IsValidRangeExpression(self):\r
	320	if self.Len == 0:\r
421ccda3	321	return False, ST.ERR_EXPR_RANGE_EMPTY\r
4234283c	322	try:\r
421ccda3 HC	323	if self.RangeExpression() not in [self.HEX, self.INT]:\r
421ccda3 HC	324	return False, ST.ERR_EXPR_RANGE % self.Token\r
5b0671c1	325	except _ExprError as XExcept:\r
421ccda3	326	return False, XExcept.Error\r
f7496d71	327	\r
4234283c LG	328	self.SkipWhitespace()\r
4234283c LG	329	if self.Index != self.Len:\r
421ccda3 HC	330	return False, (ST.ERR_EXPR_RANGE % self.Token)\r
421ccda3 HC	331	return True, ''\r
f7496d71	332	\r
4234283c LG	333	## RangeExpression\r
	334	#\r
	335	def RangeExpression(self):\r
421ccda3 HC	336	Ret = self.Unary()\r
	337	while self.IsCurrentOp(['OR', 'AND', 'and', 'or']):\r
	338	self.IsLogicalOpHappen = True\r
	339	if not self.IsParenHappen:\r
	340	raise _ExprError(ST.ERR_PAREN_NOT_USED % self.Token)\r
	341	self.IsParenHappen = False\r
	342	Ret = self.Unary()\r
f7496d71	343	\r
421ccda3 HC	344	if self.IsCurrentOp(['XOR']):\r
421ccda3 HC	345	Ret = self.Unary()\r
f7496d71	346	\r
421ccda3	347	return Ret\r
f7496d71	348	\r
4234283c LG	349	## Unary\r
	350	#\r
	351	def Unary(self):\r
421ccda3	352	if self.IsCurrentOp(["NOT"]):\r
4234283c	353	return self.Unary()\r
f7496d71	354	\r
4234283c	355	return self.ValidRange()\r
f7496d71	356	\r
4234283c	357	## ValidRange\r
f7496d71	358	#\r
4234283c	359	def ValidRange(self):\r
421ccda3	360	Ret = -1\r
4234283c	361	if self.IsCurrentOp(["("]):\r
421ccda3 HC	362	self.IsLogicalOpHappen = False\r
	363	self.IsParenHappen = True\r
	364	self.Parens += 1\r
	365	if self.Parens > 1:\r
	366	raise _ExprError(ST.ERR_EXPR_RANGE_DOUBLE_PAREN_NESTED % self.Token)\r
	367	Ret = self.RangeExpression()\r
4234283c	368	if not self.IsCurrentOp([")"]):\r
421ccda3 HC	369	raise _ExprError(ST.ERR_EXPR_RIGHT_PAREN % self.Token)\r
	370	self.Parens -= 1\r
	371	return Ret\r
f7496d71	372	\r
421ccda3 HC	373	if self.IsLogicalOpHappen:\r
421ccda3 HC	374	raise _ExprError(ST.ERR_PAREN_NOT_USED % self.Token)\r
f7496d71	375	\r
421ccda3	376	if self.IsCurrentOp(["LT", "GT", "LE", "GE", "EQ", "XOR"]):\r
4234283c LG	377	IntMatch = \\r
	378	re.compile(self.INT_PATTERN).match(self.Token[self.Index:])\r
	379	HexMatch = \\r
	380	re.compile(self.HEX_PATTERN).match(self.Token[self.Index:])\r
	381	if HexMatch and HexMatch.start() == 0:\r
	382	self.Index += HexMatch.end()\r
421ccda3	383	Ret = self.HEX\r
4234283c LG	384	elif IntMatch and IntMatch.start() == 0:\r
4234283c LG	385	self.Index += IntMatch.end()\r
421ccda3	386	Ret = self.INT\r
4234283c	387	else:\r
421ccda3	388	raise _ExprError(ST.ERR_EXPR_RANGE_FACTOR % (self.Token[self.Index:], self.Token))\r
4234283c LG	389	else:\r
	390	IntRangeMatch = re.compile(\r
	391	self.INT_RANGE_PATTERN).match(self.Token[self.Index:]\r
	392	)\r
	393	HexRangeMatch = re.compile(\r
	394	self.HEX_RANGE_PATTERN).match(self.Token[self.Index:]\r
	395	)\r
	396	if HexRangeMatch and HexRangeMatch.start() == 0:\r
	397	self.Index += HexRangeMatch.end()\r
421ccda3	398	Ret = self.HEX\r
4234283c LG	399	elif IntRangeMatch and IntRangeMatch.start() == 0:\r
4234283c LG	400	self.Index += IntRangeMatch.end()\r
421ccda3	401	Ret = self.INT\r
4234283c	402	else:\r
421ccda3 HC	403	raise _ExprError(ST.ERR_EXPR_RANGE % self.Token)\r
	404	\r
	405	return Ret\r
	406	\r
	407	## _ValidListExpressionParser\r
	408	#\r
	409	class _ValidListExpressionParser(_ExprBase):\r
	410	VALID_LIST_PATTERN = '(0[xX][0-9a-fA-F]+\|[0-9]+)([\t\s],[\t\s](0[xX][0-9a-fA-F]+\|[0-9]+))*'\r
	411	def __init__(self, Token):\r
	412	_ExprBase.__init__(self, Token)\r
	413	self.NUM = 1\r
f7496d71	414	\r
421ccda3 HC	415	def IsValidListExpression(self):\r
	416	if self.Len == 0:\r
	417	return False, ST.ERR_EXPR_LIST_EMPTY\r
	418	try:\r
	419	if self.ListExpression() not in [self.NUM]:\r
	420	return False, ST.ERR_EXPR_LIST % self.Token\r
5b0671c1	421	except _ExprError as XExcept:\r
421ccda3	422	return False, XExcept.Error\r
4234283c	423	\r
421ccda3 HC	424	self.SkipWhitespace()\r
	425	if self.Index != self.Len:\r
	426	return False, (ST.ERR_EXPR_LIST % self.Token)\r
	427	\r
	428	return True, ''\r
f7496d71	429	\r
421ccda3 HC	430	def ListExpression(self):\r
	431	Ret = -1\r
	432	self.SkipWhitespace()\r
	433	ListMatch = re.compile(self.VALID_LIST_PATTERN).match(self.Token[self.Index:])\r
	434	if ListMatch and ListMatch.start() == 0:\r
	435	self.Index += ListMatch.end()\r
	436	Ret = self.NUM\r
	437	else:\r
	438	raise _ExprError(ST.ERR_EXPR_LIST % self.Token)\r
	439	\r
	440	return Ret\r
f7496d71	441	\r
4234283c LG	442	## _StringTestParser\r
	443	#\r
	444	class _StringTestParser(_ExprBase):\r
	445	def __init__(self, Token):\r
	446	_ExprBase.__init__(self, Token)\r
	447	\r
	448	## IsValidStringTest\r
f7496d71	449	#\r
4234283c LG	450	def IsValidStringTest(self):\r
	451	if self.Len == 0:\r
	452	return False, ST.ERR_EXPR_EMPTY\r
	453	try:\r
	454	self.StringTest()\r
5b0671c1	455	except _ExprError as XExcept:\r
4234283c LG	456	return False, XExcept.Error\r
	457	return True, ''\r
	458	\r
	459	## StringItem\r
f7496d71	460	#\r
4234283c LG	461	def StringItem(self):\r
	462	Match1 = re.compile(self.QUOTED_PATTERN)\\r
	463	.match(self.Token[self.Index:].replace('\\\\', '//')\\r
	464	.replace('\\\"', '\\\''))\r
	465	Match2 = re.compile(self.MACRO_PATTERN).match(self.Token[self.Index:])\r
	466	Match3 = re.compile(self.PCD_PATTERN).match(self.Token[self.Index:])\r
	467	MatchList = [Match1, Match2, Match3]\r
	468	for Match in MatchList:\r
	469	if Match and Match.start() == 0:\r
	470	if not _ValidateToken(\r
	471	self.Token[self.Index:self.Index+Match.end()]\r
	472	):\r
	473	raise _ExprError(ST.ERR_EXPR_STRING_ITEM % \\r
	474	(self.Token, self.Token[self.Index:]))\r
	475	self.Index += Match.end()\r
	476	Token = self.Token[self.Index - Match.end():self.Index]\r
	477	if Token.strip() in ["EQ", "NE"]:\r
	478	raise _ExprError(ST.ERR_EXPR_STRING_ITEM % \\r
	479	(self.Token, self.Token[self.Index:]))\r
	480	return\r
	481	else:\r
	482	raise _ExprError(ST.ERR_EXPR_STRING_ITEM % \\r
	483	(self.Token, self.Token[self.Index:]))\r
	484	\r
	485	## StringTest\r
f7496d71	486	#\r
4234283c LG	487	def StringTest(self):\r
	488	self.StringItem()\r
	489	if not self.IsCurrentOp(["==", "EQ", "!=", "NE"]):\r
	490	raise _ExprError(ST.ERR_EXPR_EQUALITY % \\r
421ccda3	491	(self.Token[self.Index:], self.Token))\r
4234283c LG	492	self.StringItem()\r
	493	if self.Index != self.Len:\r
	494	raise _ExprError(ST.ERR_EXPR_BOOLEAN % \\r
	495	(self.Token[self.Index:], self.Token))\r
	496	\r
	497	##\r
421ccda3	498	# Check syntax of string test\r
4234283c	499	#\r
421ccda3	500	# @param Token: string test token\r
4234283c	501	#\r
421ccda3	502	def IsValidStringTest(Token, Flag=False):\r
4234283c LG	503	#\r
	504	# Not do the check right now, keep the implementation for future enhancement.\r
	505	#\r
	506	if not Flag:\r
	507	return True, ""\r
421ccda3 HC	508	return _StringTestParser(Token).IsValidStringTest()\r
421ccda3 HC	509	\r
4234283c LG	510	\r
4234283c LG	511	##\r
421ccda3	512	# Check syntax of logical expression\r
4234283c	513	#\r
421ccda3	514	# @param Token: expression token\r
4234283c	515	#\r
421ccda3	516	def IsValidLogicalExpr(Token, Flag=False):\r
4234283c LG	517	#\r
	518	# Not do the check right now, keep the implementation for future enhancement.\r
	519	#\r
	520	if not Flag:\r
	521	return True, ""\r
421ccda3	522	return _LogicalExpressionParser(Token).IsValidLogicalExpression()\r
4234283c LG	523	\r
	524	##\r
	525	# Check syntax of range expression\r
	526	#\r
	527	# @param Token: range expression token\r
	528	#\r
	529	def IsValidRangeExpr(Token):\r
	530	return _ValidRangeExpressionParser(Token).IsValidRangeExpression()\r
	531	\r
421ccda3 HC	532	##\r
	533	# Check syntax of value list expression token\r
	534	#\r
f7496d71	535	# @param Token: value list expression token\r
421ccda3 HC	536	#\r
	537	def IsValidListExpr(Token):\r
	538	return _ValidListExpressionParser(Token).IsValidListExpression()\r
	539	\r
4234283c LG	540	##\r
	541	# Check whether the feature flag expression is valid or not\r
	542	#\r
	543	# @param Token: feature flag expression\r
	544	#\r
	545	def IsValidFeatureFlagExp(Token, Flag=False):\r
	546	#\r
	547	# Not do the check right now, keep the implementation for future enhancement.\r
	548	#\r
	549	if not Flag:\r
	550	return True, "", Token\r
	551	else:\r
	552	if Token in ['TRUE', 'FALSE', 'true', 'false', 'True', 'False',\r
	553	'0x1', '0x01', '0x0', '0x00']:\r
	554	return True, ""\r
	555	Valid, Cause = IsValidStringTest(Token, Flag)\r
	556	if not Valid:\r
	557	Valid, Cause = IsValidLogicalExpr(Token, Flag)\r
	558	if not Valid:\r
f7496d71	559	return False, Cause\r
4234283c LG	560	return True, ""\r
	561	\r
	562	if __name__ == '__main__':\r
421ccda3	563	# print IsValidRangeExpr('LT 9')\r
72443dd2	564	print(_LogicalExpressionParser('gCrownBayTokenSpaceGuid.PcdPciDevice1BridgeAddressLE0').IsValidLogicalExpression())\r
421ccda3 HC	565	\r
421ccda3 HC	566	\r
f7496d71	567	\r