コード例 #1
0
ファイル: lexer.py プロジェクト: eklitzke/lexigraph
 def next(self):
     token = self.stream.current
     if token.type is TOKEN_EOF:
         self.stream.close()
         raise StopIteration()
     next(self.stream)
     return token
コード例 #2
0
ファイル: parser.py プロジェクト: eklitzke/lexigraph
 def parse_primary(self, with_postfix=True):
     token = self.stream.current
     if token.type == 'name':
         if token.value in ('true', 'false', 'True', 'False'):
             node = nodes.Const(token.value in ('true', 'True'),
                                lineno=token.lineno)
         elif token.value in ('none', 'None'):
             node = nodes.Const(None, lineno=token.lineno)
         else:
             node = nodes.Name(token.value, 'load', lineno=token.lineno)
         next(self.stream)
     elif token.type == 'string':
         next(self.stream)
         buf = [token.value]
         lineno = token.lineno
         while self.stream.current.type == 'string':
             buf.append(self.stream.current.value)
             next(self.stream)
         node = nodes.Const(''.join(buf), lineno=lineno)
     elif token.type in ('integer', 'float'):
         next(self.stream)
         node = nodes.Const(token.value, lineno=token.lineno)
     elif token.type == 'lparen':
         next(self.stream)
         node = self.parse_tuple()
         self.stream.expect('rparen')
     elif token.type == 'lbracket':
         node = self.parse_list()
     elif token.type == 'lbrace':
         node = self.parse_dict()
     else:
         self.fail("unexpected token '%s'" % (token,), token.lineno)
     if with_postfix:
         node = self.parse_postfix(node)
     return node
コード例 #3
0
ファイル: parser.py プロジェクト: eklitzke/lexigraph
 def parse_test(self, node):
     token = next(self.stream)
     if self.stream.current.test('name:not'):
         next(self.stream)
         negated = True
     else:
         negated = False
     name = self.stream.expect('name').value
     while self.stream.current.type == 'dot':
         next(self.stream)
         name += '.' + self.stream.expect('name').value
     dyn_args = dyn_kwargs = None
     kwargs = []
     if self.stream.current.type == 'lparen':
         args, kwargs, dyn_args, dyn_kwargs = self.parse_call(None)
     elif self.stream.current.type in ('name', 'string', 'integer',
                                       'float', 'lparen', 'lbracket',
                                       'lbrace') and not \
          self.stream.current.test_any('name:else', 'name:or',
                                       'name:and'):
         if self.stream.current.test('name:is'):
             self.fail('You cannot chain multiple tests with is')
         args = [self.parse_expression()]
     else:
         args = []
     node = nodes.Test(node, name, args, kwargs, dyn_args,
                       dyn_kwargs, lineno=token.lineno)
     if negated:
         node = nodes.Not(node, lineno=token.lineno)
     return node
コード例 #4
0
ファイル: parser.py プロジェクト: eklitzke/lexigraph
 def parse_subscript(self, node):
     token = next(self.stream)
     if token.type == 'dot':
         attr_token = self.stream.current
         next(self.stream)
         if attr_token.type == 'name':
             return nodes.Getattr(node, attr_token.value, 'load',
                                  lineno=token.lineno)
         elif attr_token.type != 'integer':
             self.fail('expected name or number', attr_token.lineno)
         arg = nodes.Const(attr_token.value, lineno=attr_token.lineno)
         return nodes.Getitem(node, arg, 'load', lineno=token.lineno)
     if token.type == 'lbracket':
         priority_on_attribute = False
         args = []
         while self.stream.current.type != 'rbracket':
             if args:
                 self.stream.expect('comma')
             args.append(self.parse_subscribed())
         self.stream.expect('rbracket')
         if len(args) == 1:
             arg = args[0]
         else:
             arg = nodes.Tuple(args, 'load', lineno=token.lineno)
         return nodes.Getitem(node, arg, 'load', lineno=token.lineno)
     self.fail('expected subscript expression', self.lineno)
コード例 #5
0
ファイル: lexer.py プロジェクト: eklitzke/lexigraph
 def __init__(self, generator, name, filename):
     self._next = iter(generator).next
     self._pushed = deque()
     self.name = name
     self.filename = filename
     self.closed = False
     self.current = Token(1, TOKEN_INITIAL, '')
     next(self)
コード例 #6
0
ファイル: parser.py プロジェクト: eklitzke/lexigraph
 def parse_add(self):
     lineno = self.stream.current.lineno
     left = self.parse_sub()
     while self.stream.current.type == 'add':
         next(self.stream)
         right = self.parse_sub()
         left = nodes.Add(left, right, lineno=lineno)
         lineno = self.stream.current.lineno
     return left
