mercurial-scm/hg: comparison mercurial/templater.py

equal deleted inserted replaced

-:ad43458d3529
+:8e42dfde93d1
 "(": (20, None, ("group", 1, ")"), ("func", 1, ")"), None),
 ",": (2, None, None, ("list", 2), None),
 "|": (5, None, None, ("|", 5), None),
 "%": (6, None, None, ("%", 6), None),
 ")": (0, None, None, None, None),
+"+": (3, None, None, ("+", 3), None),
+"-": (3, None, ("negate", 10), ("-", 3), None),
+"*": (4, None, None, ("*", 4), None),
+"/": (4, None, None, ("/", 4), None),
 "integer": (0, "integer", None, None, None),
 "symbol": (0, "symbol", None, None, None),
 "string": (0, "string", None, None, None),
 "template": (0, "template", None, None, None),
 "end": (0, None, None, None, None),
 pos = start
 while pos < end:
 c = program[pos]
 if c.isspace(): # skip inter-token whitespace
 pass
-elif c in "(,)%|": # handle simple operators
+elif c in "(,)%|+-*/": # handle simple operators
 yield (c, None, pos)
 elif c in '"\'': # handle quoted templates
 s = pos + 1
 data, pos = _parsetemplate(program, s, end, c)
 yield ('template', data, s)
 yield ('string', program[s:pos], s)
 break
 pos += 1
 else:
 raise error.ParseError(_("unterminated string"), s)
-elif c.isdigit() or c == '-':
+elif c.isdigit():
 s = pos
-if c == '-': # simply take negate operator as part of integer
-pos += 1
-if pos >= end or not program[pos].isdigit():
-raise error.ParseError(_("integer literal without digits"), s)
-pos += 1
 while pos < end:
 d = program[pos]
 if not d.isdigit():
 break
 pos += 1
 # v is not an iterable of dicts, this happen when 'key'
 # has been fully expanded already and format is useless.
 # If so, return the expanded value.
 yield i
+def buildnegate(exp, context):
+arg = compileexp(exp[1], context, exprmethods)
+return (runnegate, arg)
+def runnegate(context, mapping, data):
+data = evalinteger(context, mapping, data,
+_('negation needs an integer argument'))
+return -data
+def buildarithmetic(exp, context, func):
+left = compileexp(exp[1], context, exprmethods)
+right = compileexp(exp[2], context, exprmethods)
+return (runarithmetic, (func, left, right))
+def runarithmetic(context, mapping, data):
+func, left, right = data
+left = evalinteger(context, mapping, left,
+_('arithmetic only defined on integers'))
+right = evalinteger(context, mapping, right,
+_('arithmetic only defined on integers'))
+return func(left, right)
 def buildfunc(exp, context):
 n = getsymbol(exp[1])
 args = [compileexp(x, context, exprmethods) for x in getlist(exp[2])]
 if n in funcs:
 f = funcs[n]
 raise error.ParseError(_("localdate expects a timezone"))
 else:
 tzoffset = util.makedate()[1]
 return (date[0], tzoffset)
+@templatefunc('mod(a, b)')
+def mod(context, mapping, args):
+"""Calculate a mod b such that a / b + a mod b == a"""
+if not len(args) == 2:
+# i18n: "mod" is a keyword
+raise error.ParseError(_("mod expects two arguments"))
+left = evalinteger(context, mapping, args[0],
+_('arithmetic only defined on integers'))
+right = evalinteger(context, mapping, args[1],
+_('arithmetic only defined on integers'))
+return left % right
 @templatefunc('relpath(path)')
 def relpath(context, mapping, args):
 """Convert a repository-absolute path into a filesystem path relative to
 the current working directory."""
 if len(args) != 1:
 "group": lambda e, c: compileexp(e[1], c, exprmethods),
 #    ".": buildmember,
 "|": buildfilter,
 "%": buildmap,
 "func": buildfunc,
+"+": lambda e, c: buildarithmetic(e, c, lambda a, b: a + b),
+"-": lambda e, c: buildarithmetic(e, c, lambda a, b: a - b),
+"negate": buildnegate,
+"*": lambda e, c: buildarithmetic(e, c, lambda a, b: a * b),
+"/": lambda e, c: buildarithmetic(e, c, lambda a, b: a // b),
 }
 # methods to interpret top-level template (e.g. {x}, {x|_}, {x % "y"})
 methods = exprmethods.copy()
 methods["integer"] = exprmethods["symbol"]  # '{1}' as variable

changeset 30115	8e42dfde93d1
parent 30083	bd1f043d1ea3
child 30116	1c01fa29630f