1# -*- coding: utf-8 -*- 2""" 3 jinja2.parser 4 ~~~~~~~~~~~~~ 5 6 Implements the template parser. 7 8 :copyright: (c) 2010 by the Jinja Team. 9 :license: BSD, see LICENSE for more details. 10""" 11from jinja2 import nodes 12from jinja2.exceptions import TemplateSyntaxError, TemplateAssertionError 13from jinja2.utils import next 14from jinja2.lexer import describe_token, describe_token_expr 15 16 17#: statements that callinto 18_statement_keywords = frozenset(['for', 'if', 'block', 'extends', 'print', 19 'macro', 'include', 'from', 'import', 20 'set']) 21_compare_operators = frozenset(['eq', 'ne', 'lt', 'lteq', 'gt', 'gteq']) 22 23 24class Parser(object): 25 """This is the central parsing class Jinja2 uses. It's passed to 26 extensions and can be used to parse expressions or statements. 27 """ 28 29 def __init__(self, environment, source, name=None, filename=None, 30 state=None): 31 self.environment = environment 32 self.stream = environment._tokenize(source, name, filename, state) 33 self.name = name 34 self.filename = filename 35 self.closed = False 36 self.extensions = {} 37 for extension in environment.iter_extensions(): 38 for tag in extension.tags: 39 self.extensions[tag] = extension.parse 40 self._last_identifier = 0 41 self._tag_stack = [] 42 self._end_token_stack = [] 43 44 def fail(self, msg, lineno=None, exc=TemplateSyntaxError): 45 """Convenience method that raises `exc` with the message, passed 46 line number or last line number as well as the current name and 47 filename. 48 """ 49 if lineno is None: 50 lineno = self.stream.current.lineno 51 raise exc(msg, lineno, self.name, self.filename) 52 53 def _fail_ut_eof(self, name, end_token_stack, lineno): 54 expected = [] 55 for exprs in end_token_stack: 56 expected.extend(map(describe_token_expr, exprs)) 57 if end_token_stack: 58 currently_looking = ' or '.join( 59 "'%s'" % describe_token_expr(expr) 60 for expr in end_token_stack[-1]) 61 else: 62 currently_looking = None 63 64 if name is None: 65 message = ['Unexpected end of template.'] 66 else: 67 message = ['Encountered unknown tag \'%s\'.' % name] 68 69 if currently_looking: 70 if name is not None and name in expected: 71 message.append('You probably made a nesting mistake. Jinja ' 72 'is expecting this tag, but currently looking ' 73 'for %s.' % currently_looking) 74 else: 75 message.append('Jinja was looking for the following tags: ' 76 '%s.' % currently_looking) 77 78 if self._tag_stack: 79 message.append('The innermost block that needs to be ' 80 'closed is \'%s\'.' % self._tag_stack[-1]) 81 82 self.fail(' '.join(message), lineno) 83 84 def fail_unknown_tag(self, name, lineno=None): 85 """Called if the parser encounters an unknown tag. Tries to fail 86 with a human readable error message that could help to identify 87 the problem. 88 """ 89 return self._fail_ut_eof(name, self._end_token_stack, lineno) 90 91 def fail_eof(self, end_tokens=None, lineno=None): 92 """Like fail_unknown_tag but for end of template situations.""" 93 stack = list(self._end_token_stack) 94 if end_tokens is not None: 95 stack.append(end_tokens) 96 return self._fail_ut_eof(None, stack, lineno) 97 98 def is_tuple_end(self, extra_end_rules=None): 99 """Are we at the end of a tuple?""" 100 if self.stream.current.type in ('variable_end', 'block_end', 'rparen'): 101 return True 102 elif extra_end_rules is not None: 103 return self.stream.current.test_any(extra_end_rules) 104 return False 105 106 def free_identifier(self, lineno=None): 107 """Return a new free identifier as :class:`~jinja2.nodes.InternalName`.""" 108 self._last_identifier += 1 109 rv = object.__new__(nodes.InternalName) 110 nodes.Node.__init__(rv, 'fi%d' % self._last_identifier, lineno=lineno) 111 return rv 112 113 def parse_statement(self): 114 """Parse a single statement.""" 115 token = self.stream.current 116 if token.type != 'name': 117 self.fail('tag name expected', token.lineno) 118 self._tag_stack.append(token.value) 119 pop_tag = True 120 try: 121 if token.value in _statement_keywords: 122 return getattr(self, 'parse_' + self.stream.current.value)() 123 if token.value == 'call': 124 return self.parse_call_block() 125 if token.value == 'filter': 126 return self.parse_filter_block() 127 ext = self.extensions.get(token.value) 128 if ext is not None: 129 return ext(self) 130 131 # did not work out, remove the token we pushed by accident 132 # from the stack so that the unknown tag fail function can 133 # produce a proper error message. 134 self._tag_stack.pop() 135 pop_tag = False 136 self.fail_unknown_tag(token.value, token.lineno) 137 finally: 138 if pop_tag: 139 self._tag_stack.pop() 140 141 def parse_statements(self, end_tokens, drop_needle=False): 142 """Parse multiple statements into a list until one of the end tokens 143 is reached. This is used to parse the body of statements as it also 144 parses template data if appropriate. The parser checks first if the 145 current token is a colon and skips it if there is one. Then it checks 146 for the block end and parses until if one of the `end_tokens` is 147 reached. Per default the active token in the stream at the end of 148 the call is the matched end token. If this is not wanted `drop_needle` 149 can be set to `True` and the end token is removed. 150 """ 151 # the first token may be a colon for python compatibility 152 self.stream.skip_if('colon') 153 154 # in the future it would be possible to add whole code sections 155 # by adding some sort of end of statement token and parsing those here. 156 self.stream.expect('block_end') 157 result = self.subparse(end_tokens) 158 159 # we reached the end of the template too early, the subparser 160 # does not check for this, so we do that now 161 if self.stream.current.type == 'eof': 162 self.fail_eof(end_tokens) 163 164 if drop_needle: 165 next(self.stream) 166 return result 167 168 def parse_set(self): 169 """Parse an assign statement.""" 170 lineno = next(self.stream).lineno 171 target = self.parse_assign_target() 172 self.stream.expect('assign') 173 expr = self.parse_tuple() 174 return nodes.Assign(target, expr, lineno=lineno) 175 176 def parse_for(self): 177 """Parse a for loop.""" 178 lineno = self.stream.expect('name:for').lineno 179 target = self.parse_assign_target(extra_end_rules=('name:in',)) 180 self.stream.expect('name:in') 181 iter = self.parse_tuple(with_condexpr=False, 182 extra_end_rules=('name:recursive',)) 183 test = None 184 if self.stream.skip_if('name:if'): 185 test = self.parse_expression() 186 recursive = self.stream.skip_if('name:recursive') 187 body = self.parse_statements(('name:endfor', 'name:else')) 188 if next(self.stream).value == 'endfor': 189 else_ = [] 190 else: 191 else_ = self.parse_statements(('name:endfor',), drop_needle=True) 192 return nodes.For(target, iter, body, else_, test, 193 recursive, lineno=lineno) 194 195 def parse_if(self): 196 """Parse an if construct.""" 197 node = result = nodes.If(lineno=self.stream.expect('name:if').lineno) 198 while 1: 199 node.test = self.parse_tuple(with_condexpr=False) 200 node.body = self.parse_statements(('name:elif', 'name:else', 201 'name:endif')) 202 token = next(self.stream) 203 if token.test('name:elif'): 204 new_node = nodes.If(lineno=self.stream.current.lineno) 205 node.else_ = [new_node] 206 node = new_node 207 continue 208 elif token.test('name:else'): 209 node.else_ = self.parse_statements(('name:endif',), 210 drop_needle=True) 211 else: 212 node.else_ = [] 213 break 214 return result 215 216 def parse_block(self): 217 node = nodes.Block(lineno=next(self.stream).lineno) 218 node.name = self.stream.expect('name').value 219 node.scoped = self.stream.skip_if('name:scoped') 220 221 # common problem people encounter when switching from django 222 # to jinja. we do not support hyphens in block names, so let's 223 # raise a nicer error message in that case. 224 if self.stream.current.type == 'sub': 225 self.fail('Block names in Jinja have to be valid Python ' 226 'identifiers and may not contain hypens, use an ' 227 'underscore instead.') 228 229 node.body = self.parse_statements(('name:endblock',), drop_needle=True) 230 self.stream.skip_if('name:' + node.name) 231 return node 232 233 def parse_extends(self): 234 node = nodes.Extends(lineno=next(self.stream).lineno) 235 node.template = self.parse_expression() 236 return node 237 238 def parse_import_context(self, node, default): 239 if self.stream.current.test_any('name:with', 'name:without') and \ 240 self.stream.look().test('name:context'): 241 node.with_context = next(self.stream).value == 'with' 242 self.stream.skip() 243 else: 244 node.with_context = default 245 return node 246 247 def parse_include(self): 248 node = nodes.Include(lineno=next(self.stream).lineno) 249 node.template = self.parse_expression() 250 if self.stream.current.test('name:ignore') and \ 251 self.stream.look().test('name:missing'): 252 node.ignore_missing = True 253 self.stream.skip(2) 254 else: 255 node.ignore_missing = False 256 return self.parse_import_context(node, True) 257 258 def parse_import(self): 259 node = nodes.Import(lineno=next(self.stream).lineno) 260 node.template = self.parse_expression() 261 self.stream.expect('name:as') 262 node.target = self.parse_assign_target(name_only=True).name 263 return self.parse_import_context(node, False) 264 265 def parse_from(self): 266 node = nodes.FromImport(lineno=next(self.stream).lineno) 267 node.template = self.parse_expression() 268 self.stream.expect('name:import') 269 node.names = [] 270 271 def parse_context(): 272 if self.stream.current.value in ('with', 'without') and \ 273 self.stream.look().test('name:context'): 274 node.with_context = next(self.stream).value == 'with' 275 self.stream.skip() 276 return True 277 return False 278 279 while 1: 280 if node.names: 281 self.stream.expect('comma') 282 if self.stream.current.type == 'name': 283 if parse_context(): 284 break 285 target = self.parse_assign_target(name_only=True) 286 if target.name.startswith('_'): 287 self.fail('names starting with an underline can not ' 288 'be imported', target.lineno, 289 exc=TemplateAssertionError) 290 if self.stream.skip_if('name:as'): 291 alias = self.parse_assign_target(name_only=True) 292 node.names.append((target.name, alias.name)) 293 else: 294 node.names.append(target.name) 295 if parse_context() or self.stream.current.type != 'comma': 296 break 297 else: 298 break 299 if not hasattr(node, 'with_context'): 300 node.with_context = False 301 self.stream.skip_if('comma') 302 return node 303 304 def parse_signature(self, node): 305 node.args = args = [] 306 node.defaults = defaults = [] 307 self.stream.expect('lparen') 308 while self.stream.current.type != 'rparen': 309 if args: 310 self.stream.expect('comma') 311 arg = self.parse_assign_target(name_only=True) 312 arg.set_ctx('param') 313 if self.stream.skip_if('assign'): 314 defaults.append(self.parse_expression()) 315 args.append(arg) 316 self.stream.expect('rparen') 317 318 def parse_call_block(self): 319 node = nodes.CallBlock(lineno=next(self.stream).lineno) 320 if self.stream.current.type == 'lparen': 321 self.parse_signature(node) 322 else: 323 node.args = [] 324 node.defaults = [] 325 326 node.call = self.parse_expression() 327 if not isinstance(node.call, nodes.Call): 328 self.fail('expected call', node.lineno) 329 node.body = self.parse_statements(('name:endcall',), drop_needle=True) 330 return node 331 332 def parse_filter_block(self): 333 node = nodes.FilterBlock(lineno=next(self.stream).lineno) 334 node.filter = self.parse_filter(None, start_inline=True) 335 node.body = self.parse_statements(('name:endfilter',), 336 drop_needle=True) 337 return node 338 339 def parse_macro(self): 340 node = nodes.Macro(lineno=next(self.stream).lineno) 341 node.name = self.parse_assign_target(name_only=True).name 342 self.parse_signature(node) 343 node.body = self.parse_statements(('name:endmacro',), 344 drop_needle=True) 345 return node 346 347 def parse_print(self): 348 node = nodes.Output(lineno=next(self.stream).lineno) 349 node.nodes = [] 350 while self.stream.current.type != 'block_end': 351 if node.nodes: 352 self.stream.expect('comma') 353 node.nodes.append(self.parse_expression()) 354 return node 355 356 def parse_assign_target(self, with_tuple=True, name_only=False, 357 extra_end_rules=None): 358 """Parse an assignment target. As Jinja2 allows assignments to 359 tuples, this function can parse all allowed assignment targets. Per 360 default assignments to tuples are parsed, that can be disable however 361 by setting `with_tuple` to `False`. If only assignments to names are 362 wanted `name_only` can be set to `True`. The `extra_end_rules` 363 parameter is forwarded to the tuple parsing function. 364 """ 365 if name_only: 366 token = self.stream.expect('name') 367 target = nodes.Name(token.value, 'store', lineno=token.lineno) 368 else: 369 if with_tuple: 370 target = self.parse_tuple(simplified=True, 371 extra_end_rules=extra_end_rules) 372 else: 373 target = self.parse_primary() 374 target.set_ctx('store') 375 if not target.can_assign(): 376 self.fail('can\'t assign to %r' % target.__class__. 377 __name__.lower(), target.lineno) 378 return target 379 380 def parse_expression(self, with_condexpr=True): 381 """Parse an expression. Per default all expressions are parsed, if 382 the optional `with_condexpr` parameter is set to `False` conditional 383 expressions are not parsed. 384 """ 385 if with_condexpr: 386 return self.parse_condexpr() 387 return self.parse_or() 388 389 def parse_condexpr(self): 390 lineno = self.stream.current.lineno 391 expr1 = self.parse_or() 392 while self.stream.skip_if('name:if'): 393 expr2 = self.parse_or() 394 if self.stream.skip_if('name:else'): 395 expr3 = self.parse_condexpr() 396 else: 397 expr3 = None 398 expr1 = nodes.CondExpr(expr2, expr1, expr3, lineno=lineno) 399 lineno = self.stream.current.lineno 400 return expr1 401 402 def parse_or(self): 403 lineno = self.stream.current.lineno 404 left = self.parse_and() 405 while self.stream.skip_if('name:or'): 406 right = self.parse_and() 407 left = nodes.Or(left, right, lineno=lineno) 408 lineno = self.stream.current.lineno 409 return left 410 411 def parse_and(self): 412 lineno = self.stream.current.lineno 413 left = self.parse_not() 414 while self.stream.skip_if('name:and'): 415 right = self.parse_not() 416 left = nodes.And(left, right, lineno=lineno) 417 lineno = self.stream.current.lineno 418 return left 419 420 def parse_not(self): 421 if self.stream.current.test('name:not'): 422 lineno = next(self.stream).lineno 423 return nodes.Not(self.parse_not(), lineno=lineno) 424 return self.parse_compare() 425 426 def parse_compare(self): 427 lineno = self.stream.current.lineno 428 expr = self.parse_add() 429 ops = [] 430 while 1: 431 token_type = self.stream.current.type 432 if token_type in _compare_operators: 433 next(self.stream) 434 ops.append(nodes.Operand(token_type, self.parse_add())) 435 elif self.stream.skip_if('name:in'): 436 ops.append(nodes.Operand('in', self.parse_add())) 437 elif self.stream.current.test('name:not') and \ 438 self.stream.look().test('name:in'): 439 self.stream.skip(2) 440 ops.append(nodes.Operand('notin', self.parse_add())) 441 else: 442 break 443 lineno = self.stream.current.lineno 444 if not ops: 445 return expr 446 return nodes.Compare(expr, ops, lineno=lineno) 447 448 def parse_add(self): 449 lineno = self.stream.current.lineno 450 left = self.parse_sub() 451 while self.stream.current.type == 'add': 452 next(self.stream) 453 right = self.parse_sub() 454 left = nodes.Add(left, right, lineno=lineno) 455 lineno = self.stream.current.lineno 456 return left 457 458 def parse_sub(self): 459 lineno = self.stream.current.lineno 460 left = self.parse_concat() 461 while self.stream.current.type == 'sub': 462 next(self.stream) 463 right = self.parse_concat() 464 left = nodes.Sub(left, right, lineno=lineno) 465 lineno = self.stream.current.lineno 466 return left 467 468 def parse_concat(self): 469 lineno = self.stream.current.lineno 470 args = [self.parse_mul()] 471 while self.stream.current.type == 'tilde': 472 next(self.stream) 473 args.append(self.parse_mul()) 474 if len(args) == 1: 475 return args[0] 476 return nodes.Concat(args, lineno=lineno) 477 478 def parse_mul(self): 479 lineno = self.stream.current.lineno 480 left = self.parse_div() 481 while self.stream.current.type == 'mul': 482 next(self.stream) 483 right = self.parse_div() 484 left = nodes.Mul(left, right, lineno=lineno) 485 lineno = self.stream.current.lineno 486 return left 487 488 def parse_div(self): 489 lineno = self.stream.current.lineno 490 left = self.parse_floordiv() 491 while self.stream.current.type == 'div': 492 next(self.stream) 493 right = self.parse_floordiv() 494 left = nodes.Div(left, right, lineno=lineno) 495 lineno = self.stream.current.lineno 496 return left 497 498 def parse_floordiv(self): 499 lineno = self.stream.current.lineno 500 left = self.parse_mod() 501 while self.stream.current.type == 'floordiv': 502 next(self.stream) 503 right = self.parse_mod() 504 left = nodes.FloorDiv(left, right, lineno=lineno) 505 lineno = self.stream.current.lineno 506 return left 507 508 def parse_mod(self): 509 lineno = self.stream.current.lineno 510 left = self.parse_pow() 511 while self.stream.current.type == 'mod': 512 next(self.stream) 513 right = self.parse_pow() 514 left = nodes.Mod(left, right, lineno=lineno) 515 lineno = self.stream.current.lineno 516 return left 517 518 def parse_pow(self): 519 lineno = self.stream.current.lineno 520 left = self.parse_unary() 521 while self.stream.current.type == 'pow': 522 next(self.stream) 523 right = self.parse_unary() 524 left = nodes.Pow(left, right, lineno=lineno) 525 lineno = self.stream.current.lineno 526 return left 527 528 def parse_unary(self, with_filter=True): 529 token_type = self.stream.current.type 530 lineno = self.stream.current.lineno 531 if token_type == 'sub': 532 next(self.stream) 533 node = nodes.Neg(self.parse_unary(False), lineno=lineno) 534 elif token_type == 'add': 535 next(self.stream) 536 node = nodes.Pos(self.parse_unary(False), lineno=lineno) 537 else: 538 node = self.parse_primary() 539 node = self.parse_postfix(node) 540 if with_filter: 541 node = self.parse_filter_expr(node) 542 return node 543 544 def parse_primary(self): 545 token = self.stream.current 546 if token.type == 'name': 547 if token.value in ('true', 'false', 'True', 'False'): 548 node = nodes.Const(token.value in ('true', 'True'), 549 lineno=token.lineno) 550 elif token.value in ('none', 'None'): 551 node = nodes.Const(None, lineno=token.lineno) 552 else: 553 node = nodes.Name(token.value, 'load', lineno=token.lineno) 554 next(self.stream) 555 elif token.type == 'string': 556 next(self.stream) 557 buf = [token.value] 558 lineno = token.lineno 559 while self.stream.current.type == 'string': 560 buf.append(self.stream.current.value) 561 next(self.stream) 562 node = nodes.Const(''.join(buf), lineno=lineno) 563 elif token.type in ('integer', 'float'): 564 next(self.stream) 565 node = nodes.Const(token.value, lineno=token.lineno) 566 elif token.type == 'lparen': 567 next(self.stream) 568 node = self.parse_tuple(explicit_parentheses=True) 569 self.stream.expect('rparen') 570 elif token.type == 'lbracket': 571 node = self.parse_list() 572 elif token.type == 'lbrace': 573 node = self.parse_dict() 574 else: 575 self.fail("unexpected '%s'" % describe_token(token), token.lineno) 576 return node 577 578 def parse_tuple(self, simplified=False, with_condexpr=True, 579 extra_end_rules=None, explicit_parentheses=False): 580 """Works like `parse_expression` but if multiple expressions are 581 delimited by a comma a :class:`~jinja2.nodes.Tuple` node is created. 582 This method could also return a regular expression instead of a tuple 583 if no commas where found. 584 585 The default parsing mode is a full tuple. If `simplified` is `True` 586 only names and literals are parsed. The `no_condexpr` parameter is 587 forwarded to :meth:`parse_expression`. 588 589 Because tuples do not require delimiters and may end in a bogus comma 590 an extra hint is needed that marks the end of a tuple. For example 591 for loops support tuples between `for` and `in`. In that case the 592 `extra_end_rules` is set to ``['name:in']``. 593 594 `explicit_parentheses` is true if the parsing was triggered by an 595 expression in parentheses. This is used to figure out if an empty 596 tuple is a valid expression or not. 597 """ 598 lineno = self.stream.current.lineno 599 if simplified: 600 parse = self.parse_primary 601 elif with_condexpr: 602 parse = self.parse_expression 603 else: 604 parse = lambda: self.parse_expression(with_condexpr=False) 605 args = [] 606 is_tuple = False 607 while 1: 608 if args: 609 self.stream.expect('comma') 610 if self.is_tuple_end(extra_end_rules): 611 break 612 args.append(parse()) 613 if self.stream.current.type == 'comma': 614 is_tuple = True 615 else: 616 break 617 lineno = self.stream.current.lineno 618 619 if not is_tuple: 620 if args: 621 return args[0] 622 623 # if we don't have explicit parentheses, an empty tuple is 624 # not a valid expression. This would mean nothing (literally 625 # nothing) in the spot of an expression would be an empty 626 # tuple. 627 if not explicit_parentheses: 628 self.fail('Expected an expression, got \'%s\'' % 629 describe_token(self.stream.current)) 630 631 return nodes.Tuple(args, 'load', lineno=lineno) 632 633 def parse_list(self): 634 token = self.stream.expect('lbracket') 635 items = [] 636 while self.stream.current.type != 'rbracket': 637 if items: 638 self.stream.expect('comma') 639 if self.stream.current.type == 'rbracket': 640 break 641 items.append(self.parse_expression()) 642 self.stream.expect('rbracket') 643 return nodes.List(items, lineno=token.lineno) 644 645 def parse_dict(self): 646 token = self.stream.expect('lbrace') 647 items = [] 648 while self.stream.current.type != 'rbrace': 649 if items: 650 self.stream.expect('comma') 651 if self.stream.current.type == 'rbrace': 652 break 653 key = self.parse_expression() 654 self.stream.expect('colon') 655 value = self.parse_expression() 656 items.append(nodes.Pair(key, value, lineno=key.lineno)) 657 self.stream.expect('rbrace') 658 return nodes.Dict(items, lineno=token.lineno) 659 660 def parse_postfix(self, node): 661 while 1: 662 token_type = self.stream.current.type 663 if token_type == 'dot' or token_type == 'lbracket': 664 node = self.parse_subscript(node) 665 # calls are valid both after postfix expressions (getattr 666 # and getitem) as well as filters and tests 667 elif token_type == 'lparen': 668 node = self.parse_call(node) 669 else: 670 break 671 return node 672 673 def parse_filter_expr(self, node): 674 while 1: 675 token_type = self.stream.current.type 676 if token_type == 'pipe': 677 node = self.parse_filter(node) 678 elif token_type == 'name' and self.stream.current.value == 'is': 679 node = self.parse_test(node) 680 # calls are valid both after postfix expressions (getattr 681 # and getitem) as well as filters and tests 682 elif token_type == 'lparen': 683 node = self.parse_call(node) 684 else: 685 break 686 return node 687 688 def parse_subscript(self, node): 689 token = next(self.stream) 690 if token.type == 'dot': 691 attr_token = self.stream.current 692 next(self.stream) 693 if attr_token.type == 'name': 694 return nodes.Getattr(node, attr_token.value, 'load', 695 lineno=token.lineno) 696 elif attr_token.type != 'integer': 697 self.fail('expected name or number', attr_token.lineno) 698 arg = nodes.Const(attr_token.value, lineno=attr_token.lineno) 699 return nodes.Getitem(node, arg, 'load', lineno=token.lineno) 700 if token.type == 'lbracket': 701 priority_on_attribute = False 702 args = [] 703 while self.stream.current.type != 'rbracket': 704 if args: 705 self.stream.expect('comma') 706 args.append(self.parse_subscribed()) 707 self.stream.expect('rbracket') 708 if len(args) == 1: 709 arg = args[0] 710 else: 711 arg = nodes.Tuple(args, 'load', lineno=token.lineno) 712 return nodes.Getitem(node, arg, 'load', lineno=token.lineno) 713 self.fail('expected subscript expression', self.lineno) 714 715 def parse_subscribed(self): 716 lineno = self.stream.current.lineno 717 718 if self.stream.current.type == 'colon': 719 next(self.stream) 720 args = [None] 721 else: 722 node = self.parse_expression() 723 if self.stream.current.type != 'colon': 724 return node 725 next(self.stream) 726 args = [node] 727 728 if self.stream.current.type == 'colon': 729 args.append(None) 730 elif self.stream.current.type not in ('rbracket', 'comma'): 731 args.append(self.parse_expression()) 732 else: 733 args.append(None) 734 735 if self.stream.current.type == 'colon': 736 next(self.stream) 737 if self.stream.current.type not in ('rbracket', 'comma'): 738 args.append(self.parse_expression()) 739 else: 740 args.append(None) 741 else: 742 args.append(None) 743 744 return nodes.Slice(lineno=lineno, *args) 745 746 def parse_call(self, node): 747 token = self.stream.expect('lparen') 748 args = [] 749 kwargs = [] 750 dyn_args = dyn_kwargs = None 751 require_comma = False 752 753 def ensure(expr): 754 if not expr: 755 self.fail('invalid syntax for function call expression', 756 token.lineno) 757 758 while self.stream.current.type != 'rparen': 759 if require_comma: 760 self.stream.expect('comma') 761 # support for trailing comma 762 if self.stream.current.type == 'rparen': 763 break 764 if self.stream.current.type == 'mul': 765 ensure(dyn_args is None and dyn_kwargs is None) 766 next(self.stream) 767 dyn_args = self.parse_expression() 768 elif self.stream.current.type == 'pow': 769 ensure(dyn_kwargs is None) 770 next(self.stream) 771 dyn_kwargs = self.parse_expression() 772 else: 773 ensure(dyn_args is None and dyn_kwargs is None) 774 if self.stream.current.type == 'name' and \ 775 self.stream.look().type == 'assign': 776 key = self.stream.current.value 777 self.stream.skip(2) 778 value = self.parse_expression() 779 kwargs.append(nodes.Keyword(key, value, 780 lineno=value.lineno)) 781 else: 782 ensure(not kwargs) 783 args.append(self.parse_expression()) 784 785 require_comma = True 786 self.stream.expect('rparen') 787 788 if node is None: 789 return args, kwargs, dyn_args, dyn_kwargs 790 return nodes.Call(node, args, kwargs, dyn_args, dyn_kwargs, 791 lineno=token.lineno) 792 793 def parse_filter(self, node, start_inline=False): 794 while self.stream.current.type == 'pipe' or start_inline: 795 if not start_inline: 796 next(self.stream) 797 token = self.stream.expect('name') 798 name = token.value 799 while self.stream.current.type == 'dot': 800 next(self.stream) 801 name += '.' + self.stream.expect('name').value 802 if self.stream.current.type == 'lparen': 803 args, kwargs, dyn_args, dyn_kwargs = self.parse_call(None) 804 else: 805 args = [] 806 kwargs = [] 807 dyn_args = dyn_kwargs = None 808 node = nodes.Filter(node, name, args, kwargs, dyn_args, 809 dyn_kwargs, lineno=token.lineno) 810 start_inline = False 811 return node 812 813 def parse_test(self, node): 814 token = next(self.stream) 815 if self.stream.current.test('name:not'): 816 next(self.stream) 817 negated = True 818 else: 819 negated = False 820 name = self.stream.expect('name').value 821 while self.stream.current.type == 'dot': 822 next(self.stream) 823 name += '.' + self.stream.expect('name').value 824 dyn_args = dyn_kwargs = None 825 kwargs = [] 826 if self.stream.current.type == 'lparen': 827 args, kwargs, dyn_args, dyn_kwargs = self.parse_call(None) 828 elif self.stream.current.type in ('name', 'string', 'integer', 829 'float', 'lparen', 'lbracket', 830 'lbrace') and not \ 831 self.stream.current.test_any('name:else', 'name:or', 832 'name:and'): 833 if self.stream.current.test('name:is'): 834 self.fail('You cannot chain multiple tests with is') 835 args = [self.parse_expression()] 836 else: 837 args = [] 838 node = nodes.Test(node, name, args, kwargs, dyn_args, 839 dyn_kwargs, lineno=token.lineno) 840 if negated: 841 node = nodes.Not(node, lineno=token.lineno) 842 return node 843 844 def subparse(self, end_tokens=None): 845 body = [] 846 data_buffer = [] 847 add_data = data_buffer.append 848 849 if end_tokens is not None: 850 self._end_token_stack.append(end_tokens) 851 852 def flush_data(): 853 if data_buffer: 854 lineno = data_buffer[0].lineno 855 body.append(nodes.Output(data_buffer[:], lineno=lineno)) 856 del data_buffer[:] 857 858 try: 859 while self.stream: 860 token = self.stream.current 861 if token.type == 'data': 862 if token.value: 863 add_data(nodes.TemplateData(token.value, 864 lineno=token.lineno)) 865 next(self.stream) 866 elif token.type == 'variable_begin': 867 next(self.stream) 868 add_data(self.parse_tuple(with_condexpr=True)) 869 self.stream.expect('variable_end') 870 elif token.type == 'block_begin': 871 flush_data() 872 next(self.stream) 873 if end_tokens is not None and \ 874 self.stream.current.test_any(*end_tokens): 875 return body 876 rv = self.parse_statement() 877 if isinstance(rv, list): 878 body.extend(rv) 879 else: 880 body.append(rv) 881 self.stream.expect('block_end') 882 else: 883 raise AssertionError('internal parsing error') 884 885 flush_data() 886 finally: 887 if end_tokens is not None: 888 self._end_token_stack.pop() 889 890 return body 891 892 def parse(self): 893 """Parse the whole template into a `Template` node.""" 894 result = nodes.Template(self.subparse(), lineno=1) 895 result.set_environment(self.environment) 896 return result 897