コード例 #7
0
ファイル: parser.py プロジェクト: eklitzke/lexigraph
 def parse_mul(self):
     lineno = self.stream.current.lineno
     left = self.parse_div()
     while self.stream.current.type == 'mul':
         next(self.stream)
         right = self.parse_div()
         left = nodes.Mul(left, right, lineno=lineno)
         lineno = self.stream.current.lineno
     return left
コード例 #8
0
ファイル: parser.py プロジェクト: eklitzke/lexigraph
 def parse_concat(self):
     lineno = self.stream.current.lineno
     args = [self.parse_mul()]
     while self.stream.current.type == 'tilde':
         next(self.stream)
         args.append(self.parse_mul())
     if len(args) == 1:
         return args[0]
     return nodes.Concat(args, lineno=lineno)
コード例 #9
0
ファイル: parser.py プロジェクト: eklitzke/lexigraph
 def parse_mod(self):
     lineno = self.stream.current.lineno
     left = self.parse_pow()
     while self.stream.current.type == 'mod':
         next(self.stream)
         right = self.parse_pow()
         left = nodes.Mod(left, right, lineno=lineno)
         lineno = self.stream.current.lineno
     return left
コード例 #10
0
ファイル: parser.py プロジェクト: eklitzke/lexigraph
 def parse_floordiv(self):
     lineno = self.stream.current.lineno
     left = self.parse_mod()
     while self.stream.current.type == 'floordiv':
         next(self.stream)
         right = self.parse_mod()
         left = nodes.FloorDiv(left, right, lineno=lineno)
         lineno = self.stream.current.lineno
     return left
コード例 #11
0
ファイル: parser.py プロジェクト: eklitzke/lexigraph
 def parse_pow(self):
     lineno = self.stream.current.lineno
     left = self.parse_unary()
     while self.stream.current.type == 'pow':
         next(self.stream)
         right = self.parse_unary()
         left = nodes.Pow(left, right, lineno=lineno)
         lineno = self.stream.current.lineno
     return left
コード例 #12
0
ファイル: parser.py プロジェクト: eklitzke/lexigraph
 def parse_sub(self):
     lineno = self.stream.current.lineno
     left = self.parse_concat()
     while self.stream.current.type == 'sub':
         next(self.stream)
         right = self.parse_concat()
         left = nodes.Sub(left, right, lineno=lineno)
         lineno = self.stream.current.lineno
     return left
コード例 #13
0
ファイル: parser.py プロジェクト: eklitzke/lexigraph
 def parse_unary(self):
     token_type = self.stream.current.type
     lineno = self.stream.current.lineno
     if token_type == 'sub':
         next(self.stream)
         node = self.parse_unary()
         return nodes.Neg(node, lineno=lineno)
     if token_type == 'add':
         next(self.stream)
         node = self.parse_unary()
         return nodes.Pos(node, lineno=lineno)
     return self.parse_primary()
コード例 #14
0
ファイル: parser.py プロジェクト: eklitzke/lexigraph
 def parse_block(self):
     node = nodes.Block(lineno=next(self.stream).lineno)
     node.name = self.stream.expect('name').value
     node.scoped = self.stream.skip_if('name:scoped')
     node.body = self.parse_statements(('name:endblock',), drop_needle=True)
     self.stream.skip_if('name:' + node.name)
     return node
コード例 #15
0
ファイル: parser.py プロジェクト: eklitzke/lexigraph
 def parse_context():
     if self.stream.current.value in ('with', 'without') and \
        self.stream.look().test('name:context'):
         node.with_context = next(self.stream).value == 'with'
         self.stream.skip()
         return True
     return False
コード例 #16
0
ファイル: parser.py プロジェクト: eklitzke/lexigraph
 def parse_macro(self):
     node = nodes.Macro(lineno=next(self.stream).lineno)
     node.name = self.parse_assign_target(name_only=True).name
     self.parse_signature(node)
     node.body = self.parse_statements(('name:endmacro',),
                                       drop_needle=True)
     return node
コード例 #17
0
ファイル: parser.py プロジェクト: eklitzke/lexigraph
 def parse_set(self):
     """Parse an assign statement."""
     lineno = next(self.stream).lineno
     target = self.parse_assign_target()
     self.stream.expect('assign')
     expr = self.parse_tuple()
     return nodes.Assign(target, expr, lineno=lineno)
コード例 #18
0
ファイル: lexer.py プロジェクト: eklitzke/lexigraph
 def look(self):
     """Look at the next token."""
     old_token = next(self)
     result = self.current
     self.push(result)
     self.current = old_token
     return result
