Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 1 | """Interface to the compiler's internal symbol tables""" |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 2 | |
| 3 | import _symtable |
Pablo Galindo | d5b4f1b | 2018-10-20 01:46:00 +0100 | [diff] [blame] | 4 | from _symtable import (USE, DEF_GLOBAL, DEF_NONLOCAL, DEF_LOCAL, DEF_PARAM, |
Yury Selivanov | f8cb8a1 | 2016-09-08 20:50:03 -0700 | [diff] [blame] | 5 | DEF_IMPORT, DEF_BOUND, DEF_ANNOT, SCOPE_OFF, SCOPE_MASK, FREE, |
Benjamin Peterson | 500c6ef | 2009-06-28 19:30:36 +0000 | [diff] [blame] | 6 | LOCAL, GLOBAL_IMPLICIT, GLOBAL_EXPLICIT, CELL) |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 7 | |
| 8 | import weakref |
| 9 | |
Benjamin Peterson | 3938a90 | 2008-08-20 02:33:00 +0000 | [diff] [blame] | 10 | __all__ = ["symtable", "SymbolTable", "Class", "Function", "Symbol"] |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 11 | |
| 12 | def symtable(code, filename, compile_type): |
Joannah Nanjekye | a95ac77 | 2020-07-07 20:09:56 -0300 | [diff] [blame] | 13 | """ Return the toplevel *SymbolTable* for the source code. |
| 14 | |
| 15 | *filename* is the name of the file with the code |
| 16 | and *compile_type* is the *compile()* mode argument. |
| 17 | """ |
Benjamin Peterson | 89d8cd9 | 2013-10-26 13:13:51 -0400 | [diff] [blame] | 18 | top = _symtable.symtable(code, filename, compile_type) |
Benjamin Peterson | 3938a90 | 2008-08-20 02:33:00 +0000 | [diff] [blame] | 19 | return _newSymbolTable(top, filename) |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 20 | |
| 21 | class SymbolTableFactory: |
| 22 | def __init__(self): |
| 23 | self.__memo = weakref.WeakValueDictionary() |
| 24 | |
| 25 | def new(self, table, filename): |
| 26 | if table.type == _symtable.TYPE_FUNCTION: |
| 27 | return Function(table, filename) |
| 28 | if table.type == _symtable.TYPE_CLASS: |
| 29 | return Class(table, filename) |
| 30 | return SymbolTable(table, filename) |
| 31 | |
| 32 | def __call__(self, table, filename): |
| 33 | key = table, filename |
| 34 | obj = self.__memo.get(key, None) |
| 35 | if obj is None: |
| 36 | obj = self.__memo[key] = self.new(table, filename) |
| 37 | return obj |
| 38 | |
Benjamin Peterson | 3938a90 | 2008-08-20 02:33:00 +0000 | [diff] [blame] | 39 | _newSymbolTable = SymbolTableFactory() |
Tim Peters | a19a168 | 2001-03-29 04:36:09 +0000 | [diff] [blame] | 40 | |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 41 | |
Pablo Galindo | fb0a465 | 2020-10-03 20:45:55 +0100 | [diff] [blame] | 42 | class SymbolTable: |
Benjamin Peterson | 55e00f2 | 2008-08-17 18:02:44 +0000 | [diff] [blame] | 43 | |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 44 | def __init__(self, raw_table, filename): |
| 45 | self._table = raw_table |
| 46 | self._filename = filename |
| 47 | self._symbols = {} |
| 48 | |
| 49 | def __repr__(self): |
| 50 | if self.__class__ == SymbolTable: |
| 51 | kind = "" |
| 52 | else: |
| 53 | kind = "%s " % self.__class__.__name__ |
Tim Peters | a19a168 | 2001-03-29 04:36:09 +0000 | [diff] [blame] | 54 | |
Pablo Galindo | fb0a465 | 2020-10-03 20:45:55 +0100 | [diff] [blame] | 55 | if self._table.name == "top": |
Benjamin Peterson | 55e00f2 | 2008-08-17 18:02:44 +0000 | [diff] [blame] | 56 | return "<{0}SymbolTable for module {1}>".format(kind, self._filename) |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 57 | else: |
Benjamin Peterson | 55e00f2 | 2008-08-17 18:02:44 +0000 | [diff] [blame] | 58 | return "<{0}SymbolTable for {1} in {2}>".format(kind, |
| 59 | self._table.name, |
| 60 | self._filename) |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 61 | |
| 62 | def get_type(self): |
Joannah Nanjekye | a95ac77 | 2020-07-07 20:09:56 -0300 | [diff] [blame] | 63 | """Return the type of the symbol table. |
| 64 | |
| 65 | The values retuned are 'class', 'module' and |
| 66 | 'function'. |
| 67 | """ |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 68 | if self._table.type == _symtable.TYPE_MODULE: |
| 69 | return "module" |
| 70 | if self._table.type == _symtable.TYPE_FUNCTION: |
| 71 | return "function" |
| 72 | if self._table.type == _symtable.TYPE_CLASS: |
| 73 | return "class" |
| 74 | assert self._table.type in (1, 2, 3), \ |
Benjamin Peterson | 55e00f2 | 2008-08-17 18:02:44 +0000 | [diff] [blame] | 75 | "unexpected type: {0}".format(self._table.type) |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 76 | |
| 77 | def get_id(self): |
Joannah Nanjekye | a95ac77 | 2020-07-07 20:09:56 -0300 | [diff] [blame] | 78 | """Return an identifier for the table. |
| 79 | """ |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 80 | return self._table.id |
| 81 | |
| 82 | def get_name(self): |
Joannah Nanjekye | a95ac77 | 2020-07-07 20:09:56 -0300 | [diff] [blame] | 83 | """Return the table's name. |
| 84 | |
| 85 | This corresponds to the name of the class, function |
| 86 | or 'top' if the table is for a class, function or |
| 87 | global respectively. |
| 88 | """ |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 89 | return self._table.name |
| 90 | |
| 91 | def get_lineno(self): |
Joannah Nanjekye | a95ac77 | 2020-07-07 20:09:56 -0300 | [diff] [blame] | 92 | """Return the number of the first line in the |
| 93 | block for the table. |
| 94 | """ |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 95 | return self._table.lineno |
| 96 | |
| 97 | def is_optimized(self): |
Joannah Nanjekye | a95ac77 | 2020-07-07 20:09:56 -0300 | [diff] [blame] | 98 | """Return *True* if the locals in the table |
| 99 | are optimizable. |
| 100 | """ |
Benjamin Peterson | 1dfd247 | 2015-04-27 21:44:22 -0400 | [diff] [blame] | 101 | return bool(self._table.type == _symtable.TYPE_FUNCTION) |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 102 | |
| 103 | def is_nested(self): |
Joannah Nanjekye | a95ac77 | 2020-07-07 20:09:56 -0300 | [diff] [blame] | 104 | """Return *True* if the block is a nested class |
| 105 | or function.""" |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 106 | return bool(self._table.nested) |
| 107 | |
| 108 | def has_children(self): |
Joannah Nanjekye | a95ac77 | 2020-07-07 20:09:56 -0300 | [diff] [blame] | 109 | """Return *True* if the block has nested namespaces. |
| 110 | """ |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 111 | return bool(self._table.children) |
| 112 | |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 113 | def get_identifiers(self): |
Joannah Nanjekye | a95ac77 | 2020-07-07 20:09:56 -0300 | [diff] [blame] | 114 | """Return a list of names of symbols in the table. |
| 115 | """ |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 116 | return self._table.symbols.keys() |
| 117 | |
| 118 | def lookup(self, name): |
Joannah Nanjekye | a95ac77 | 2020-07-07 20:09:56 -0300 | [diff] [blame] | 119 | """Lookup a *name* in the table. |
| 120 | |
| 121 | Returns a *Symbol* instance. |
| 122 | """ |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 123 | sym = self._symbols.get(name) |
| 124 | if sym is None: |
| 125 | flags = self._table.symbols[name] |
| 126 | namespaces = self.__check_children(name) |
Pablo Galindo | fb0a465 | 2020-10-03 20:45:55 +0100 | [diff] [blame] | 127 | module_scope = (self._table.name == "top") |
| 128 | sym = self._symbols[name] = Symbol(name, flags, namespaces, |
| 129 | module_scope=module_scope) |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 130 | return sym |
| 131 | |
| 132 | def get_symbols(self): |
Joannah Nanjekye | a95ac77 | 2020-07-07 20:09:56 -0300 | [diff] [blame] | 133 | """Return a list of *Symbol* instances for |
| 134 | names in the table. |
| 135 | """ |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 136 | return [self.lookup(ident) for ident in self.get_identifiers()] |
| 137 | |
| 138 | def __check_children(self, name): |
Benjamin Peterson | 3938a90 | 2008-08-20 02:33:00 +0000 | [diff] [blame] | 139 | return [_newSymbolTable(st, self._filename) |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 140 | for st in self._table.children |
| 141 | if st.name == name] |
| 142 | |
Jeremy Hylton | 101651c | 2001-03-23 15:41:14 +0000 | [diff] [blame] | 143 | def get_children(self): |
Joannah Nanjekye | a95ac77 | 2020-07-07 20:09:56 -0300 | [diff] [blame] | 144 | """Return a list of the nested symbol tables. |
| 145 | """ |
Benjamin Peterson | 3938a90 | 2008-08-20 02:33:00 +0000 | [diff] [blame] | 146 | return [_newSymbolTable(st, self._filename) |
Jeremy Hylton | 101651c | 2001-03-23 15:41:14 +0000 | [diff] [blame] | 147 | for st in self._table.children] |
| 148 | |
Benjamin Peterson | 55e00f2 | 2008-08-17 18:02:44 +0000 | [diff] [blame] | 149 | |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 150 | class Function(SymbolTable): |
| 151 | |
| 152 | # Default values for instance variables |
| 153 | __params = None |
| 154 | __locals = None |
| 155 | __frees = None |
| 156 | __globals = None |
Pablo Galindo | d5b4f1b | 2018-10-20 01:46:00 +0100 | [diff] [blame] | 157 | __nonlocals = None |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 158 | |
| 159 | def __idents_matching(self, test_func): |
Jon Dufresne | 3972628 | 2017-05-18 07:35:54 -0700 | [diff] [blame] | 160 | return tuple(ident for ident in self.get_identifiers() |
| 161 | if test_func(self._table.symbols[ident])) |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 162 | |
| 163 | def get_parameters(self): |
Joannah Nanjekye | a95ac77 | 2020-07-07 20:09:56 -0300 | [diff] [blame] | 164 | """Return a tuple of parameters to the function. |
| 165 | """ |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 166 | if self.__params is None: |
| 167 | self.__params = self.__idents_matching(lambda x:x & DEF_PARAM) |
| 168 | return self.__params |
| 169 | |
| 170 | def get_locals(self): |
Joannah Nanjekye | a95ac77 | 2020-07-07 20:09:56 -0300 | [diff] [blame] | 171 | """Return a tuple of locals in the function. |
| 172 | """ |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 173 | if self.__locals is None: |
Benjamin Peterson | 500c6ef | 2009-06-28 19:30:36 +0000 | [diff] [blame] | 174 | locs = (LOCAL, CELL) |
| 175 | test = lambda x: ((x >> SCOPE_OFF) & SCOPE_MASK) in locs |
Benjamin Peterson | 78565b2 | 2009-06-28 19:19:51 +0000 | [diff] [blame] | 176 | self.__locals = self.__idents_matching(test) |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 177 | return self.__locals |
Tim Peters | a19a168 | 2001-03-29 04:36:09 +0000 | [diff] [blame] | 178 | |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 179 | def get_globals(self): |
Joannah Nanjekye | a95ac77 | 2020-07-07 20:09:56 -0300 | [diff] [blame] | 180 | """Return a tuple of globals in the function. |
| 181 | """ |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 182 | if self.__globals is None: |
Benjamin Peterson | 55e00f2 | 2008-08-17 18:02:44 +0000 | [diff] [blame] | 183 | glob = (GLOBAL_IMPLICIT, GLOBAL_EXPLICIT) |
| 184 | test = lambda x:((x >> SCOPE_OFF) & SCOPE_MASK) in glob |
| 185 | self.__globals = self.__idents_matching(test) |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 186 | return self.__globals |
| 187 | |
Pablo Galindo | d5b4f1b | 2018-10-20 01:46:00 +0100 | [diff] [blame] | 188 | def get_nonlocals(self): |
Joannah Nanjekye | a95ac77 | 2020-07-07 20:09:56 -0300 | [diff] [blame] | 189 | """Return a tuple of nonlocals in the function. |
| 190 | """ |
Pablo Galindo | d5b4f1b | 2018-10-20 01:46:00 +0100 | [diff] [blame] | 191 | if self.__nonlocals is None: |
| 192 | self.__nonlocals = self.__idents_matching(lambda x:x & DEF_NONLOCAL) |
| 193 | return self.__nonlocals |
| 194 | |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 195 | def get_frees(self): |
Joannah Nanjekye | a95ac77 | 2020-07-07 20:09:56 -0300 | [diff] [blame] | 196 | """Return a tuple of free variables in the function. |
| 197 | """ |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 198 | if self.__frees is None: |
Benjamin Peterson | 55e00f2 | 2008-08-17 18:02:44 +0000 | [diff] [blame] | 199 | is_free = lambda x:((x >> SCOPE_OFF) & SCOPE_MASK) == FREE |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 200 | self.__frees = self.__idents_matching(is_free) |
| 201 | return self.__frees |
| 202 | |
Benjamin Peterson | 55e00f2 | 2008-08-17 18:02:44 +0000 | [diff] [blame] | 203 | |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 204 | class Class(SymbolTable): |
| 205 | |
| 206 | __methods = None |
| 207 | |
| 208 | def get_methods(self): |
Joannah Nanjekye | a95ac77 | 2020-07-07 20:09:56 -0300 | [diff] [blame] | 209 | """Return a tuple of methods declared in the class. |
| 210 | """ |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 211 | if self.__methods is None: |
| 212 | d = {} |
| 213 | for st in self._table.children: |
| 214 | d[st.name] = 1 |
Benjamin Peterson | b71caf1 | 2008-08-20 12:55:31 +0000 | [diff] [blame] | 215 | self.__methods = tuple(d) |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 216 | return self.__methods |
| 217 | |
Benjamin Peterson | 55e00f2 | 2008-08-17 18:02:44 +0000 | [diff] [blame] | 218 | |
Pablo Galindo | fb0a465 | 2020-10-03 20:45:55 +0100 | [diff] [blame] | 219 | class Symbol: |
Benjamin Peterson | 55e00f2 | 2008-08-17 18:02:44 +0000 | [diff] [blame] | 220 | |
Pablo Galindo | fb0a465 | 2020-10-03 20:45:55 +0100 | [diff] [blame] | 221 | def __init__(self, name, flags, namespaces=None, *, module_scope=False): |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 222 | self.__name = name |
| 223 | self.__flags = flags |
Benjamin Peterson | 55e00f2 | 2008-08-17 18:02:44 +0000 | [diff] [blame] | 224 | self.__scope = (flags >> SCOPE_OFF) & SCOPE_MASK # like PyST_GetScope() |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 225 | self.__namespaces = namespaces or () |
Pablo Galindo | fb0a465 | 2020-10-03 20:45:55 +0100 | [diff] [blame] | 226 | self.__module_scope = module_scope |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 227 | |
| 228 | def __repr__(self): |
Benjamin Peterson | 55e00f2 | 2008-08-17 18:02:44 +0000 | [diff] [blame] | 229 | return "<symbol {0!r}>".format(self.__name) |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 230 | |
| 231 | def get_name(self): |
Joannah Nanjekye | a95ac77 | 2020-07-07 20:09:56 -0300 | [diff] [blame] | 232 | """Return a name of a symbol. |
| 233 | """ |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 234 | return self.__name |
| 235 | |
| 236 | def is_referenced(self): |
Joannah Nanjekye | a95ac77 | 2020-07-07 20:09:56 -0300 | [diff] [blame] | 237 | """Return *True* if the symbol is used in |
| 238 | its block. |
| 239 | """ |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 240 | return bool(self.__flags & _symtable.USE) |
| 241 | |
| 242 | def is_parameter(self): |
Joannah Nanjekye | a95ac77 | 2020-07-07 20:09:56 -0300 | [diff] [blame] | 243 | """Return *True* if the symbol is a parameter. |
| 244 | """ |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 245 | return bool(self.__flags & DEF_PARAM) |
| 246 | |
| 247 | def is_global(self): |
Joannah Nanjekye | a95ac77 | 2020-07-07 20:09:56 -0300 | [diff] [blame] | 248 | """Return *True* if the sysmbol is global. |
| 249 | """ |
Pablo Galindo | fb0a465 | 2020-10-03 20:45:55 +0100 | [diff] [blame] | 250 | return bool(self.__scope in (GLOBAL_IMPLICIT, GLOBAL_EXPLICIT) |
| 251 | or (self.__module_scope and self.__flags & DEF_BOUND)) |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 252 | |
Pablo Galindo | d5b4f1b | 2018-10-20 01:46:00 +0100 | [diff] [blame] | 253 | def is_nonlocal(self): |
Joannah Nanjekye | a95ac77 | 2020-07-07 20:09:56 -0300 | [diff] [blame] | 254 | """Return *True* if the symbol is nonlocal.""" |
Pablo Galindo | d5b4f1b | 2018-10-20 01:46:00 +0100 | [diff] [blame] | 255 | return bool(self.__flags & DEF_NONLOCAL) |
| 256 | |
Jeremy Hylton | f37708e | 2009-03-31 15:26:37 +0000 | [diff] [blame] | 257 | def is_declared_global(self): |
Joannah Nanjekye | a95ac77 | 2020-07-07 20:09:56 -0300 | [diff] [blame] | 258 | """Return *True* if the symbol is declared global |
| 259 | with a global statement.""" |
Jeremy Hylton | f37708e | 2009-03-31 15:26:37 +0000 | [diff] [blame] | 260 | return bool(self.__scope == GLOBAL_EXPLICIT) |
| 261 | |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 262 | def is_local(self): |
Joannah Nanjekye | a95ac77 | 2020-07-07 20:09:56 -0300 | [diff] [blame] | 263 | """Return *True* if the symbol is local. |
| 264 | """ |
Pablo Galindo | fb0a465 | 2020-10-03 20:45:55 +0100 | [diff] [blame] | 265 | return bool(self.__scope in (LOCAL, CELL) |
| 266 | or (self.__module_scope and self.__flags & DEF_BOUND)) |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 267 | |
Yury Selivanov | f8cb8a1 | 2016-09-08 20:50:03 -0700 | [diff] [blame] | 268 | def is_annotated(self): |
Joannah Nanjekye | a95ac77 | 2020-07-07 20:09:56 -0300 | [diff] [blame] | 269 | """Return *True* if the symbol is annotated. |
| 270 | """ |
Yury Selivanov | f8cb8a1 | 2016-09-08 20:50:03 -0700 | [diff] [blame] | 271 | return bool(self.__flags & DEF_ANNOT) |
| 272 | |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 273 | def is_free(self): |
Joannah Nanjekye | a95ac77 | 2020-07-07 20:09:56 -0300 | [diff] [blame] | 274 | """Return *True* if a referenced symbol is |
| 275 | not assigned to. |
| 276 | """ |
Benjamin Peterson | 55e00f2 | 2008-08-17 18:02:44 +0000 | [diff] [blame] | 277 | return bool(self.__scope == FREE) |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 278 | |
| 279 | def is_imported(self): |
Joannah Nanjekye | a95ac77 | 2020-07-07 20:09:56 -0300 | [diff] [blame] | 280 | """Return *True* if the symbol is created from |
| 281 | an import statement. |
| 282 | """ |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 283 | return bool(self.__flags & DEF_IMPORT) |
| 284 | |
| 285 | def is_assigned(self): |
Joannah Nanjekye | a95ac77 | 2020-07-07 20:09:56 -0300 | [diff] [blame] | 286 | """Return *True* if a symbol is assigned to.""" |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 287 | return bool(self.__flags & DEF_LOCAL) |
| 288 | |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 289 | def is_namespace(self): |
Joannah Nanjekye | a95ac77 | 2020-07-07 20:09:56 -0300 | [diff] [blame] | 290 | """Returns *True* if name binding introduces new namespace. |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 291 | |
| 292 | If the name is used as the target of a function or class |
| 293 | statement, this will be true. |
| 294 | |
| 295 | Note that a single name can be bound to multiple objects. If |
| 296 | is_namespace() is true, the name may also be bound to other |
| 297 | objects, like an int or list, that does not introduce a new |
| 298 | namespace. |
| 299 | """ |
| 300 | return bool(self.__namespaces) |
| 301 | |
| 302 | def get_namespaces(self): |
| 303 | """Return a list of namespaces bound to this name""" |
| 304 | return self.__namespaces |
| 305 | |
| 306 | def get_namespace(self): |
Joannah Nanjekye | a95ac77 | 2020-07-07 20:09:56 -0300 | [diff] [blame] | 307 | """Return the single namespace bound to this name. |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 308 | |
| 309 | Raises ValueError if the name is bound to multiple namespaces. |
| 310 | """ |
| 311 | if len(self.__namespaces) != 1: |
Collin Winter | ce36ad8 | 2007-08-30 01:19:48 +0000 | [diff] [blame] | 312 | raise ValueError("name is bound to multiple namespaces") |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 313 | return self.__namespaces[0] |
| 314 | |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 315 | if __name__ == "__main__": |
| 316 | import os, sys |
Giampaolo Rodola' | 2f50aaf | 2013-02-12 02:04:27 +0100 | [diff] [blame] | 317 | with open(sys.argv[0]) as f: |
| 318 | src = f.read() |
Jeremy Hylton | 816e149 | 2001-03-22 23:32:22 +0000 | [diff] [blame] | 319 | mod = symtable(src, os.path.split(sys.argv[0])[1], "exec") |
| 320 | for ident in mod.get_identifiers(): |
| 321 | info = mod.lookup(ident) |
Guido van Rossum | be19ed7 | 2007-02-09 05:37:30 +0000 | [diff] [blame] | 322 | print(info, info.is_local(), info.is_namespace()) |