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)