コード例 #19
0
ファイル: parser.py プロジェクト: eklitzke/lexigraph
 def parse_import_context(self, node, default):
     if self.stream.current.test_any('name:with', 'name:without') and \
        self.stream.look().test('name:context'):
         node.with_context = next(self.stream).value == 'with'
         self.stream.skip()
     else:
         node.with_context = default
     return node
コード例 #20
0
ファイル: parser.py プロジェクト: eklitzke/lexigraph
    def parse_call(self, node):
        token = self.stream.expect('lparen')
        args = []
        kwargs = []
        dyn_args = dyn_kwargs = None
        require_comma = False

        def ensure(expr):
            if not expr:
                self.fail('invalid syntax for function call expression',
                          token.lineno)

        while self.stream.current.type != 'rparen':
            if require_comma:
                self.stream.expect('comma')
                # support for trailing comma
                if self.stream.current.type == 'rparen':
                    break
            if self.stream.current.type == 'mul':
                ensure(dyn_args is None and dyn_kwargs is None)
                next(self.stream)
                dyn_args = self.parse_expression()
            elif self.stream.current.type == 'pow':
                ensure(dyn_kwargs is None)
                next(self.stream)
                dyn_kwargs = self.parse_expression()
            else:
                ensure(dyn_args is None and dyn_kwargs is None)
                if self.stream.current.type == 'name' and \
                    self.stream.look().type == 'assign':
                    key = self.stream.current.value
                    self.stream.skip(2)
                    value = self.parse_expression()
                    kwargs.append(nodes.Keyword(key, value,
                                                lineno=value.lineno))
                else:
                    ensure(not kwargs)
                    args.append(self.parse_expression())

            require_comma = True
        self.stream.expect('rparen')

        if node is None:
            return args, kwargs, dyn_args, dyn_kwargs
        return nodes.Call(node, args, kwargs, dyn_args, dyn_kwargs,
                          lineno=token.lineno)
コード例 #21
0
ファイル: parser.py プロジェクト: eklitzke/lexigraph
 def parse_print(self):
     node = nodes.Output(lineno=next(self.stream).lineno)
     node.nodes = []
     while self.stream.current.type != 'block_end':
         if node.nodes:
             self.stream.expect('comma')
         node.nodes.append(self.parse_expression())
     return node
コード例 #22
0
ファイル: parser.py プロジェクト: eklitzke/lexigraph
 def parse_include(self):
     node = nodes.Include(lineno=next(self.stream).lineno)
     node.template = self.parse_expression()
     if self.stream.current.test('name:ignore') and \
        self.stream.look().test('name:missing'):
         node.ignore_missing = True
         self.stream.skip(2)
     else:
         node.ignore_missing = False
     return self.parse_import_context(node, True)
コード例 #23
0
ファイル: parser.py プロジェクト: eklitzke/lexigraph
 def parse_filter(self, node, start_inline=False):
     while self.stream.current.type == 'pipe' or start_inline:
         if not start_inline:
             next(self.stream)
         token = self.stream.expect('name')
         name = token.value
         while self.stream.current.type == 'dot':
             next(self.stream)
             name += '.' + self.stream.expect('name').value
         if self.stream.current.type == 'lparen':
             args, kwargs, dyn_args, dyn_kwargs = self.parse_call(None)
         else:
             args = []
             kwargs = []
             dyn_args = dyn_kwargs = None
         node = nodes.Filter(node, name, args, kwargs, dyn_args,
                             dyn_kwargs, lineno=token.lineno)
         start_inline = False
     return node
コード例 #24
0
ファイル: lexer.py プロジェクト: eklitzke/lexigraph
 def expect(self, expr):
     """Expect a given token type and return it.  This accepts the same
     argument as :meth:`jinja2.lexer.Token.test`.
     """
     if not self.current.test(expr):
         if ':' in expr:
             expr = expr.split(':')[1]
         if self.current.type is TOKEN_EOF:
             raise TemplateSyntaxError('unexpected end of template, '
                                       'expected %r.' % expr,
                                       self.current.lineno,
                                       self.name, self.filename)
         raise TemplateSyntaxError("expected token %r, got %r" %
                                   (expr, str(self.current)),
                                   self.current.lineno,
                                   self.name, self.filename)
     try:
         return self.current
     finally:
         next(self)
コード例 #25
0
ファイル: parser.py プロジェクト: eklitzke/lexigraph
 def parse_compare(self):
     lineno = self.stream.current.lineno
     expr = self.parse_add()
     ops = []
     while 1:
         token_type = self.stream.current.type
         if token_type in _compare_operators:
             next(self.stream)
             ops.append(nodes.Operand(token_type, self.parse_add()))
         elif self.stream.skip_if('name:in'):
             ops.append(nodes.Operand('in', self.parse_add()))
         elif self.stream.current.test('name:not') and \
              self.stream.look().test('name:in'):
             self.stream.skip(2)
             ops.append(nodes.Operand('notin', self.parse_add()))
         else:
             break
         lineno = self.stream.current.lineno
     if not ops:
         return expr
     return nodes.Compare(expr, ops, lineno=lineno)
