def evaluate(self, context):
if self._op == "=":
true = boolean.true
false = boolean.false
else:
true = boolean.false
false = boolean.true
lrt = self._left.evaluate(context)
rrt = self._right.evaluate(context)
lType = type(lrt)
rType = type(rrt)
if lType == list == rType:
# Node set to node set
for right_curr in rrt:
right_curr = Conversions.StringValue(right_curr)
for left_curr in lrt:
if right_curr == Conversions.StringValue(left_curr):
return true
return false
elif lType == list or rType == list:
func = None
if lType == list:
set = lrt
val = rrt
else:
set = rrt
val = lrt
if type(val) in NumberTypes:
func = Conversions.NumberValue
elif boolean.IsBooleanType(val):
func = Conversions.BooleanValue
elif type(val) == bytes:
func = Conversions.StringValue
else:
# Deal with e.g. RTFs
val = Conversions.StringValue(val)
func = Conversions.StringValue
for n in set:
if func(n) == val:
return true
return false
if boolean.IsBooleanType(lrt) or boolean.IsBooleanType(rrt):
rt = Conversions.BooleanValue(lrt) == Conversions.BooleanValue(rrt)
elif lType in NumberTypes or rType in NumberTypes:
rt = Conversions.NumberValue(lrt) == Conversions.NumberValue(rrt)
else:
rt = Conversions.StringValue(lrt) == Conversions.StringValue(rrt)
if rt:
# Due to the swapping of true/false, true might evaluate to 0
# We cannot compact this to 'rt and true or false'
return true
return false
def range(context, lo, hi):
doc = context.node
while doc.parentNode:
doc = doc.parentNode
lo = Conversions.NumberValue(lo)
hi = Conversions.NumberValue(hi)
nodeset = []
for number in range(lo, hi):
nodeset.append(doc.createTextNode(str(number)))
return nodeset
def evaluate(self, context):
"""returns a number"""
if self._leftLit:
lrt = self._left
else:
lrt = self._left.evaluate(context)
lrt = Conversions.NumberValue(lrt)
if self._rightLit:
rrt = self._right
else:
rrt = self._right.evaluate(context)
rrt = Conversions.NumberValue(rrt)
return lrt + (rrt * self._sign)
def __init__(self, sign, left, right):
self._sign = sign
self._leftLit = 0
self._rightLit = 0
if isinstance(left, ParsedLiteralExpr):
self._leftLit = 1
self._left = Conversions.NumberValue(left.evaluate(None))
else:
self._left = left
if isinstance(right, ParsedLiteralExpr):
self._rightLit = 1
self._right = Conversions.NumberValue(right.evaluate(None))
else:
self._right = right
return
def __init__(self, opcode, left, right):
self._op = opcode
if isinstance(left, ParsedLiteralExpr):
self._left = Conversions.NumberValue(left.evaluate(None))
self._leftLit = 1
else:
self._left = left
self._leftLit = 0
if isinstance(right, ParsedLiteralExpr):
self._right = Conversions.NumberValue(right.evaluate(None))
self._rightLit = 1
else:
self._right = right
self._rightLit = 0
def Substring(context, st, start, end=None):
"""Function: <string> substring(<string>, <number>, <number>?)"""
st = Conversions.StringValue(st)
start = Conversions.NumberValue(start)
if start is NaN:
return ''
start = int(round(start))
start = start > 1 and start - 1 or 0
if end is None:
return st[start:]
end = Conversions.NumberValue(end)
if start is NaN:
return st[start:]
end = int(round(end))
return st[start:start + end]
def evaluate(self, context):
if self._leftLit:
lrt = self._left
else:
lrt = Conversions.NumberValue(self._left.evaluate(context))
if self._rightLit:
rrt = self._right
else:
rrt = Conversions.NumberValue(self._right.evaluate(context))
if self._op == 0:
rt = lrt < rrt
elif self._op == 1:
rt = lrt <= rrt
elif self._op == 2:
rt = lrt > rrt
elif self._op == 3:
rt = lrt >= rrt
return rt and boolean.true or boolean.false
def Ceiling(context, number):
"""Function: <number> ceiling(<number>)"""
number = Conversions.NumberValue(number)
#if type(number) in g_stringTypes:
# number = string.atof(number)
if int(number) == number:
return number
elif number > 0:
return int(number) + 1
else:
return int(number)
def evaluate(self, context):
"""returns a number"""
lrt = self._left.evaluate(context)
lrt = Conversions.NumberValue(lrt)
rrt = self._right.evaluate(context)
rrt = Conversions.NumberValue(rrt)
res = 0
if self._op == 0:
res = lrt * rrt
elif self._op == 1:
if rrt == 0:
res = NaN
else:
res = lrt / rrt
elif self._op == 2:
if rrt == 0:
res = NaN
else:
res = lrt % rrt
return res
def Floor(context, number):
"""Function: <number> floor(<number>)"""
number = Conversions.NumberValue(number)
#if type(number) in g_stringTypes:
# number = string.atof(number)
if int(number) == number:
return number
elif number < 0:
return int(number) - 1
else:
return int(number)
def FormatNumber(context, number, formatString, decimalFormatName=None):
decimal_format = ''
num = Conversions.NumberValue(number)
format_string = Conversions.StringValue(formatString)
if decimalFormatName is not None:
split_name = Util.ExpandQName(decimalFormatName,
namespaces=context.processorNss)
decimal_format = context.stylesheet.decimalFormats[split_name]
else:
decimal_format = context.stylesheet.decimalFormats['']
from Ft.Lib import routines
result = routines.FormatNumber(num, format_string)
return result
def Number(context, object=None):
"""Function: <number> number(<object>?)"""
if object is None:
object = [context.node]
return Conversions.NumberValue(object)
def XsltNumberValue(object):
handled, value = XsltStringValue(object)
if handled:
return 1, Conversions.NumberValue(value)
return 0, None
def evaluate(self, context):
"""returns a number"""
exp = self._exp.evaluate(context)
exp = Conversions.NumberValue(exp)
rt = exp * -1.0
return rt
def instantiate(self, context, processor, nodeList=None, specList=None):
if nodeList is None:
nodeList = []
if specList is None:
specList = []
origState = context.copy()
context.setNamespaces(self._nss)
if self._format:
format = self._format.evaluate(context)
else:
format = '1'
if self._grouping_separator:
grouping_separator = self._grouping_separator.evaluate(context)
else:
grouping_separator = ','
if self._grouping_size:
grouping_size = self._grouping_size.evaluate(context)
else:
grouping_size = '3'
if grouping_separator and grouping_size:
try:
grouping_size = string.atoi(grouping_size)
except ValueError:
raise XsltException(Error.ILLEGAL_NUMBER_GROUPING_SIZE_VALUE)
else:
grouping_separator = None
grouping_size = None
if self._letter_value:
letter_value = self._letter_value.evaluate(context)
if letter_value not in ['alphabetic', 'traditional']:
raise XsltException(Error.ILLEGAL_NUMBER_LETTER_VALUE_VALUE)
value = []
tempState = context.copyNodePosSize()
if self._value:
result = self._value_expr.evaluate(context)
value = [Conversions.NumberValue(result)]
elif self._level == 'single':
ancorself_result = self._ancorself_expr.evaluate(context)
ancorself_result.reverse()
for node in ancorself_result:
context.node = node
if self._count_pattern.match(context, context.node):
break
sibling_result = self._sibling_expr.evaluate(context)
value = 1
for node in sibling_result:
context.node = node
if self._count_pattern.match(context, context.node):
value = value + 1
value = [value]
elif self._level == 'multiple':
ancorself_result = self._ancorself_expr.evaluate(context)
ancorself_result.reverse()
count_result = []
for node in ancorself_result:
context.node = node
if self._count_pattern.match(context, context.node):
count_result.append(node)
context.setNodePosSize(tempState)
value = []
for node in count_result:
context.node = node
sibling_result = self._sibling_expr.evaluate(context)
lvalue = 1
for node in sibling_result:
context.node = node
if self._count_pattern.match(context, context.node):
lvalue = lvalue + 1
value.insert(0, lvalue)
elif self._level == 'any':
count_result = self._count_prior_doc_order_expr.evaluate(context)
value = [len(count_result)]
context.setNodePosSize(tempState)
format_tokens = []
format_separators = []
re_groups = g_formatToken.findall(format)
if not re_groups:
raise XsltException(Error.ILLEGAL_NUMBER_FORMAT_VALUE)
pre_string = re_groups[0][0]
post_string = re_groups[-1][2]
for group in re_groups:
format_tokens.append(group[1])
format_separators.append(group[2])
format_separators = ['.'] + format_separators[:-1]
result = pre_string
curr_index = 0
lft = len(format_tokens)
lfs = len(format_separators)
for number in value:
if curr_index: result = result + curr_sep
if curr_index < lft:
curr_ft = format_tokens[curr_index]
curr_sep = format_separators[curr_index]
curr_index = curr_index + 1
else:
curr_ft = format_tokens[-1]
curr_sep = format_separators[-1]
numstr = str(number)
if curr_ft[-1] == '1':
subresult = Group('0' * (len(curr_ft) - len(numstr)) + numstr,
grouping_size, grouping_separator)
result = result + subresult
elif curr_ft == 'A':
digits = Base26(number)
#FIXME: faster with reduce
for dig in digits:
result = result + chr(ord('A') + dig - 1)
elif curr_ft == 'a':
digits = Base26(number)
for dig in digits:
result = result + chr(ord('a') + dig - 1)
elif curr_ft == 'I':
result = result + Roman.IToRoman(number)
elif curr_ft == 'i':
result = result + string.lower(Roman.IToRoman(number))
else:
raise XsltException(Error.ILLEGAL_NUMBER_FORMAT_VALUE)
processor.writers[-1].text(result + post_string)
context.set(origState)
return (context, )
def Round(context, number):
"""Function: <number> round(<number>)"""
number = Conversions.NumberValue(number)
return round(number, 0)
def Sum(context, nodeSet):
"""Function: <number> sum(<node-set>)"""
nns = map(lambda x: Conversions.NumberValue(x), nodeSet)
return reduce(lambda x, y: x + y, nns, 0)