1.1 --- a/docs/syspython.txt Thu Jul 04 22:41:32 2013 +0200
1.2 +++ b/docs/syspython.txt Thu Jul 04 22:53:22 2013 +0200
1.3 @@ -8,6 +8,21 @@
1.4 temporary storage administration and other code generation tasks are to be
1.5 left to the systems programming language compiler.
1.6
1.7 +Special Functions
1.8 +-----------------
1.9 +
1.10 +In syspython, the function invocation notation is reserved to specify
1.11 +primitive operations such as attribute access and actual function invocations,
1.12 +with the latter being expressed as follows:
1.13 +
1.14 + fn(y) # original Python
1.15 + apply(fn, y) # syspython
1.16 +
1.17 +Thus, in syspython, whenever the invocation notation is used, the target of
1.18 +the invocation is always a special function and not a general Python function
1.19 +or method. Note that the apply function resembles the Python function of the
1.20 +same name but is not actually that particular function.
1.21 +
1.22 Program Data and Data Structure Definition
1.23 ------------------------------------------
1.24
1.25 @@ -18,21 +33,21 @@
1.26 Explicit constant declaration shall be done at the start of the main
1.27 module:
1.28
1.29 - __constants__(...)
1.30 + constants(...)
1.31
1.32 Explicit structure declaration is still performed using class statements,
1.33 but base classes are omitted and attributes are declared explicitly as
1.34 follows:
1.35
1.36 class C:
1.37 - __instattrs__(member...)
1.38 - __classattrs__(member...)
1.39 + instattrs(member...)
1.40 + classattrs(member...)
1.41
1.42 Other object table information, such as inherited class attributes and
1.43 class compatibility (to support isinstance) are also declared explicitly:
1.44
1.45 - __inherited__(superclass, member...)
1.46 - __descendants__(class...)
1.47 + inherited(superclass, member...)
1.48 + descendants(class...)
1.49
1.50 Other than function definitions, no other code statements shall appear in
1.51 class definitions; such statements will appear after classes have been
1.52 @@ -69,10 +84,10 @@
1.53 ...
1.54
1.55 def __main__():
1.56 - __globalnames__(...)
1.57 + globalnames(...)
1.58 ...
1.59 if something:
1.60 - __storeattr__(module.C, method, something)
1.61 + storeattr(module.C, method, something)
1.62
1.63 Imports
1.64 -------
1.65 @@ -82,17 +97,17 @@
1.66
1.67 # import package
1.68 package.__main__()
1.69 - package = __static__(package)
1.70 + storelocal(package, static(package))
1.71
1.72 # import package.module
1.73 package.__main__()
1.74 package.module.__main__()
1.75 - package = __static__(package)
1.76 + storelocal(package, static(package))
1.77
1.78 # from package.module import cls
1.79 package.__main__()
1.80 package.module.__main__()
1.81 - cls = __loadattribute__(package.module, cls) # see below
1.82 + storelocal(cls, loadattribute(package.module, cls)) # see below
1.83
1.84 Since import statements can appear in code that may be executed more than
1.85 once, __main__ functions should test and set a flag indicating whether the
1.86 @@ -108,17 +123,15 @@
1.87 Assignments and name usage involve locals and globals but usage is declared
1.88 explicitly:
1.89
1.90 - __localnames__(...)
1.91 + localnames(...)
1.92
1.93 At the function level, locals are genuine local name definitions whereas
1.94 globals refer to module globals:
1.95
1.96 - __globalnames__(...)
1.97 + globalnames(...)
1.98
1.99 -At the module level, locals are effectively equivalent to module globals but
1.100 -are declared as follows:
1.101 -
1.102 - __moduleattrs__(...)
1.103 +At the module level, locals are effectively equivalent to module globals and
1.104 +are declared as such.
1.105
1.106 Each module's __main__ function will declare any referenced module globals as
1.107 globals. Note that the __main__ function is not a genuine attribute of any
1.108 @@ -128,33 +141,33 @@
1.109 For example:
1.110
1.111 def f(a, b):
1.112 - __localnames__(a, b, x, y)
1.113 - __globalnames__(f, g)
1.114 + localnames(a, b, x, y)
1.115 + globalnames(f, g)
1.116
1.117 - __storelocal__(x, 1)
1.118 - __storelocal__(y, x)
1.119 - __storelocal__(a, b)
1.120 - __storeattr__(module, g, f)
1.121 + storelocal(x, 1)
1.122 + storelocal(y, x)
1.123 + storelocal(a, b)
1.124 + storeattr(module, g, f)
1.125
1.126 Names and Attributes
1.127 --------------------
1.128
1.129 -Bare names refer to locals or globals according to the __localnames__ and
1.130 -__globalnames__ declarations, or to constants such as None, True, False and
1.131 +Bare names refer to locals or globals according to the localnames and
1.132 +globalnames declarations, or to constants such as None, True, False and
1.133 NotImplemented. Storage of local or global names is done using explicit
1.134 functions as follows:
1.135
1.136 - __storelocal__(name, value)
1.137 - __storeattr__(module, name, value) # see below
1.138 + storelocal(name, value)
1.139 + storeattr(module, name, value) # see below
1.140
1.141 No operator usage: all operators are converted to invocations, including
1.142 all attribute access except static references to modules or particular class
1.143 or function definitions using the following notation:
1.144
1.145 - __static__(package)
1.146 - __static__(package.module)
1.147 - __static__(package.module.cls)
1.148 - __static__(package.module.cls.function)
1.149 + static(package)
1.150 + static(package.module)
1.151 + static(package.module.cls)
1.152 + static(package.module.cls.function)
1.153
1.154 A shorthand dot notation could be employed:
1.155
1.156 @@ -165,26 +178,27 @@
1.157 Where multiple definitions of static objects occur, the dot notation cannot be
1.158 used, and the full name of such definitions must be quoted. For example:
1.159
1.160 - __static__("package.module.cls#1.function")
1.161 + static("package.module.cls#1.function")
1.162
1.163 In general, attribute access must use an explicit function indicating the
1.164 kind of access operation being performed. For example:
1.165
1.166 - __loadattr__(obj, attrname) # preserve context
1.167 - __loadattrcontext__(obj, attrname) # replace context with obj
1.168 - __loadattrcontextcond__(obj, attrname) # run-time context decision
1.169 - __loadattrindex__(obj, attrname) # preserve context
1.170 - __loadattrindexcontext__(obj, attrname) # replace context with obj
1.171 - __loadattrindexcontextcond__(obj, attrname) # run-time context decision
1.172 + # context effect
1.173 + # --------------
1.174 + loadattr(obj, attrname) # preserve context
1.175 + loadattrcontext(parent, attrname, obj) # replace context with obj
1.176 + loadattrcontextcond(parent, attrname, obj) # run-time context decision
1.177 + loadattrindex(obj, attrname) # preserve context
1.178 + loadattrindexcontextcond(obj, attrname) # run-time context decision
1.179
1.180 - __storeattr__(obj, attrname, value) # preserve context
1.181 - __storeattrcontext__(obj, attrname, value) # replace context
1.182 - __storeattrindex__(obj, attrname, value)
1.183 + storeattr(obj, attrname, value) # preserve context
1.184 + storeattrcontext(parent, attrname, value, obj) # replace context with obj
1.185 + storeattrindex(obj, attrname, value)
1.186
1.187 Temporary variables could employ similar functions:
1.188
1.189 - __loadtemp__(0)
1.190 - __storetemp__(0, value)
1.191 + loadtemp(0)
1.192 + storetemp(0, value)
1.193
1.194 Operators and Invocations
1.195 -------------------------
1.196 @@ -195,6 +209,7 @@
1.197 but might as well be supported directly:
1.198
1.199 __is__(a, b)
1.200 + __is_not__(a, b)
1.201
1.202 Logical operators involving short-circuit evaluation could be represented
1.203 as function calls, but the evaluation semantics would be preserved:
1.204 @@ -218,20 +233,20 @@
1.205
1.206 Special functions for low-level operations:
1.207
1.208 - __check__(obj, type)
1.209 - __jump__(callable)
1.210 + check(obj, type)
1.211 + jump(callable)
1.212
1.213 Function/subroutine definition with entry points for checked and unchecked
1.214 parameters.
1.215
1.216 def fn_checked(self, ...):
1.217 - __check__(self, Type) # raises a TypeError if not isinstance(self, Type)
1.218 - __jump__(fn_unchecked) # preserves the frame and return address
1.219 + check(self, Type) # raises a TypeError if not isinstance(self, Type)
1.220 + jump(fn_unchecked) # preserves the frame and return address
1.221
1.222 def fn_unchecked(self, ...):
1.223 ...
1.224
1.225 -The __jump__ function might also be used for inlining appropriate functions.
1.226 +The jump function might also be used for inlining appropriate functions.
1.227
1.228 Exceptions must also be handled in the language.
1.229
1.230 @@ -241,4 +256,4 @@
1.231 Occasionally, the type of an object (instance of a particular class, class,
1.232 and so on) needs to be determined at run-time:
1.233
1.234 - __isclass__(obj)
1.235 + isclass(obj)
2.1 --- a/micropython/syspython.py Thu Jul 04 22:41:32 2013 +0200
2.2 +++ b/micropython/syspython.py Thu Jul 04 22:53:22 2013 +0200
2.3 @@ -41,19 +41,19 @@
2.4 return compiler.ast.Const(s)
2.5
2.6 def quoted_ref(obj):
2.7 - return compiler.ast.CallFunc("__static__", [quoted_name(obj.full_name())])
2.8 + return compiler.ast.CallFunc("static", [quoted_name(obj.full_name())])
2.9
2.10 def module_attribute(module_name, attrname):
2.11 - return compiler.ast.Getattr(special_name(module_name), attrname)
2.12 + return special_name(module_name + "." + attrname)
2.13
2.14 # Special function names.
2.15 # Some of the assignment operations cannot be supported unless attribute usage
2.16 # observations are being made.
2.17
2.18 -assattr_functions = ("__storeattrcontext__", "__storeattrcontext__", "__storeattr__",
2.19 - "__storeattrindex__", None)
2.20 -getattr_functions = ("__loadattrcontext__", "__loadattrcontextcond__", "__loadattr__",
2.21 - "__loadattrindex__", "__loadattrindexcontextcond__")
2.22 +assattr_functions = ("storeattrcontext", "storeattrcontext", "storeattr",
2.23 + "storeattrindex", None)
2.24 +getattr_functions = ("loadattrcontext", "loadattrcontextcond", "loadattr",
2.25 + "loadattrindex", "loadattrindexcontextcond")
2.26
2.27 # Source code classes.
2.28
2.29 @@ -91,11 +91,11 @@
2.30
2.31 definitions = self.process_definitions(node)
2.32
2.33 - # __globalnames__(name, ...)
2.34 + # globalnames(name, ...)
2.35
2.36 globalnames = module.module_attribute_names() and [
2.37 compiler.ast.CallFunc(
2.38 - special_name("__globalnames__"),
2.39 + special_name("globalnames"),
2.40 [special_name(attr.name) for attr in module.attributes_as_list()]
2.41 )
2.42 ] or []
2.43 @@ -127,7 +127,7 @@
2.44 def visitAugAssign(self, node):
2.45
2.46 # lvalue = op(lvalue, expr)
2.47 - # -> __fn__(lvalue, op(lvalue, expr))
2.48 + # -> fn(lvalue, op(lvalue, expr))
2.49
2.50 op_name = operator_functions[node.op]
2.51
2.52 @@ -157,24 +157,24 @@
2.53 def _visitClassDefinition(self, node):
2.54 cls = node.unit
2.55
2.56 - # __instattrs__(name, ...)
2.57 - # __clsattrs__(name, ...)
2.58 + # instattrs(name, ...)
2.59 + # clsattrs(name, ...)
2.60
2.61 instattrs = cls.instance_attribute_names() and [
2.62 compiler.ast.CallFunc(
2.63 - special_name("__instattrs__"),
2.64 + special_name("instattrs"),
2.65 [special_name(attr.name) for attr in cls.instance_attributes_as_list()]
2.66 )
2.67 ] or []
2.68
2.69 clsattrs = cls.class_attribute_names() and [
2.70 compiler.ast.CallFunc(
2.71 - special_name("__clsattrs__"),
2.72 + special_name("clsattrs"),
2.73 [special_name(attr.name) for attr in cls.attributes_as_list()]
2.74 )
2.75 ] or []
2.76
2.77 - # __inherited__(superclass, name, ...)
2.78 + # inherited(superclass, name, ...)
2.79 # ...
2.80
2.81 attrs_by_cls = {}
2.82 @@ -191,15 +191,15 @@
2.83 for supercls, attrnames in attrs_by_cls.items():
2.84 inherited.append(
2.85 compiler.ast.CallFunc(
2.86 - special_name("__inherited__"),
2.87 + special_name("inherited"),
2.88 [quoted_ref(supercls)] + [special_name(name) for name in attrnames]
2.89 ))
2.90
2.91 - # __descendants__(name, ...)
2.92 + # descendants(name, ...)
2.93
2.94 descendants = cls.all_descendants() and [
2.95 compiler.ast.CallFunc(
2.96 - special_name("__descendants__"),
2.97 + special_name("descendants"),
2.98 [special_name(name) for name in cls.all_descendants().keys()]
2.99 )
2.100 ] or []
2.101 @@ -247,8 +247,8 @@
2.102 else_nodes = node.else_ and self.dispatch(node.else_).nodes or []
2.103
2.104 return compiler.ast.Stmt([
2.105 - # __storetemp__(_it, __builtins__.iter(<list>))
2.106 - compiler.ast.CallFunc(special_name("__storetemp__"), [
2.107 + # storetemp(_it, __builtins__.iter(<list>))
2.108 + compiler.ast.CallFunc(special_name("storetemp"), [
2.109 temp,
2.110 compiler.ast.CallFunc(
2.111 module_attribute("__builtins__", "iter"),
2.112 @@ -265,8 +265,8 @@
2.113 self.dispatch(node.assign,
2.114 # _it.next()
2.115 compiler.ast.CallFunc(
2.116 - compiler.ast.CallFunc(special_name("__loadattrindex__"), [
2.117 - compiler.ast.CallFunc(special_name("__loadtemp__"), [temp]),
2.118 + compiler.ast.CallFunc(special_name("loadattrindex"), [
2.119 + compiler.ast.CallFunc(special_name("loadtemp"), [temp]),
2.120 special_name("next")
2.121 ]),
2.122 []
2.123 @@ -296,13 +296,14 @@
2.124
2.125 for name, alias in node.names:
2.126 statements.append(
2.127 - compiler.ast.Assign(
2.128 - [special_name(alias or name)],
2.129 + compiler.ast.CallFunc(
2.130 + special_name("storelocal"),
2.131 + [special_name(alias or name),
2.132 compiler.ast.CallFunc(
2.133 - special_name("__loadattr__"),
2.134 + special_name("loadattr"),
2.135 [special_name(node.modname), special_name(name)]
2.136 )
2.137 - )
2.138 + ])
2.139 )
2.140
2.141 return compiler.ast.Stmt(statements)
2.142 @@ -323,7 +324,7 @@
2.143 return compiler.ast.Stmt([])
2.144 else:
2.145 return compiler.ast.CallFunc(
2.146 - special_name("__storeattr__"),
2.147 + special_name("storeattr"),
2.148 [quoted_ref(fn.parent), special_name(fn.original_name),
2.149 quoted_ref(fn)]
2.150 )
2.151 @@ -335,19 +336,19 @@
2.152 def _visitFunctionDefinition(self, node):
2.153 fn = node.unit
2.154
2.155 - # __localnames__(name, ...)
2.156 - # __globalnames__(name, ...)
2.157 + # localnames(name, ...)
2.158 + # globalnames(name, ...)
2.159
2.160 localnames = fn.all_locals() and [
2.161 compiler.ast.CallFunc(
2.162 - special_name("__localnames__"),
2.163 + special_name("localnames"),
2.164 [special_name(name) for name in fn.all_locals().keys()]
2.165 )
2.166 ] or []
2.167
2.168 globalnames = fn.globals and [
2.169 compiler.ast.CallFunc(
2.170 - special_name("__globalnames__"),
2.171 + special_name("globalnames"),
2.172 [special_name(name) for name in fn.globals]
2.173 )
2.174 ] or []
2.175 @@ -383,13 +384,14 @@
2.176 )
2.177
2.178 statements.append(
2.179 - compiler.ast.Assign(
2.180 - [special_name(alias or name.split(".")[0])],
2.181 + compiler.ast.CallFunc(
2.182 + special_name("storelocal"),
2.183 + [special_name(alias or name.split(".")[0]),
2.184 compiler.ast.CallFunc(
2.185 - special_name("__static__"),
2.186 + special_name("static"),
2.187 [special_name(name)]
2.188 )
2.189 - )
2.190 + ])
2.191 )
2.192
2.193 return compiler.ast.Stmt(statements)
2.194 @@ -535,6 +537,11 @@
2.195 if expr:
2.196 args.append(expr)
2.197
2.198 + # Append any context to be set.
2.199 +
2.200 + if node._set_context and args[0] is not accessor:
2.201 + args.append(accessor)
2.202 +
2.203 return compiler.ast.CallFunc(special_name(op), args)
2.204
2.205 # Positioned accesses are normal accesses via instances.
2.206 @@ -556,19 +563,19 @@
2.207
2.208 if node.attrname == "__class__":
2.209
2.210 - # __storetemp__(n, <accessor>)
2.211 - # __isclass__(n) and __builtins__.type or <access>
2.212 + # storetemp(n, <accessor>)
2.213 + # isclass(n) and __builtins__.type or <access>
2.214
2.215 temp = quoted_name(unit.temp_usage)
2.216 unit.temp_usage += 1
2.217
2.218 return compiler.ast.Stmt([
2.219 - compiler.ast.CallFunc(special_name("__storetemp__"), [temp, access]),
2.220 + compiler.ast.CallFunc(special_name("storetemp"), [temp, access]),
2.221 compiler.ast.Or([
2.222 compiler.ast.And([
2.223 compiler.ast.CallFunc(
2.224 - special_name("__isclass__"),
2.225 - [compiler.ast.CallFunc(special_name("__loadtemp__"), [temp])]
2.226 + special_name("isclass"),
2.227 + [compiler.ast.CallFunc(special_name("loadtemp"), [temp])]
2.228 ),
2.229 module_attribute("__builtins__", "type")
2.230 ]),
2.231 @@ -637,7 +644,7 @@
2.232
2.233 if isinstance(unit, Function):
2.234 return compiler.ast.CallFunc(
2.235 - special_name("__storelocal__"),
2.236 + special_name("storelocal"),
2.237 [special_name(node.name), expr]
2.238 )
2.239
2.240 @@ -645,7 +652,7 @@
2.241
2.242 elif isinstance(unit, Class):
2.243 return compiler.ast.CallFunc(
2.244 - special_name("__storeattrcontext__"),
2.245 + special_name("storeattrcontext"),
2.246 [quoted_ref(unit), special_name(node.name), expr]
2.247 )
2.248
2.249 @@ -653,7 +660,7 @@
2.250
2.251 elif isinstance(unit, Module):
2.252 return compiler.ast.CallFunc(
2.253 - special_name("__storeattr__"),
2.254 + special_name("storeattr"),
2.255 [quoted_ref(unit), special_name(node.name), expr]
2.256 )
2.257 else:
2.258 @@ -664,7 +671,7 @@
2.259 # Globals are references to module attributes.
2.260
2.261 return compiler.ast.CallFunc(
2.262 - special_name("__storeattr__"),
2.263 + special_name("storeattr"),
2.264 [quoted_ref(self.get_module()), special_name(node.name), expr]
2.265 )
2.266
2.267 @@ -673,14 +680,14 @@
2.268 # Builtins are accessed via the __builtins__ module.
2.269
2.270 return compiler.ast.CallFunc(
2.271 - special_name("__storeattr__"),
2.272 + special_name("storeattr"),
2.273 [special_name("__builtins__"), special_name(node.name), expr]
2.274 )
2.275
2.276 else:
2.277 # NOTE: This may happen because a class attribute is optimised away.
2.278 return compiler.ast.CallFunc(
2.279 - special_name("__storeunknown__"),
2.280 + special_name("storeunknown"),
2.281 [special_name(node.name), expr]
2.282 )
2.283
2.284 @@ -697,8 +704,8 @@
2.285
2.286 def visitCallFunc(self, node):
2.287 return compiler.ast.CallFunc(
2.288 - self.dispatch(node.node),
2.289 - [self.dispatch(arg) for arg in node.args],
2.290 + special_name("apply"),
2.291 + [self.dispatch(node.node)] + [self.dispatch(arg) for arg in node.args],
2.292 node.star_args and self.dispatch(node.star_args),
2.293 node.dstar_args and self.dispatch(node.dstar_args)
2.294 )
2.295 @@ -707,12 +714,27 @@
2.296 nodes = []
2.297 left = node.expr
2.298 for op_name, right in node.ops:
2.299 - nodes.append(
2.300 - compiler.ast.CallFunc(
2.301 - module_attribute("operator", operator_functions.get(op_name)),
2.302 - [self.dispatch(left), self.dispatch(right)]
2.303 + if op_name == "is":
2.304 + nodes.append(
2.305 + compiler.ast.CallFunc(
2.306 + special_name("__is__"),
2.307 + [self.dispatch(left), self.dispatch(right)]
2.308 + )
2.309 )
2.310 - )
2.311 + elif op_name == "is not":
2.312 + nodes.append(
2.313 + compiler.ast.CallFunc(
2.314 + special_name("__is_not__"),
2.315 + [self.dispatch(left), self.dispatch(right)]
2.316 + )
2.317 + )
2.318 + else:
2.319 + nodes.append(
2.320 + compiler.ast.CallFunc(
2.321 + module_attribute("operator", operator_functions.get(op_name)),
2.322 + [self.dispatch(left), self.dispatch(right)]
2.323 + )
2.324 + )
2.325 left = right
2.326 return compiler.ast.And(nodes)
2.327
2.328 @@ -805,8 +827,8 @@
2.329 unit.temp_usage += 1
2.330
2.331 return compiler.ast.Stmt([
2.332 - # __storetemp__(_out, __builtins__.list())
2.333 - compiler.ast.CallFunc(special_name("__storetemp__"), [
2.334 + # storetemp(_out, __builtins__.list())
2.335 + compiler.ast.CallFunc(special_name("storetemp"), [
2.336 temp,
2.337 compiler.ast.CallFunc(
2.338 module_attribute("__builtins__", "list"),
2.339 @@ -855,8 +877,8 @@
2.340 # Wrap the above body in the loop construct.
2.341
2.342 return compiler.ast.Stmt([
2.343 - # __storetemp__(_it, __builtins__.iter(<list>))
2.344 - compiler.ast.CallFunc(special_name("__storetemp__"), [
2.345 + # storetemp(_it, __builtins__.iter(<list>))
2.346 + compiler.ast.CallFunc(special_name("storetemp"), [
2.347 temp,
2.348 compiler.ast.CallFunc(
2.349 module_attribute("__builtins__", "iter"),
2.350 @@ -873,8 +895,8 @@
2.351 self.dispatch(node.assign,
2.352 # _it.next()
2.353 compiler.ast.CallFunc(
2.354 - compiler.ast.CallFunc(special_name("__loadattrindex__"), [
2.355 - compiler.ast.CallFunc(special_name("__loadtemp__"), [temp]),
2.356 + compiler.ast.CallFunc(special_name("loadattrindex"), [
2.357 + compiler.ast.CallFunc(special_name("loadtemp"), [temp]),
2.358 special_name("next")
2.359 ]),
2.360 []
2.361 @@ -914,8 +936,8 @@
2.362 return compiler.ast.Stmt([
2.363 # _out.append(<expr>)
2.364 compiler.ast.CallFunc(
2.365 - compiler.ast.CallFunc(special_name("__loadattrindex__"), [
2.366 - compiler.ast.CallFunc(special_name("__loadtemp__"), [out_temp]),
2.367 + compiler.ast.CallFunc(special_name("loadattrindex"), [
2.368 + compiler.ast.CallFunc(special_name("loadtemp"), [out_temp]),
2.369 special_name("append")
2.370 ]),
2.371 [self.dispatch(expr)]
2.372 @@ -953,7 +975,7 @@
2.373 return constant_attribute(quoted_ref(attr.parent), node.name)
2.374 else:
2.375 return compiler.ast.CallFunc(
2.376 - special_name("__loadattr__"),
2.377 + special_name("loadattr"),
2.378 [quoted_ref(attr.parent), special_name(node.name)]
2.379 )
2.380
2.381 @@ -961,7 +983,7 @@
2.382
2.383 elif scope == "global":
2.384 return compiler.ast.CallFunc(
2.385 - special_name("__loadattr__"),
2.386 + special_name("loadattr"),
2.387 [quoted_ref(self.get_module()), special_name(node.name)]
2.388 )
2.389
2.390 @@ -970,7 +992,7 @@
2.391
2.392 else:
2.393 return compiler.ast.CallFunc(
2.394 - special_name("__loadunknown__"),
2.395 + special_name("loadunknown"),
2.396 [special_name(node.name)]
2.397 )
2.398