def _parseFeatureSignature(sig):
"""This function parses a given feature-signature."""
mal = set()
def _rewriteOne(p): return ''
def _rewriteTwo(p): return ''
def _addIdentifier2Mal(p): mal.add(p[0])
operand = __string | __hexadec | __function | __integer | \
__identifier.setParseAction(_addIdentifier2Mal)
compoperator = pypa.oneOf('< > <= >= == !=')
calcoperator = pypa.oneOf('+ - * / % & | << >>')
expr = pypa.operatorPrecedence(operand, [
('defined', 1, pypa.opAssoc.RIGHT, _rewriteOne),
('!', 1, pypa.opAssoc.RIGHT, _rewriteOne),
(calcoperator, 2, pypa.opAssoc.LEFT, _rewriteTwo),
(compoperator, 2, pypa.opAssoc.LEFT, _rewriteTwo),
('&&', 2, pypa.opAssoc.LEFT, _rewriteTwo),
('||', 2, pypa.opAssoc.LEFT, _rewriteTwo),
])
try:
rsig = expr.parseString(sig)[0]
except pypa.ParseException, e:
print('ERROR (parse): cannot parse sig (%s) -- (%s)' %
(sig, e.col))
return sig
def _parseIfDefExpression(ifdefexp):
"""This function parses a given ifdef-expression and
rewrites the expression according to the given __pt mapping.
This one is used to make use of a csp solver without using
a predicate."""
mal = list()
def _rewriteOne(param):
"""This function returns each one parameter function
representation for csp."""
op, ma = param[0]
mal.append(ma)
if op == '!': ret = op + '(' + ma + ')'
if op == 'defined': ret = ma
return ret
def _rewriteTwo(param):
"""This function returns each two parameter function
representation for csp."""
mal.extend(param[0][0::2])
ret = param[0][1]
ret = '(' + ret.join(map(str, param[0][0::2])) + ')'
return ret
operand = __string | __hexadec | __integer | \
__function | __identifier
operators = pypa.oneOf('&& ||') # extend with furhter operators
expr = pypa.operatorPrecedence(operand, [
('defined', 1, pypa.opAssoc.RIGHT, _rewriteOne),
('!', 1, pypa.opAssoc.RIGHT, _rewriteOne),
(operators, 2, pypa.opAssoc.LEFT, _rewriteTwo),
]) + pypa.StringEnd()
try:
rsig = expr.parseString(ifdefexp)[0]
except pypa.ParseException, e:
print('ERROR (parse): cannot parse sig (%s) -- (%s)' %
(ifdefexp, e.col))
return ifdefexp
def _parseFeatureSignatureAndRewrite(sig):
"""This function parses a given feature-signature and rewrites
the signature according to the given __pt mapping.
"""
# this dictionary holds all transformations of operators from
# the origin (cpp) to the compare (language)
# e.g. in cpp && stands for the 'and'-operator.
# the equivalent in maple (which is used for comparison)
# is '&and'
# if no equivalence can be found a name rewriting is done
# e.g. 'defined'
__pt = {
#'defined' : 'defined_',
'defined' : '',
'!' : '¬',
'&&': '&and',
'||': '&or',
'<' : '<',
'>' : '>',
'<=': '<=',
'>=': '>=',
'==': '=',
'!=': '!=',
'*' : '*', # needs rewriting with parenthesis
'/' : '/',
'%' : '', # needs rewriting a % b => modp(a, b)
'+' : '+',
'-' : '-',
'&' : '', # needs rewriting a & b => BitAnd(a, b)
'|' : '', # needs rewriting a | b => BitOr(a, b)
'>>': '>>', # needs rewriting a >> b => a / (2^b)
'<<': '<<', # needs rewriting a << b => a * (2^b)
}
def _rewriteOne(param):
"""This function returns each one parameter function
representation for maple."""
if param[0][0] == '!':
ret = __pt[param[0][0]] + '(' + str(param[0][1]) + ')'
if param[0][0] == 'defined':
ret = __pt[param[0][0]] + str(param[0][1])
return ret
def _rewriteTwo(param):
"""This function returns each two parameter function
representation for maple."""
# rewriting rules
if param[0][1] == '%':
return 'modp(' + param[0][0] + ',' + param[0][2] + ')'
ret = ' ' + __pt[param[0][1]] + ' '
ret = '(' + ret.join(map(str, param[0][0::2])) + ')'
if param[0][1] in ['<', '>', '<=', '>=', '!=', '==']:
ret = '(true &and ' + ret + ')'
return ret
operand = __string | __hexadec | __integer | \
__function | __identifier
compoperator = pypa.oneOf('< > <= >= == !=')
calcoperator = pypa.oneOf('+ - * / & | << >> %')
expr = pypa.operatorPrecedence(operand, [
('defined', 1, pypa.opAssoc.RIGHT, _rewriteOne),
('!', 1, pypa.opAssoc.RIGHT, _rewriteOne),
(calcoperator, 2, pypa.opAssoc.LEFT, _rewriteTwo),
(compoperator, 2, pypa.opAssoc.LEFT, _rewriteTwo),
('&&', 2, pypa.opAssoc.LEFT, _rewriteTwo),
('||', 2, pypa.opAssoc.LEFT, _rewriteTwo),
])
try:
rsig = expr.parseString(sig)[0]
except pypa.ParseException, e:
print('ERROR (parse): cannot parse sig (%s) -- (%s)' %
(sig, e.col))
return sig
def _parseFeatureSignatureAndRewriteCSP(sig):
"""This function parses a given feature-expresson and
rewrites the expression according to the given __pt mapping.
This one is used to make use of a csp solver without using
a predicate."""
__pt = {
#'defined' : 'defined_',
'defined' : '',
'!' : '!',
'&&': '&',
'||': '|',
'<' : '_lt_',
'>' : '_gt_',
'<=': '_le_',
'>=': '_ge_',
'==': '_eq_',
'!=': '_ne_',
'*' : '_mu_',
'/' : '_di_',
'%' : '_mo_',
'+' : '_pl_',
'-' : '_mi_',
'&' : '_ba_',
'|' : '_bo_',
'>>': '_sr_',
'<<': '_sl_',
}
mal = list()
def _rewriteOne(param):
"""This function returns each one parameter function
representation for csp."""
op, ma = param[0]
mal.append(ma)
if op == '!': ret = __pt[op] + '(' + ma + ')'
if op == 'defined': ret = ma
return ret
def _rewriteTwo(param):
"""This function returns each two parameter function
representation for csp."""
mal.extend(param[0][0::2])
ret = __pt[param[0][1]]
ret = '(' + ret.join(map(str, param[0][0::2])) + ')'
return ret
operand = __hexadec | __integer | __string | \
__function | __identifier
compoperator = pypa.oneOf('< > <= >= == !=')
calcoperator = pypa.oneOf('+ - * / & | << >> %')
expr = pypa.operatorPrecedence(operand, [
('defined', 1, pypa.opAssoc.RIGHT, _rewriteOne),
('!', 1, pypa.opAssoc.RIGHT, _rewriteOne),
(calcoperator, 2, pypa.opAssoc.LEFT, _rewriteTwo),
(compoperator, 2, pypa.opAssoc.LEFT, _rewriteTwo),
('&&', 2, pypa.opAssoc.LEFT, _rewriteTwo),
('||', 2, pypa.opAssoc.LEFT, _rewriteTwo),
])
try:
rsig = expr.parseString(sig)[0]
except pypa.ParseException, e:
print('ERROR (parse): cannot parse sig (%s) -- (%s)' %
(sig, e.col))
return sig
