ExpressionValidate.py revision 4fd606d1f5abe38e1f42c38de1d2e895166bd0f4
## @file
# This file is used to check PCD logical expression
#
# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>
#
# This program and the accompanying materials are licensed and made available
# under the terms and conditions of the BSD License which accompanies this
# distribution. The full text of the license may be found at
#
# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
'''
ExpressionValidate
'''
##
# Import Modules
#
import re
## IsValidBareCString
#
# Check if String is comprised by whitespace(0x20), !(0x21), 0x23 - 0x7E
# or '\n', '\t', '\f', '\r', '\b', '\0', '\\'
#
# @param String: string to be checked
#
def IsValidBareCString(String):
PreChar = ''
LastChar = ''
if PreChar == '\\':
if Char not in EscapeList:
return False
if Char == '\\':
PreChar = ''
continue
else:
return False
# Last char cannot be \ if PreChar is not \
return False
return True
def _ValidateToken(Token):
if Index != -1:
return True
## _ExprError
#
# @param Exception: Exception
#
class _ExprError(Exception):
## _ExprBase
#
class _ExprBase:
HEX_PATTERN = '[\t\s]*0[xX][a-fA-F0-9]+'
INT_PATTERN = '[\t\s]*[0-9]+'
MACRO_PATTERN = '[\t\s]*\$\(([A-Z][_A-Z0-9]*)\)'
PCD_PATTERN = \
'[\t\s]*[_a-zA-Z][a-zA-Z0-9_]*[\t\s]*\.[\t\s]*[_a-zA-Z][a-zA-Z0-9_]*'
QUOTED_PATTERN = '[\t\s]*L?"[^"]*"'
BOOL_PATTERN = '[\t\s]*(true|True|TRUE|false|False|FALSE)'
## SkipWhitespace
#
def SkipWhitespace(self):
if Char not in ' \t':
break
## IsCurrentOp
#
# @param OpList: option list
#
"or", "OR", "XOR"]
OpMap = {
'|' : '|',
'&' : '&',
'!' : '=',
'>' : '=',
'<' : '='
}
continue
break
return True
return False
## _LogicalExpressionParser
#
# @param _ExprBase: _ExprBase object
#
class _LogicalExpressionParser(_ExprBase):
#
# STRINGITEM can only be logical field according to spec
#
STRINGITEM = -1
#
# Evaluate to True or False
#
LOGICAL = 0
REALLOGICAL = 2
#
# Just arithmetic expression
#
ARITH = 1
if not _ValidateToken(
):
return False
return True
return False
"NOT", "and", "AND", "or", "OR", "XOR"]:
return False
return True
return False
def IsAtomicNumVal(self):
#
# Hex number
#
#
# Number
#
#
# Macro
#
#
# PcdName
#
def IsAtomicItem(self):
#
# Macro
#
#
# PcdName
#
#
# Quoted string
#
## A || B
#
def LogicalExpression(self):
return Ret
## A < B, A > B, A <= B, A >= b
#
"==", "EQ", "!=", "NE"]):
return Ret
## A + B, A - B
#
return Ret
## Factor
#
return Ret
if self.IsAtomicItem():
return self.STRINGITEM
elif self.IsAtomicNumVal():
else:
## IsValidLogicalExpression
#
def IsValidLogicalExpression(self):
try:
except _ExprError, XExcept:
return True, ''
## _ValidRangeExpressionParser
#
class _ValidRangeExpressionParser(_ExprBase):
INT_RANGE_PATTERN = '[\t\s]*[0-9]+[\t\s]*-[\t\s]*[0-9]+'
'[\t\s]*0[xX][a-fA-F0-9]+[\t\s]*-[\t\s]*0[xX][a-fA-F0-9]+'
## IsValidRangeExpression
#
def IsValidRangeExpression(self):
return False
try:
except _ExprError:
return False
return False
return True
## RangeExpression
#
def RangeExpression(self):
## Unary
#
return self.ValidRange()
## ValidRange
#
def ValidRange(self):
raise _ExprError('')
return
IntMatch = \
HexMatch = \
else:
raise _ExprError('')
else:
)
)
else:
raise _ExprError('')
raise _ExprError('')
## _StringTestParser
#
class _StringTestParser(_ExprBase):
## IsValidStringTest
#
def IsValidStringTest(self):
try:
except _ExprError, XExcept:
return True, ''
## StringItem
#
def StringItem(self):
if not _ValidateToken(
):
return
else:
## StringTest
#
def StringTest(self):
##
# Check syntax of logical expression
#
# @param Token: expression token
#
#
# Not do the check right now, keep the implementation for future enhancement.
#
if not Flag:
return True, ""
##
# Check syntax of string test
#
# @param Token: string test token
#
#
# Not do the check right now, keep the implementation for future enhancement.
#
if not Flag:
return True, ""
##
# Check syntax of range expression
#
# @param Token: range expression token
#
def IsValidRangeExpr(Token):
##
# Check whether the feature flag expression is valid or not
#
# @param Token: feature flag expression
#
#
# Not do the check right now, keep the implementation for future enhancement.
#
if not Flag:
else:
'0x1', '0x01', '0x0', '0x00']:
return True, ""
if not Valid:
if not Valid:
return True, ""
if __name__ == '__main__':