blob: 38042ae96041e47fea51d54025cb9ab40f3a0b8a [file] [log] [blame]
Jeremy Hylton816e1492001-03-22 23:32:22 +00001"""Interface to the compiler's internal symbol tables"""
Jeremy Hylton816e1492001-03-22 23:32:22 +00002
3import _symtable
4from _symtable import USE, DEF_GLOBAL, DEF_LOCAL, DEF_PARAM, \
5 DEF_STAR, DEF_DOUBLESTAR, DEF_INTUPLE, DEF_FREE, \
Jeremy Hylton5030cf12001-04-16 18:43:18 +00006 DEF_FREE_GLOBAL, DEF_FREE_CLASS, DEF_IMPORT, DEF_BOUND, \
7 OPT_IMPORT_STAR, OPT_EXEC, OPT_BARE_EXEC
Jeremy Hylton816e1492001-03-22 23:32:22 +00008
9import weakref
10
Jeremy Hylton101651c2001-03-23 15:41:14 +000011__all__ = ["symtable", "SymbolTable", "newSymbolTable", "Class",
12 "Function", "Symbol"]
Jeremy Hylton816e1492001-03-22 23:32:22 +000013
14def symtable(code, filename, compile_type):
15 raw = _symtable.symtable(code, filename, compile_type)
16 return newSymbolTable(raw[0], filename)
17
18class SymbolTableFactory:
19 def __init__(self):
20 self.__memo = weakref.WeakValueDictionary()
21
22 def new(self, table, filename):
23 if table.type == _symtable.TYPE_FUNCTION:
24 return Function(table, filename)
25 if table.type == _symtable.TYPE_CLASS:
26 return Class(table, filename)
27 return SymbolTable(table, filename)
28
29 def __call__(self, table, filename):
30 key = table, filename
31 obj = self.__memo.get(key, None)
32 if obj is None:
33 obj = self.__memo[key] = self.new(table, filename)
34 return obj
35
36newSymbolTable = SymbolTableFactory()
Tim Petersa19a1682001-03-29 04:36:09 +000037
Jeremy Hylton816e1492001-03-22 23:32:22 +000038def is_free(flags):
39 if (flags & (USE | DEF_FREE)) \
40 and (flags & (DEF_LOCAL | DEF_PARAM | DEF_GLOBAL)):
Tim Petersbc0e9102002-04-04 22:55:58 +000041 return True
Jeremy Hylton816e1492001-03-22 23:32:22 +000042 if flags & DEF_FREE_CLASS:
Tim Petersbc0e9102002-04-04 22:55:58 +000043 return True
44 return False
Jeremy Hylton816e1492001-03-22 23:32:22 +000045
46class SymbolTable:
47 def __init__(self, raw_table, filename):
48 self._table = raw_table
49 self._filename = filename
50 self._symbols = {}
51
52 def __repr__(self):
53 if self.__class__ == SymbolTable:
54 kind = ""
55 else:
56 kind = "%s " % self.__class__.__name__
Tim Petersa19a1682001-03-29 04:36:09 +000057
Jeremy Hylton816e1492001-03-22 23:32:22 +000058 if self._table.name == "global":
59 return "<%sSymbolTable for module %s>" % (kind, self._filename)
60 else:
61 return "<%sSymbolTable for %s in %s>" % (kind, self._table.name,
62 self._filename)
63
64 def get_type(self):
65 if self._table.type == _symtable.TYPE_MODULE:
66 return "module"
67 if self._table.type == _symtable.TYPE_FUNCTION:
68 return "function"
69 if self._table.type == _symtable.TYPE_CLASS:
70 return "class"
71 assert self._table.type in (1, 2, 3), \
72 "unexpected type: %s" % self._table.type
73
74 def get_id(self):
75 return self._table.id
76
77 def get_name(self):
78 return self._table.name
79
80 def get_lineno(self):
81 return self._table.lineno
82
83 def is_optimized(self):
84 return bool(self._table.type == _symtable.TYPE_FUNCTION
85 and not self._table.optimized)
86
87 def is_nested(self):
88 return bool(self._table.nested)
89
90 def has_children(self):
91 return bool(self._table.children)
92
93 def has_exec(self):
Jeremy Hylton5030cf12001-04-16 18:43:18 +000094 """Return true if the scope uses exec"""
95 return bool(self._table.optimized & (OPT_EXEC | OPT_BARE_EXEC))
96
97 def has_import_star(self):
98 """Return true if the scope uses import *"""
99 return bool(self._table.optimized & OPT_IMPORT_STAR)
Jeremy Hylton816e1492001-03-22 23:32:22 +0000100
101 def get_identifiers(self):
102 return self._table.symbols.keys()
103
104 def lookup(self, name):
105 sym = self._symbols.get(name)
106 if sym is None:
107 flags = self._table.symbols[name]
108 namespaces = self.__check_children(name)
109 sym = self._symbols[name] = Symbol(name, flags, namespaces)
110 return sym
111
112 def get_symbols(self):
113 return [self.lookup(ident) for ident in self.get_identifiers()]
114
115 def __check_children(self, name):
116 return [newSymbolTable(st, self._filename)
117 for st in self._table.children
118 if st.name == name]
119
Jeremy Hylton101651c2001-03-23 15:41:14 +0000120 def get_children(self):
121 return [newSymbolTable(st, self._filename)
122 for st in self._table.children]
123
Jeremy Hylton816e1492001-03-22 23:32:22 +0000124class Function(SymbolTable):
125
126 # Default values for instance variables
127 __params = None
128 __locals = None
129 __frees = None
130 __globals = None
131
132 def __idents_matching(self, test_func):
133 return tuple([ident for ident in self.get_identifiers()
134 if test_func(self._table.symbols[ident])])
135
136 def get_parameters(self):
137 if self.__params is None:
138 self.__params = self.__idents_matching(lambda x:x & DEF_PARAM)
139 return self.__params
140
141 def get_locals(self):
142 if self.__locals is None:
143 self.__locals = self.__idents_matching(lambda x:x & DEF_BOUND)
144 return self.__locals
Tim Petersa19a1682001-03-29 04:36:09 +0000145
Jeremy Hylton816e1492001-03-22 23:32:22 +0000146 def get_globals(self):
147 if self.__globals is None:
148 glob = DEF_GLOBAL | DEF_FREE_GLOBAL
149 self.__globals = self.__idents_matching(lambda x:x & glob)
150 return self.__globals
151
152 def get_frees(self):
153 if self.__frees is None:
154 self.__frees = self.__idents_matching(is_free)
155 return self.__frees
156
157class Class(SymbolTable):
158
159 __methods = None
160
161 def get_methods(self):
162 if self.__methods is None:
163 d = {}
164 for st in self._table.children:
165 d[st.name] = 1
Raymond Hettingere0d49722002-06-02 18:55:56 +0000166 self.__methods = tuple(d)
Jeremy Hylton816e1492001-03-22 23:32:22 +0000167 return self.__methods
168
169class Symbol:
170 def __init__(self, name, flags, namespaces=None):
171 self.__name = name
172 self.__flags = flags
173 self.__namespaces = namespaces or ()
174
175 def __repr__(self):
176 return "<symbol '%s'>" % self.__name
177
178 def get_name(self):
179 return self.__name
180
181 def is_referenced(self):
182 return bool(self.__flags & _symtable.USE)
183
184 def is_parameter(self):
185 return bool(self.__flags & DEF_PARAM)
186
187 def is_global(self):
Tim Petersa19a1682001-03-29 04:36:09 +0000188 return bool((self.__flags & DEF_GLOBAL)
Jeremy Hylton816e1492001-03-22 23:32:22 +0000189 or (self.__flags & DEF_FREE_GLOBAL))
190
191 def is_vararg(self):
Jeremy Hylton5030cf12001-04-16 18:43:18 +0000192 return bool(self.__flags & DEF_STAR)
Jeremy Hylton816e1492001-03-22 23:32:22 +0000193
194 def is_keywordarg(self):
Jeremy Hylton5030cf12001-04-16 18:43:18 +0000195 return bool(self.__flags & DEF_DOUBLESTAR)
Jeremy Hylton816e1492001-03-22 23:32:22 +0000196
197 def is_local(self):
198 return bool(self.__flags & DEF_BOUND)
199
200 def is_free(self):
201 if (self.__flags & (USE | DEF_FREE)) \
202 and (self.__flags & (DEF_LOCAL | DEF_PARAM | DEF_GLOBAL)):
Tim Petersbc0e9102002-04-04 22:55:58 +0000203 return True
Jeremy Hylton816e1492001-03-22 23:32:22 +0000204 if self.__flags & DEF_FREE_CLASS:
Tim Petersbc0e9102002-04-04 22:55:58 +0000205 return True
206 return False
Jeremy Hylton816e1492001-03-22 23:32:22 +0000207
208 def is_imported(self):
209 return bool(self.__flags & DEF_IMPORT)
210
211 def is_assigned(self):
212 return bool(self.__flags & DEF_LOCAL)
213
214 def is_in_tuple(self):
215 return bool(self.__flags & DEF_INTUPLE)
216
217 def is_namespace(self):
218 """Returns true if name binding introduces new namespace.
219
220 If the name is used as the target of a function or class
221 statement, this will be true.
222
223 Note that a single name can be bound to multiple objects. If
224 is_namespace() is true, the name may also be bound to other
225 objects, like an int or list, that does not introduce a new
226 namespace.
227 """
228 return bool(self.__namespaces)
229
230 def get_namespaces(self):
231 """Return a list of namespaces bound to this name"""
232 return self.__namespaces
233
234 def get_namespace(self):
235 """Returns the single namespace bound to this name.
236
237 Raises ValueError if the name is bound to multiple namespaces.
238 """
239 if len(self.__namespaces) != 1:
240 raise ValueError, "name is bound to multiple namespaces"
241 return self.__namespaces[0]
242
Jeremy Hylton816e1492001-03-22 23:32:22 +0000243if __name__ == "__main__":
244 import os, sys
245 src = open(sys.argv[0]).read()
246 mod = symtable(src, os.path.split(sys.argv[0])[1], "exec")
247 for ident in mod.get_identifiers():
248 info = mod.lookup(ident)
249 print info, info.is_local(), info.is_namespace()