コード例 #26
0
ファイル: parser.py プロジェクト: eklitzke/lexigraph
    def parse_statements(self, end_tokens, drop_needle=False):
        """Parse multiple statements into a list until one of the end tokens
        is reached.  This is used to parse the body of statements as it also
        parses template data if appropriate.  The parser checks first if the
        current token is a colon and skips it if there is one.  Then it checks
        for the block end and parses until if one of the `end_tokens` is
        reached.  Per default the active token in the stream at the end of
        the call is the matched end token.  If this is not wanted `drop_needle`
        can be set to `True` and the end token is removed.
        """
        # the first token may be a colon for python compatibility
        self.stream.skip_if('colon')

        # in the future it would be possible to add whole code sections
        # by adding some sort of end of statement token and parsing those here.
        self.stream.expect('block_end')
        result = self.subparse(end_tokens)

        if drop_needle:
            next(self.stream)
        return result
コード例 #27
0
ファイル: ext.py プロジェクト: eklitzke/lexigraph
    def _parse_block(self, parser, allow_pluralize):
        """Parse until the next block tag with a given name."""
        referenced = []
        buf = []
        while 1:
            if parser.stream.current.type == 'data':
                buf.append(parser.stream.current.value.replace('%', '%%'))
                next(parser.stream)
            elif parser.stream.current.type == 'variable_begin':
                next(parser.stream)
                name = parser.stream.expect('name').value
                referenced.append(name)
                buf.append('%%(%s)s' % name)
                parser.stream.expect('variable_end')
            elif parser.stream.current.type == 'block_begin':
                next(parser.stream)
                if parser.stream.current.test('name:endtrans'):
                    break
                elif parser.stream.current.test('name:pluralize'):
                    if allow_pluralize:
                        break
                    parser.fail('a translatable section can have only one '
                                'pluralize section')
                parser.fail('control structures in translatable sections are '
                            'not allowed')
            elif parser.stream.eos:
                parser.fail('unclosed translation block')
            else:
                assert False, 'internal parser error'

        return referenced, concat(buf)
コード例 #28
0
ファイル: parser.py プロジェクト: eklitzke/lexigraph
    def parse_subscribed(self):
        lineno = self.stream.current.lineno

        if self.stream.current.type == 'colon':
            next(self.stream)
            args = [None]
        else:
            node = self.parse_expression()
            if self.stream.current.type != 'colon':
                return node
            next(self.stream)
            args = [node]

        if self.stream.current.type == 'colon':
            args.append(None)
        elif self.stream.current.type not in ('rbracket', 'comma'):
            args.append(self.parse_expression())
        else:
            args.append(None)

        if self.stream.current.type == 'colon':
            next(self.stream)
            if self.stream.current.type not in ('rbracket', 'comma'):
                args.append(self.parse_expression())
            else:
                args.append(None)
        else:
            args.append(None)

        return nodes.Slice(lineno=lineno, *args)
コード例 #29
0
ファイル: parser.py プロジェクト: eklitzke/lexigraph
    def parse_call_block(self):
        node = nodes.CallBlock(lineno=next(self.stream).lineno)
        if self.stream.current.type == 'lparen':
            self.parse_signature(node)
        else:
            node.args = []
            node.defaults = []

        node.call = self.parse_expression()
        if not isinstance(node.call, nodes.Call):
            self.fail('expected call', node.lineno)
        node.body = self.parse_statements(('name:endcall',), drop_needle=True)
        return node
コード例 #30
0
ファイル: parser.py プロジェクト: eklitzke/lexigraph
 def parse_for(self):
     """Parse a for loop."""
     lineno = self.stream.expect('name:for').lineno
     target = self.parse_assign_target(extra_end_rules=('name:in',))
     self.stream.expect('name:in')
     iter = self.parse_tuple(with_condexpr=False,
                             extra_end_rules=('name:recursive',))
     test = None
     if self.stream.skip_if('name:if'):
         test = self.parse_expression()
     recursive = self.stream.skip_if('name:recursive')
     body = self.parse_statements(('name:endfor', 'name:else'))
     if next(self.stream).value == 'endfor':
         else_ = []
     else:
         else_ = self.parse_statements(('name:endfor',), drop_needle=True)
     return nodes.For(target, iter, body, else_, test,
                      recursive, lineno=lineno)