Mercurial > genshi > mirror

annotate markup/eval.py @ 118:c392d38694d9 trunk

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Add basic support for using `lambda`s in expressions. Closes #21. (Not sure about default arguments, need a test case).
author cmlenz
date Tue, 01 Aug 2006 22:34:39 +0000
parents c77c113846d6
children c9f0a26e28a2
rev   line source
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
1 # -*- coding: utf-8 -*-
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
2 #
66
59eb24184e9c Switch copyright to Edgewall and URLs to markup.edgewall.org.
cmlenz
parents: 42
diff changeset
3 # Copyright (C) 2006 Edgewall Software
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
4 # All rights reserved.
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
5 #
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
6 # This software is licensed as described in the file COPYING, which
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
7 # you should have received as part of this distribution. The terms
66
59eb24184e9c Switch copyright to Edgewall and URLs to markup.edgewall.org.
cmlenz
parents: 42
diff changeset
8 # are also available at http://markup.edgewall.org/wiki/License.
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
9 #
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
10 # This software consists of voluntary contributions made by many
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
11 # individuals. For the exact contribution history, see the revision
66
59eb24184e9c Switch copyright to Edgewall and URLs to markup.edgewall.org.
cmlenz
parents: 42
diff changeset
12 # history and logs, available at http://markup.edgewall.org/log/.
27
b4f78c05e5c9 * Fix the boilerplate in the Python source files.
cmlenz
parents: 16
diff changeset
13
b4f78c05e5c9 * Fix the boilerplate in the Python source files.
cmlenz
parents: 16
diff changeset
14 """Support for "safe" evaluation of Python expressions."""
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
15
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
16 import __builtin__
87
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
17 from compiler import ast, parse
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
18 from compiler.pycodegen import ExpressionCodeGenerator
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
19
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
20 from markup.core import Stream
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
21
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
22 __all__ = ['Expression']
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
23
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
24
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
25 class Expression(object):
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
26 """Evaluates Python expressions used in templates.
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
27
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
28 >>> data = dict(test='Foo', items=[1, 2, 3], dict={'some': 'thing'})
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
29 >>> Expression('test').evaluate(data)
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
30 'Foo'
81
d60486018004 Template expressions are now compiled to Python bytecode.
cmlenz
parents: 69
diff changeset
31
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
32 >>> Expression('items[0]').evaluate(data)
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
33 1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
34 >>> Expression('items[-1]').evaluate(data)
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
35 3
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
36 >>> Expression('dict["some"]').evaluate(data)
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
37 'thing'
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
38
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
39 Similar to e.g. Javascript, expressions in templates can use the dot
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
40 notation for attribute access to access items in mappings:
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
41
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
42 >>> Expression('dict.some').evaluate(data)
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
43 'thing'
86
a54ebae77330 Accidentially left some doctests disabled.
cmlenz
parents: 82
diff changeset
44
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
45 This also works the other way around: item access can be used to access
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
46 any object attribute (meaning there's no use for `getattr()` in templates):
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
47
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
48 >>> class MyClass(object):
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
49 ... myattr = 'Bar'
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
50 >>> data = dict(mine=MyClass(), key='myattr')
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
51 >>> Expression('mine.myattr').evaluate(data)
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
52 'Bar'
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
53 >>> Expression('mine["myattr"]').evaluate(data)
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
54 'Bar'
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
55 >>> Expression('mine[key]').evaluate(data)
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
56 'Bar'
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
57
31
2ab5fa60575d * More test cases for expression evaluation.
cmlenz
parents: 30
diff changeset
58 All of the standard Python operators are available to template expressions.
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
59 Built-in functions such as `len()` are also available in template
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
60 expressions:
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
61
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
62 >>> data = dict(items=[1, 2, 3])
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
63 >>> Expression('len(items)').evaluate(data)
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
64 3
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
65 """
81
d60486018004 Template expressions are now compiled to Python bytecode.
cmlenz
parents: 69
diff changeset
66 __slots__ = ['source', 'code']
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
67
81
d60486018004 Template expressions are now compiled to Python bytecode.
cmlenz
parents: 69
diff changeset
68 def __init__(self, source, filename=None, lineno=-1):
27
b4f78c05e5c9 * Fix the boilerplate in the Python source files.
cmlenz
parents: 16
diff changeset
69 """Create the expression.
b4f78c05e5c9 * Fix the boilerplate in the Python source files.
cmlenz
parents: 16
diff changeset
70
b4f78c05e5c9 * Fix the boilerplate in the Python source files.
cmlenz
parents: 16
diff changeset
71 @param source: the expression as string
b4f78c05e5c9 * Fix the boilerplate in the Python source files.
cmlenz
parents: 16
diff changeset
72 """
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
73 self.source = source
116
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 112
diff changeset
74 self.code = _compile(source, filename, lineno)
1
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
75
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
76 def __repr__(self):
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
77 return '<Expression "%s">' % self.source
5479aae32f5a Initial import.
cmlenz
parents:
diff changeset
78
81
d60486018004 Template expressions are now compiled to Python bytecode.
cmlenz
parents: 69
diff changeset
79 def evaluate(self, data):
d60486018004 Template expressions are now compiled to Python bytecode.
cmlenz
parents: 69
diff changeset
80 """Evaluate the expression against the given data dictionary.
d60486018004 Template expressions are now compiled to Python bytecode.
cmlenz
parents: 69
diff changeset
81
d60486018004 Template expressions are now compiled to Python bytecode.
cmlenz
parents: 69
diff changeset
82 @param data: a mapping containing the data to evaluate against
d60486018004 Template expressions are now compiled to Python bytecode.
cmlenz
parents: 69
diff changeset
83 @return: the result of the evaluation
d60486018004 Template expressions are now compiled to Python bytecode.
cmlenz
parents: 69
diff changeset
84 """
118
c392d38694d9 Add basic support for using `lambda`s in expressions. Closes #21. (Not sure about default arguments, need a test case).
cmlenz
parents: 116
diff changeset
85 retval = eval(self.code, {'data': data,
c392d38694d9 Add basic support for using `lambda`s in expressions. Closes #21. (Not sure about default arguments, need a test case).
cmlenz
parents: 116
diff changeset
86 '_lookup_name': _lookup_name,
c392d38694d9 Add basic support for using `lambda`s in expressions. Closes #21. (Not sure about default arguments, need a test case).
cmlenz
parents: 116
diff changeset
87 '_lookup_attr': _lookup_attr,
c392d38694d9 Add basic support for using `lambda`s in expressions. Closes #21. (Not sure about default arguments, need a test case).
cmlenz
parents: 116
diff changeset
88 '_lookup_item': _lookup_item})
90
c835e81c50af When an expression evaluates to a callable, it is called implicitly.
cmlenz
parents: 88
diff changeset
89 if callable(retval):
c835e81c50af When an expression evaluates to a callable, it is called implicitly.
cmlenz
parents: 88
diff changeset
90 retval = retval()
c835e81c50af When an expression evaluates to a callable, it is called implicitly.
cmlenz
parents: 88
diff changeset
91 return retval
30
bcdbb7e5e4e5 Experimental support for using the new native AST in Python 2.5 instead of the `compiler` package.
cmlenz
parents: 27
diff changeset
92
87
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
93
116
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 112
diff changeset
94 def _compile(source, filename=None, lineno=-1):
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 112
diff changeset
95 tree = parse(source, 'eval')
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 112
diff changeset
96 xform = ExpressionASTTransformer()
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 112
diff changeset
97 tree = xform.visit(tree)
87
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
98
116
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 112
diff changeset
99 if isinstance(filename, unicode):
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 112
diff changeset
100 # pycodegen doesn't like unicode in the filename
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 112
diff changeset
101 filename = filename.encode('utf-8', 'replace')
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 112
diff changeset
102 tree.filename = filename or '<string>'
87
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
103
116
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 112
diff changeset
104 gen = ExpressionCodeGenerator(tree)
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 112
diff changeset
105 if lineno >= 0:
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 112
diff changeset
106 gen.emit('SET_LINENO', lineno)
87
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
107
116
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 112
diff changeset
108 return gen.getCode()
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 112
diff changeset
109
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 112
diff changeset
110 def _lookup_name(data, name, locals=None):
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 112
diff changeset
111 val = data.get(name)
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 112
diff changeset
112 if val is None and locals:
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 112
diff changeset
113 val = locals.get(name)
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 112
diff changeset
114 if val is None:
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 112
diff changeset
115 val = getattr(__builtin__, name, None)
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 112
diff changeset
116 return val
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 112
diff changeset
117
118
c392d38694d9 Add basic support for using `lambda`s in expressions. Closes #21. (Not sure about default arguments, need a test case).
cmlenz
parents: 116
diff changeset
118 def _lookup_attr(data, obj, key):
116
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 112
diff changeset
119 if hasattr(obj, key):
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 112
diff changeset
120 return getattr(obj, key)
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 112
diff changeset
121 try:
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 112
diff changeset
122 return obj[key]
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 112
diff changeset
123 except (KeyError, TypeError):
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 112
diff changeset
124 return None
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 112
diff changeset
125
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 112
diff changeset
126 def _lookup_item(data, obj, key):
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 112
diff changeset
127 if len(key) == 1:
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 112
diff changeset
128 key = key[0]
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 112
diff changeset
129 try:
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 112
diff changeset
130 return obj[key]
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 112
diff changeset
131 except (KeyError, IndexError, TypeError), e:
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 112
diff changeset
132 pass
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 112
diff changeset
133 if isinstance(key, basestring):
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 112
diff changeset
134 try:
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 112
diff changeset
135 return getattr(obj, key)
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 112
diff changeset
136 except (AttributeError, TypeError), e:
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 112
diff changeset
137 pass
87
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
138
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
139 class ASTTransformer(object):
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
140 """General purpose base class for AST transformations.
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
141
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
142 Every visitor method can be overridden to return an AST node that has been
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
143 altered or replaced in some way.
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
144 """
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
145 _visitors = {}
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
146
88
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
147 def visit(self, node, *args, **kwargs):
87
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
148 v = self._visitors.get(node.__class__)
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
149 if not v:
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
150 v = getattr(self, 'visit%s' % node.__class__.__name__)
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
151 self._visitors[node.__class__] = v
88
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
152 return v(node, *args, **kwargs)
87
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
153
88
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
154 def visitExpression(self, node, *args, **kwargs):
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
155 node.node = self.visit(node.node, *args, **kwargs)
87
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
156 return node
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
157
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
158 # Functions & Accessors
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
159
88
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
160 def visitCallFunc(self, node, *args, **kwargs):
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
161 node.node = self.visit(node.node, *args, **kwargs)
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
162 node.args = map(lambda x: self.visit(x, *args, **kwargs), node.args)
87
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
163 if node.star_args:
88
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
164 node.star_args = map(lambda x: self.visit(x, *args, **kwargs),
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
165 node.star_args)
87
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
166 if node.dstar_args:
88
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
167 node.dstart_args = map(lambda x: self.visit(x, *args, **kwargs),
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
168 node.dstar_args)
87
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
169 return node
30
bcdbb7e5e4e5 Experimental support for using the new native AST in Python 2.5 instead of the `compiler` package.
cmlenz
parents: 27
diff changeset
170
118
c392d38694d9 Add basic support for using `lambda`s in expressions. Closes #21. (Not sure about default arguments, need a test case).
cmlenz
parents: 116
diff changeset
171 def visitLambda(self, node, *args, **kwargs):
c392d38694d9 Add basic support for using `lambda`s in expressions. Closes #21. (Not sure about default arguments, need a test case).
cmlenz
parents: 116
diff changeset
172 node.code = self.visit(node.code, *args, **kwargs)
c392d38694d9 Add basic support for using `lambda`s in expressions. Closes #21. (Not sure about default arguments, need a test case).
cmlenz
parents: 116
diff changeset
173 node.filename = '<string>' # workaround for bug in pycodegen
c392d38694d9 Add basic support for using `lambda`s in expressions. Closes #21. (Not sure about default arguments, need a test case).
cmlenz
parents: 116
diff changeset
174 return node
c392d38694d9 Add basic support for using `lambda`s in expressions. Closes #21. (Not sure about default arguments, need a test case).
cmlenz
parents: 116
diff changeset
175
88
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
176 def visitGetattr(self, node, *args, **kwargs):
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
177 node.expr = self.visit(node.expr, *args, **kwargs)
87
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
178 return node
30
bcdbb7e5e4e5 Experimental support for using the new native AST in Python 2.5 instead of the `compiler` package.
cmlenz
parents: 27
diff changeset
179
88
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
180 def visitSubscript(self, node, *args, **kwargs):
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
181 node.expr = self.visit(node.expr, *args, **kwargs)
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
182 node.subs = map(lambda x: self.visit(x, *args, **kwargs), node.subs)
87
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
183 return node
30
bcdbb7e5e4e5 Experimental support for using the new native AST in Python 2.5 instead of the `compiler` package.
cmlenz
parents: 27
diff changeset
184
87
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
185 # Operators
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
186
88
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
187 def _visitBoolOp(self, node, *args, **kwargs):
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
188 node.nodes = map(lambda x: self.visit(x, *args, **kwargs), node.nodes)
87
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
189 return node
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
190 visitAnd = visitOr = visitBitand = visitBitor = _visitBoolOp
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
191
88
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
192 def _visitBinOp(self, node, *args, **kwargs):
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
193 node.left = self.visit(node.left, *args, **kwargs)
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
194 node.right = self.visit(node.right, *args, **kwargs)
87
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
195 return node
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
196 visitAdd = visitSub = _visitBinOp
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
197 visitDiv = visitFloorDiv = visitMod = visitMul = visitPower = _visitBinOp
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
198 visitLeftShift = visitRightShift = _visitBinOp
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
199
88
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
200 def visitCompare(self, node, *args, **kwargs):
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
201 node.expr = self.visit(node.expr, *args, **kwargs)
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
202 node.ops = map(lambda (op, n): (op, self.visit(n, *args, **kwargs)),
87
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
203 node.ops)
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
204 return node
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
205
88
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
206 def _visitUnaryOp(self, node, *args, **kwargs):
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
207 node.expr = self.visit(node.expr, *args, **kwargs)
87
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
208 return node
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
209 visitUnaryAdd = visitUnarySub = visitNot = visitInvert = _visitUnaryOp
98
44af12832c5a Bugfix in `builder` module: attribute values need to be converted to strings when generating streams.
cmlenz
parents: 90
diff changeset
210 visitBackquote = _visitUnaryOp
87
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
211
88
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
212 # Identifiers, Literals and Comprehensions
87
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
213
88
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
214 def _visitDefault(self, node, *args, **kwargs):
87
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
215 return node
88
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
216 visitAssName = visitAssTuple = _visitDefault
102
e20a153cc20c Ported [118] to trunk
jonas
parents: 101
diff changeset
217 visitConst = visitName = _visitDefault
e20a153cc20c Ported [118] to trunk
jonas
parents: 101
diff changeset
218
e20a153cc20c Ported [118] to trunk
jonas
parents: 101
diff changeset
219 def visitKeyword(self, node, *args, **kwargs):
e20a153cc20c Ported [118] to trunk
jonas
parents: 101
diff changeset
220 node.expr = self.visit(node.expr, *args, **kwargs)
e20a153cc20c Ported [118] to trunk
jonas
parents: 101
diff changeset
221 return node
87
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
222
88
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
223 def visitDict(self, node, *args, **kwargs):
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
224 node.items = map(lambda (k, v): (self.visit(k, *args, **kwargs),
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
225 self.visit(v, *args, **kwargs)),
87
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
226 node.items)
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
227 return node
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
228
88
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
229 def visitTuple(self, node, *args, **kwargs):
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
230 node.nodes = map(lambda n: self.visit(n, *args, **kwargs), node.nodes)
87
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
231 return node
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
232
88
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
233 def visitList(self, node, *args, **kwargs):
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
234 node.nodes = map(lambda n: self.visit(n, *args, **kwargs), node.nodes)
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
235 return node
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
236
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
237 def visitListComp(self, node, *args, **kwargs):
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
238 node.expr = self.visit(node.expr, *args, **kwargs)
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
239 node.quals = map(lambda x: self.visit(x, *args, **kwargs), node.quals)
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
240 return node
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
241
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
242 def visitListCompFor(self, node, *args, **kwargs):
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
243 node.assign = self.visit(node.assign, *args, **kwargs)
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
244 node.list = self.visit(node.list, *args, **kwargs)
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
245 node.ifs = map(lambda x: self.visit(x, *args, **kwargs), node.ifs)
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
246 return node
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
247
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
248 def visitListCompIf(self, node, *args, **kwargs):
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
249 node.test = self.visit(node.test, *args, **kwargs)
87
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
250 return node
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
251
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
252
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
253 class ExpressionASTTransformer(ASTTransformer):
112
5f9af749341c Docstring typo fix.
cmlenz
parents: 102
diff changeset
254 """Concrete AST transformer that implements the AST transformations needed
5f9af749341c Docstring typo fix.
cmlenz
parents: 102
diff changeset
255 for template expressions.
87
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
256 """
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
257
88
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
258 def visitGetattr(self, node, *args, **kwargs):
118
c392d38694d9 Add basic support for using `lambda`s in expressions. Closes #21. (Not sure about default arguments, need a test case).
cmlenz
parents: 116
diff changeset
259 return ast.CallFunc(ast.Name('_lookup_attr'),
88
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
260 [ast.Name('data'), self.visit(node.expr, *args, **kwargs),
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
261 ast.Const(node.attrname)]
87
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
262 )
30
bcdbb7e5e4e5 Experimental support for using the new native AST in Python 2.5 instead of the `compiler` package.
cmlenz
parents: 27
diff changeset
263
118
c392d38694d9 Add basic support for using `lambda`s in expressions. Closes #21. (Not sure about default arguments, need a test case).
cmlenz
parents: 116
diff changeset
264 def visitLambda(self, node, *args, **kwargs):
c392d38694d9 Add basic support for using `lambda`s in expressions. Closes #21. (Not sure about default arguments, need a test case).
cmlenz
parents: 116
diff changeset
265 old_lookup_locals = kwargs.get('lookup_locals', False)
c392d38694d9 Add basic support for using `lambda`s in expressions. Closes #21. (Not sure about default arguments, need a test case).
cmlenz
parents: 116
diff changeset
266 kwargs['lookup_locals'] = True
c392d38694d9 Add basic support for using `lambda`s in expressions. Closes #21. (Not sure about default arguments, need a test case).
cmlenz
parents: 116
diff changeset
267 node.code = self.visit(node.code, *args, **kwargs)
c392d38694d9 Add basic support for using `lambda`s in expressions. Closes #21. (Not sure about default arguments, need a test case).
cmlenz
parents: 116
diff changeset
268 node.filename = '<string>' # workaround for bug in pycodegen
c392d38694d9 Add basic support for using `lambda`s in expressions. Closes #21. (Not sure about default arguments, need a test case).
cmlenz
parents: 116
diff changeset
269 kwargs['lookup_locals'] = old_lookup_locals
c392d38694d9 Add basic support for using `lambda`s in expressions. Closes #21. (Not sure about default arguments, need a test case).
cmlenz
parents: 116
diff changeset
270 return node
c392d38694d9 Add basic support for using `lambda`s in expressions. Closes #21. (Not sure about default arguments, need a test case).
cmlenz
parents: 116
diff changeset
271
88
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
272 def visitListComp(self, node, *args, **kwargs):
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
273 old_lookup_locals = kwargs.get('lookup_locals', False)
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
274 kwargs['lookup_locals'] = True
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
275 node.expr = self.visit(node.expr, *args, **kwargs)
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
276 node.quals = map(lambda x: self.visit(x, *args, **kwargs), node.quals)
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
277 kwargs['lookup_locals'] = old_lookup_locals
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
278 return node
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
279
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
280 def visitName(self, node, *args, **kwargs):
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
281 func_args = [ast.Name('data'), ast.Const(node.name)]
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
282 if kwargs.get('lookup_locals'):
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
283 func_args.append(ast.CallFunc(ast.Name('locals'), []))
116
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 112
diff changeset
284 return ast.CallFunc(ast.Name('_lookup_name'), func_args)
87
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
285 return node
81
d60486018004 Template expressions are now compiled to Python bytecode.
cmlenz
parents: 69
diff changeset
286
88
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
287 def visitSubscript(self, node, *args, **kwargs):
116
c77c113846d6 Merged [135:138/branches/experimental/cspeedups].
cmlenz
parents: 112
diff changeset
288 return ast.CallFunc(ast.Name('_lookup_item'),
88
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
289 [ast.Name('data'), self.visit(node.expr, *args, **kwargs),
628ba9ed39ef Add support for list comprehension in expressions (see #12).
cmlenz
parents: 87
diff changeset
290 ast.Tuple(map(self.visit, node.subs, *args, **kwargs))]
87
1b874f032bde Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13.
cmlenz
parents: 86
diff changeset
291 )
Copyright (C) 2012-2017 Edgewall Software