1.1 --- a/Cython/Compiler/ExprNodes.py Tue Sep 23 11:53:34 2008 -0700 1.2 +++ b/Cython/Compiler/ExprNodes.py Tue Sep 23 13:48:06 2008 -0700 1.3 @@ -103,11 +103,6 @@ 1.4 # - Call release_temp on sub-nodes and release any other 1.5 # temps used during assignment. 1.6 # 1.7 - # calculate_result_code 1.8 - # - Called during the Allocate Temps phase. Should return a 1.9 - # C code fragment evaluating to the result. This is only 1.10 - # called when the result is not a temporary. 1.11 - # 1.12 # target_code 1.13 # Called by the default implementation of allocate_target_temps. 1.14 # Should return a C lvalue for assigning to the node. The default 1.15 @@ -140,13 +135,18 @@ 1.16 # on all sub-expressions. 1.17 # 1.18 # A default implementation of generate_evaluation_code 1.19 - # is provided which uses the following abstract method: 1.20 + # is provided which uses the following abstract methods: 1.21 # 1.22 # generate_result_code 1.23 # - Generate any C statements necessary to calculate 1.24 # the result of this node from the results of its 1.25 # sub-expressions. 1.26 # 1.27 + # calculate_result_code 1.28 + # - Should return a C code fragment evaluating to the 1.29 + # result. This is only called when the result is not 1.30 + # a temporary. 1.31 + # 1.32 # generate_assignment_code 1.33 # Called on the LHS of an assignment. 1.34 # - Call generate_evaluation_code for sub-expressions. 1.35 @@ -204,10 +204,16 @@ 1.36 nodes.extend(item) 1.37 self.saved_subexpr_nodes = nodes 1.38 return self.saved_subexpr_nodes 1.39 + 1.40 + def result(self): 1.41 + if self.is_temp: 1.42 + return self.result_code 1.43 + else: 1.44 + return self.calculate_result_code() 1.45 1.46 def result_as(self, type = None): 1.47 # Return the result code cast to the specified C type. 1.48 - return typecast(type, self.ctype(), self.result_code) 1.49 + return typecast(type, self.ctype(), self.result()) 1.50 1.51 def py_result(self): 1.52 # Return the result code cast to PyObject *. 1.53 @@ -381,8 +387,6 @@ 1.54 self.result_code = None 1.55 if debug_temp_alloc: 1.56 print("%s Allocated result %s" % (self, self.result_code)) 1.57 - else: 1.58 - self.result_code = self.calculate_result_code() 1.59 1.60 def target_code(self): 1.61 # Return code fragment for use as LHS of a C assignment. 1.62 @@ -418,7 +422,7 @@ 1.63 # If result is a pyobject, make sure we own 1.64 # a reference to it. 1.65 if self.type.is_pyobject and not self.result_in_temp(): 1.66 - code.put_incref(self.result_code, self.ctype()) 1.67 + code.put_incref(self.result(), self.ctype()) 1.68 1.69 def generate_evaluation_code(self, code): 1.70 code.mark_pos(self.pos) 1.71 @@ -442,7 +446,7 @@ 1.72 # temporary Python reference. 1.73 if self.is_temp: 1.74 if self.type.is_pyobject: 1.75 - code.put_decref_clear(self.result_code, self.ctype()) 1.76 + code.put_decref_clear(self.result(), self.ctype()) 1.77 else: 1.78 self.generate_subexpr_disposal_code(code) 1.79 1.80 @@ -458,7 +462,7 @@ 1.81 # the result if it is a Python object. 1.82 if self.is_temp: 1.83 if self.type.is_pyobject: 1.84 - code.putln("%s = 0;" % self.result_code) 1.85 + code.putln("%s = 0;" % self.result()) 1.86 else: 1.87 self.generate_subexpr_disposal_code(code) 1.88 1.89 @@ -795,9 +799,9 @@ 1.90 def generate_evaluation_code(self, code): 1.91 code.putln( 1.92 '%s = PyLong_FromString("%s", 0, 0); %s' % ( 1.93 - self.result_code, 1.94 + self.result(), 1.95 self.value, 1.96 - code.error_goto_if_null(self.result_code, self.pos))) 1.97 + code.error_goto_if_null(self.result(), self.pos))) 1.98 1.99 1.100 class ImagNode(AtomicExprNode): 1.101 @@ -818,9 +822,9 @@ 1.102 def generate_evaluation_code(self, code): 1.103 code.putln( 1.104 "%s = PyComplex_FromDoubles(0.0, %s); %s" % ( 1.105 - self.result_code, 1.106 + self.result(), 1.107 self.value, 1.108 - code.error_goto_if_null(self.result_code, self.pos))) 1.109 + code.error_goto_if_null(self.result(), self.pos))) 1.110 1.111 1.112 class NameNode(AtomicExprNode): 1.113 @@ -1017,10 +1021,10 @@ 1.114 namespace = entry.scope.namespace_cname 1.115 code.putln( 1.116 '%s = __Pyx_GetName(%s, %s); %s' % ( 1.117 - self.result_code, 1.118 + self.result(), 1.119 namespace, 1.120 self.interned_cname, 1.121 - code.error_goto_if_null(self.result_code, self.pos))) 1.122 + code.error_goto_if_null(self.result(), self.pos))) 1.123 elif entry.is_local and False: 1.124 # control flow not good enough yet 1.125 assigned = entry.scope.control_flow.get_state((entry.name, 'initalized'), self.pos) 1.126 @@ -1083,12 +1087,12 @@ 1.127 if entry.is_local and not Options.init_local_none: 1.128 initalized = entry.scope.control_flow.get_state((entry.name, 'initalized'), self.pos) 1.129 if initalized is True: 1.130 - code.put_decref(self.result_code, self.ctype()) 1.131 + code.put_decref(self.result(), self.ctype()) 1.132 elif initalized is None: 1.133 - code.put_xdecref(self.result_code, self.ctype()) 1.134 - else: 1.135 - code.put_decref(self.result_code, self.ctype()) 1.136 - code.putln('%s = %s;' % (self.result_code, rhs.result_as(self.ctype()))) 1.137 + code.put_xdecref(self.result(), self.ctype()) 1.138 + else: 1.139 + code.put_decref(self.result(), self.ctype()) 1.140 + code.putln('%s = %s;' % (self.result(), rhs.result_as(self.ctype()))) 1.141 if debug_disposal_code: 1.142 print("NameNode.generate_assignment_code:") 1.143 print("...generating post-assignment code for %s" % rhs) 1.144 @@ -1101,7 +1105,7 @@ 1.145 code.putln('%s = %s;' % (rhstmp, rhs.result_as(self.ctype()))) 1.146 1.147 import Buffer 1.148 - Buffer.put_assign_to_buffer(self.result_code, rhstmp, buffer_aux, self.entry.type, 1.149 + Buffer.put_assign_to_buffer(self.result(), rhstmp, buffer_aux, self.entry.type, 1.150 is_initialized=not self.skip_assignment_decref, 1.151 pos=self.pos, code=code) 1.152 code.putln("%s = 0;" % rhstmp) 1.153 @@ -1145,9 +1149,9 @@ 1.154 def generate_result_code(self, code): 1.155 code.putln( 1.156 "%s = PyObject_Repr(%s); %s" % ( 1.157 - self.result_code, 1.158 + self.result(), 1.159 self.arg.py_result(), 1.160 - code.error_goto_if_null(self.result_code, self.pos))) 1.161 + code.error_goto_if_null(self.result(), self.pos))) 1.162 1.163 1.164 class ImportNode(ExprNode): 1.165 @@ -1179,10 +1183,10 @@ 1.166 name_list_code = "0" 1.167 code.putln( 1.168 "%s = __Pyx_Import(%s, %s); %s" % ( 1.169 - self.result_code, 1.170 + self.result(), 1.171 self.module_name.py_result(), 1.172 name_list_code, 1.173 - code.error_goto_if_null(self.result_code, self.pos))) 1.174 + code.error_goto_if_null(self.result(), self.pos))) 1.175 1.176 1.177 class IteratorNode(ExprNode): 1.178 @@ -1206,7 +1210,7 @@ 1.179 gil_message = "Iterating over Python object" 1.180 1.181 def release_temp(self, env): 1.182 - env.release_temp(self.result_code) 1.183 + env.release_temp(self.result()) 1.184 self.counter.release_temp(env) 1.185 1.186 def generate_result_code(self, code): 1.187 @@ -1216,16 +1220,16 @@ 1.188 self.sequence.py_result())) 1.189 code.putln( 1.190 "%s = 0; %s = %s; Py_INCREF(%s);" % ( 1.191 - self.counter.result_code, 1.192 - self.result_code, 1.193 + self.counter.result(), 1.194 + self.result(), 1.195 self.sequence.py_result(), 1.196 - self.result_code)) 1.197 + self.result())) 1.198 code.putln("} else {") 1.199 code.putln("%s = -1; %s = PyObject_GetIter(%s); %s" % ( 1.200 - self.counter.result_code, 1.201 - self.result_code, 1.202 + self.counter.result(), 1.203 + self.result(), 1.204 self.sequence.py_result(), 1.205 - code.error_goto_if_null(self.result_code, self.pos))) 1.206 + code.error_goto_if_null(self.result(), self.pos))) 1.207 code.putln("}") 1.208 1.209 1.210 @@ -1249,26 +1253,26 @@ 1.211 "if (likely(Py%s_CheckExact(%s))) {" % (py_type, self.iterator.py_result())) 1.212 code.putln( 1.213 "if (%s >= Py%s_GET_SIZE(%s)) break;" % ( 1.214 - self.iterator.counter.result_code, 1.215 + self.iterator.counter.result(), 1.216 py_type, 1.217 self.iterator.py_result())) 1.218 code.putln( 1.219 "%s = Py%s_GET_ITEM(%s, %s); Py_INCREF(%s); %s++;" % ( 1.220 - self.result_code, 1.221 + self.result(), 1.222 py_type, 1.223 self.iterator.py_result(), 1.224 - self.iterator.counter.result_code, 1.225 - self.result_code, 1.226 - self.iterator.counter.result_code)) 1.227 + self.iterator.counter.result(), 1.228 + self.result(), 1.229 + self.iterator.counter.result())) 1.230 code.put("} else ") 1.231 code.putln("{") 1.232 code.putln( 1.233 "%s = PyIter_Next(%s);" % ( 1.234 - self.result_code, 1.235 + self.result(), 1.236 self.iterator.py_result())) 1.237 code.putln( 1.238 "if (!%s) {" % 1.239 - self.result_code) 1.240 + self.result()) 1.241 code.putln(code.error_goto_if_PyErr(self.pos)) 1.242 code.putln("break;") 1.243 code.putln("}") 1.244 @@ -1465,7 +1469,7 @@ 1.245 return "<not used>" 1.246 else: 1.247 return "(%s[%s])" % ( 1.248 - self.base.result_code, self.index.result_code) 1.249 + self.base.result(), self.index.result()) 1.250 1.251 def index_unsigned_parameter(self): 1.252 if self.index.type.is_int: 1.253 @@ -1496,33 +1500,33 @@ 1.254 if self.is_buffer_access: 1.255 ptrcode = self.buffer_lookup_code(code) 1.256 code.putln("%s = *%s;" % ( 1.257 - self.result_code, 1.258 + self.result(), 1.259 self.buffer_type.buffer_ptr_type.cast_code(ptrcode))) 1.260 # Must incref the value we pulled out. 1.261 if self.buffer_type.dtype.is_pyobject: 1.262 - code.putln("Py_INCREF((PyObject*)%s);" % self.result_code) 1.263 + code.putln("Py_INCREF((PyObject*)%s);" % self.result()) 1.264 elif self.type.is_pyobject: 1.265 if self.index.type.is_int: 1.266 function = "__Pyx_GetItemInt" 1.267 - index_code = self.index.result_code 1.268 + index_code = self.index.result() 1.269 else: 1.270 function = "PyObject_GetItem" 1.271 index_code = self.index.py_result() 1.272 sign_code = "" 1.273 code.putln( 1.274 "%s = %s(%s, %s%s); if (!%s) %s" % ( 1.275 - self.result_code, 1.276 + self.result(), 1.277 function, 1.278 self.base.py_result(), 1.279 index_code, 1.280 self.index_unsigned_parameter(), 1.281 - self.result_code, 1.282 + self.result(), 1.283 code.error_goto(self.pos))) 1.284 1.285 def generate_setitem_code(self, value_code, code): 1.286 if self.index.type.is_int: 1.287 function = "__Pyx_SetItemInt" 1.288 - index_code = self.index.result_code 1.289 + index_code = self.index.result() 1.290 else: 1.291 function = "PyObject_SetItem" 1.292 index_code = self.index.py_result() 1.293 @@ -1545,7 +1549,7 @@ 1.294 if rhs.is_temp: 1.295 rhs_code = code.funcstate.allocate_temp(rhs.type) 1.296 else: 1.297 - rhs_code = rhs.result_code 1.298 + rhs_code = rhs.result() 1.299 code.putln("%s = %s;" % (ptr, ptrexpr)) 1.300 code.putln("Py_DECREF(*%s); Py_INCREF(%s);" % ( 1.301 ptr, rhs_code 1.302 @@ -1556,7 +1560,7 @@ 1.303 code.funcstate.release_temp(ptr) 1.304 else: 1.305 # Simple case 1.306 - code.putln("*%s %s= %s;" % (ptrexpr, op, rhs.result_code)) 1.307 + code.putln("*%s %s= %s;" % (ptrexpr, op, rhs.result())) 1.308 1.309 def generate_assignment_code(self, rhs, code): 1.310 self.generate_subexpr_evaluation_code(code) 1.311 @@ -1567,7 +1571,7 @@ 1.312 else: 1.313 code.putln( 1.314 "%s = %s;" % ( 1.315 - self.result_code, rhs.result_code)) 1.316 + self.result(), rhs.result())) 1.317 self.generate_subexpr_disposal_code(code) 1.318 rhs.generate_disposal_code(code) 1.319 1.320 @@ -1576,7 +1580,7 @@ 1.321 #if self.type.is_pyobject: 1.322 if self.index.type.is_int: 1.323 function = "PySequence_DelItem" 1.324 - index_code = self.index.result_code 1.325 + index_code = self.index.result() 1.326 else: 1.327 function = "PyObject_DelItem" 1.328 index_code = self.index.py_result() 1.329 @@ -1592,7 +1596,7 @@ 1.330 # Assign indices to temps 1.331 index_temps = [code.funcstate.allocate_temp(i.type) for i in self.indices] 1.332 for temp, index in zip(index_temps, self.indices): 1.333 - code.putln("%s = %s;" % (temp, index.result_code)) 1.334 + code.putln("%s = %s;" % (temp, index.result())) 1.335 # Generate buffer access code using these temps 1.336 import Buffer 1.337 # The above could happen because child_attrs is wrong somewhere so that 1.338 @@ -1645,11 +1649,11 @@ 1.339 def generate_result_code(self, code): 1.340 code.putln( 1.341 "%s = PySequence_GetSlice(%s, %s, %s); %s" % ( 1.342 - self.result_code, 1.343 + self.result(), 1.344 self.base.py_result(), 1.345 self.start_code(), 1.346 self.stop_code(), 1.347 - code.error_goto_if_null(self.result_code, self.pos))) 1.348 + code.error_goto_if_null(self.result(), self.pos))) 1.349 1.350 def generate_assignment_code(self, rhs, code): 1.351 self.generate_subexpr_evaluation_code(code) 1.352 @@ -1658,7 +1662,7 @@ 1.353 self.base.py_result(), 1.354 self.start_code(), 1.355 self.stop_code(), 1.356 - rhs.result_code)) 1.357 + rhs.result())) 1.358 self.generate_subexpr_disposal_code(code) 1.359 rhs.generate_disposal_code(code) 1.360 1.361 @@ -1673,18 +1677,18 @@ 1.362 1.363 def start_code(self): 1.364 if self.start: 1.365 - return self.start.result_code 1.366 + return self.start.result() 1.367 else: 1.368 return "0" 1.369 1.370 def stop_code(self): 1.371 if self.stop: 1.372 - return self.stop.result_code 1.373 + return self.stop.result() 1.374 else: 1.375 return "PY_SSIZE_T_MAX" 1.376 1.377 def calculate_result_code(self): 1.378 - # self.result_code is not used, but this method must exist 1.379 + # self.result() is not used, but this method must exist 1.380 return "<unused>" 1.381 1.382 1.383 @@ -1722,11 +1726,11 @@ 1.384 def generate_result_code(self, code): 1.385 code.putln( 1.386 "%s = PySlice_New(%s, %s, %s); %s" % ( 1.387 - self.result_code, 1.388 + self.result(), 1.389 self.start.py_result(), 1.390 self.stop.py_result(), 1.391 self.step.py_result(), 1.392 - code.error_goto_if_null(self.result_code, self.pos))) 1.393 + code.error_goto_if_null(self.result(), self.pos))) 1.394 1.395 1.396 class CallNode(ExprNode): 1.397 @@ -1897,8 +1901,8 @@ 1.398 arg_list_code.append(optional_args) 1.399 1.400 for actual_arg in self.args[len(formal_args):]: 1.401 - arg_list_code.append(actual_arg.result_code) 1.402 - result = "%s(%s)" % (self.function.result_code, 1.403 + arg_list_code.append(actual_arg.result()) 1.404 + result = "%s(%s)" % (self.function.result(), 1.405 join(arg_list_code, ", ")) 1.406 # if self.wrapper_call or \ 1.407 # self.function.entry.is_unbound_cmethod and self.function.entry.type.is_overridable: 1.408 @@ -1911,10 +1915,10 @@ 1.409 arg_code = self.arg_tuple.py_result() 1.410 code.putln( 1.411 "%s = PyObject_Call(%s, %s, NULL); %s" % ( 1.412 - self.result_code, 1.413 + self.result(), 1.414 self.function.py_result(), 1.415 arg_code, 1.416 - code.error_goto_if_null(self.result_code, self.pos))) 1.417 + code.error_goto_if_null(self.result(), self.pos))) 1.418 elif func_type.is_cfunction: 1.419 if self.has_optional_args: 1.420 actual_nargs = len(self.args) 1.421 @@ -1931,18 +1935,18 @@ 1.422 actual_arg.result_as(formal_arg.type))) 1.423 exc_checks = [] 1.424 if self.type.is_pyobject: 1.425 - exc_checks.append("!%s" % self.result_code) 1.426 + exc_checks.append("!%s" % self.result()) 1.427 else: 1.428 exc_val = func_type.exception_value 1.429 exc_check = func_type.exception_check 1.430 if exc_val is not None: 1.431 - exc_checks.append("%s == %s" % (self.result_code, exc_val)) 1.432 + exc_checks.append("%s == %s" % (self.result(), exc_val)) 1.433 if exc_check: 1.434 exc_checks.append("PyErr_Occurred()") 1.435 if self.is_temp or exc_checks: 1.436 rhs = self.c_call_code() 1.437 - if self.result_code: 1.438 - lhs = "%s = " % self.result_code 1.439 + if self.result(): 1.440 + lhs = "%s = " % self.result() 1.441 if self.is_temp and self.type.is_pyobject: 1.442 #return_type = self.type # func_type.return_type 1.443 #print "SimpleCallNode.generate_result_code: casting", rhs, \ 1.444 @@ -2033,9 +2037,9 @@ 1.445 keyword_code) 1.446 code.putln( 1.447 "%s = %s; %s" % ( 1.448 - self.result_code, 1.449 + self.result(), 1.450 call_code, 1.451 - code.error_goto_if_null(self.result_code, self.pos))) 1.452 + code.error_goto_if_null(self.result(), self.pos))) 1.453 1.454 1.455 class AsTupleNode(ExprNode): 1.456 @@ -2065,9 +2069,9 @@ 1.457 def generate_result_code(self, code): 1.458 code.putln( 1.459 "%s = PySequence_Tuple(%s); %s" % ( 1.460 - self.result_code, 1.461 + self.result(), 1.462 self.arg.py_result(), 1.463 - code.error_goto_if_null(self.result_code, self.pos))) 1.464 + code.error_goto_if_null(self.result(), self.pos))) 1.465 1.466 1.467 class AttributeNode(ExprNode): 1.468 @@ -2090,7 +2094,6 @@ 1.469 subexprs = ['obj'] 1.470 1.471 type = PyrexTypes.error_type 1.472 - result = "<error>" 1.473 entry = None 1.474 is_called = 0 1.475 needs_none_check = True 1.476 @@ -2299,7 +2302,7 @@ 1.477 1.478 def calculate_result_code(self): 1.479 #print "AttributeNode.calculate_result_code:", self.member ### 1.480 - #print "...obj node =", self.obj, "code", self.obj.result_code ### 1.481 + #print "...obj node =", self.obj, "code", self.obj.result() ### 1.482 #print "...obj type", self.obj.type, "ctype", self.obj.ctype() ### 1.483 obj = self.obj 1.484 obj_code = obj.result_as(obj.type) 1.485 @@ -2318,10 +2321,10 @@ 1.486 if self.is_py_attr: 1.487 code.putln( 1.488 '%s = PyObject_GetAttr(%s, %s); %s' % ( 1.489 - self.result_code, 1.490 + self.result(), 1.491 self.obj.py_result(), 1.492 self.interned_attr_cname, 1.493 - code.error_goto_if_null(self.result_code, self.pos))) 1.494 + code.error_goto_if_null(self.result(), self.pos))) 1.495 else: 1.496 # result_code contains what is needed, but we may need to insert 1.497 # a check and raise an exception 1.498 @@ -2345,7 +2348,7 @@ 1.499 and code.globalstate.directives['nonecheck']): 1.500 self.put_nonecheck(code) 1.501 1.502 - select_code = self.result_code 1.503 + select_code = self.result() 1.504 if self.type.is_pyobject: 1.505 rhs.make_owned_reference(code) 1.506 code.put_decref(select_code, self.ctype()) 1.507 @@ -2353,7 +2356,7 @@ 1.508 "%s = %s;" % ( 1.509 select_code, 1.510 rhs.result_as(self.ctype()))) 1.511 - #rhs.result_code)) 1.512 + #rhs.result())) 1.513 rhs.generate_post_assignment_code(code) 1.514 self.obj.generate_disposal_code(code) 1.515 1.516 @@ -2463,9 +2466,9 @@ 1.517 item = self.unpacked_items[i] 1.518 code.putln( 1.519 "%s = PyTuple_GET_ITEM(tuple, %s);" % ( 1.520 - item.result_code, 1.521 + item.result(), 1.522 i)) 1.523 - code.put_incref(item.result_code, item.ctype()) 1.524 + code.put_incref(item.result(), item.ctype()) 1.525 value_node = self.coerced_unpacked_items[i] 1.526 value_node.generate_evaluation_code(code) 1.527 self.args[i].generate_assignment_code(value_node, code) 1.528 @@ -2476,9 +2479,9 @@ 1.529 1.530 code.putln( 1.531 "%s = PyObject_GetIter(%s); %s" % ( 1.532 - self.iterator.result_code, 1.533 + self.iterator.result(), 1.534 rhs.py_result(), 1.535 - code.error_goto_if_null(self.iterator.result_code, self.pos))) 1.536 + code.error_goto_if_null(self.iterator.result(), self.pos))) 1.537 rhs.generate_disposal_code(code) 1.538 for i in range(len(self.args)): 1.539 item = self.unpacked_items[i] 1.540 @@ -2486,9 +2489,9 @@ 1.541 self.iterator.py_result(), i) 1.542 code.putln( 1.543 "%s = %s; %s" % ( 1.544 - item.result_code, 1.545 + item.result(), 1.546 typecast(item.ctype(), py_object_type, unpack_code), 1.547 - code.error_goto_if_null(item.result_code, self.pos))) 1.548 + code.error_goto_if_null(item.result(), self.pos))) 1.549 value_node = self.coerced_unpacked_items[i] 1.550 value_node.generate_evaluation_code(code) 1.551 self.args[i].generate_assignment_code(value_node, code) 1.552 @@ -2544,16 +2547,16 @@ 1.553 return 1.554 code.putln( 1.555 "%s = PyTuple_New(%s); %s" % ( 1.556 - self.result_code, 1.557 + self.result(), 1.558 len(self.args), 1.559 - code.error_goto_if_null(self.result_code, self.pos))) 1.560 + code.error_goto_if_null(self.result(), self.pos))) 1.561 for i in range(len(self.args)): 1.562 arg = self.args[i] 1.563 if not arg.result_in_temp(): 1.564 - code.put_incref(arg.result_code, arg.ctype()) 1.565 + code.put_incref(arg.result(), arg.ctype()) 1.566 code.putln( 1.567 "PyTuple_SET_ITEM(%s, %s, %s);" % ( 1.568 - self.result_code, 1.569 + self.result(), 1.570 i, 1.571 arg.py_result())) 1.572 1.573 @@ -2579,16 +2582,16 @@ 1.574 1.575 def generate_operation_code(self, code): 1.576 code.putln("%s = PyList_New(%s); %s" % 1.577 - (self.result_code, 1.578 + (self.result(), 1.579 len(self.args), 1.580 - code.error_goto_if_null(self.result_code, self.pos))) 1.581 + code.error_goto_if_null(self.result(), self.pos))) 1.582 for i in range(len(self.args)): 1.583 arg = self.args[i] 1.584 #if not arg.is_temp: 1.585 if not arg.result_in_temp(): 1.586 - code.put_incref(arg.result_code, arg.ctype()) 1.587 + code.put_incref(arg.result(), arg.ctype()) 1.588 code.putln("PyList_SET_ITEM(%s, %s, %s);" % 1.589 - (self.result_code, 1.590 + (self.result(), 1.591 i, 1.592 arg.py_result())) 1.593 1.594 @@ -2621,9 +2624,9 @@ 1.595 1.596 def generate_operation_code(self, code): 1.597 code.putln("%s = PyList_New(%s); %s" % 1.598 - (self.result_code, 1.599 + (self.result(), 1.600 0, 1.601 - code.error_goto_if_null(self.result_code, self.pos))) 1.602 + code.error_goto_if_null(self.result(), self.pos))) 1.603 self.loop.generate_execution_code(code) 1.604 1.605 def annotate(self, code): 1.606 @@ -2645,10 +2648,10 @@ 1.607 1.608 def generate_result_code(self, code): 1.609 code.putln("%s = PyList_Append(%s, (PyObject*)%s); %s" % 1.610 - (self.result_code, 1.611 - self.target.result_code, 1.612 - self.expr.result_code, 1.613 - code.error_goto_if(self.result_code, self.pos))) 1.614 + (self.result(), 1.615 + self.target.result(), 1.616 + self.expr.result(), 1.617 + code.error_goto_if(self.result(), self.pos))) 1.618 1.619 1.620 class DictNode(ExprNode): 1.621 @@ -2690,13 +2693,13 @@ 1.622 # pairs are evaluated and used one at a time. 1.623 code.putln( 1.624 "%s = PyDict_New(); %s" % ( 1.625 - self.result_code, 1.626 - code.error_goto_if_null(self.result_code, self.pos))) 1.627 + self.result(), 1.628 + code.error_goto_if_null(self.result(), self.pos))) 1.629 for item in self.key_value_pairs: 1.630 item.generate_evaluation_code(code) 1.631 code.put_error_if_neg(self.pos, 1.632 "PyDict_SetItem(%s, %s, %s)" % ( 1.633 - self.result_code, 1.634 + self.result(), 1.635 item.key.py_result(), 1.636 item.value.py_result())) 1.637 item.generate_disposal_code(code) 1.638 @@ -2763,12 +2766,12 @@ 1.639 self.doc.py_result())) 1.640 code.putln( 1.641 '%s = __Pyx_CreateClass(%s, %s, %s, "%s"); %s' % ( 1.642 - self.result_code, 1.643 + self.result(), 1.644 self.bases.py_result(), 1.645 self.dict.py_result(), 1.646 self.cname, 1.647 self.module_name, 1.648 - code.error_goto_if_null(self.result_code, self.pos))) 1.649 + code.error_goto_if_null(self.result(), self.pos))) 1.650 1.651 1.652 class UnboundMethodNode(ExprNode): 1.653 @@ -2792,10 +2795,10 @@ 1.654 def generate_result_code(self, code): 1.655 code.putln( 1.656 "%s = PyMethod_New(%s, 0, %s); %s" % ( 1.657 - self.result_code, 1.658 + self.result(), 1.659 self.function.py_result(), 1.660 self.class_cname, 1.661 - code.error_goto_if_null(self.result_code, self.pos))) 1.662 + code.error_goto_if_null(self.result(), self.pos))) 1.663 1.664 1.665 class PyCFunctionNode(AtomicExprNode): 1.666 @@ -2815,9 +2818,9 @@ 1.667 def generate_result_code(self, code): 1.668 code.putln( 1.669 "%s = PyCFunction_New(&%s, 0); %s" % ( 1.670 - self.result_code, 1.671 + self.result(), 1.672 self.pymethdef_cname, 1.673 - code.error_goto_if_null(self.result_code, self.pos))) 1.674 + code.error_goto_if_null(self.result(), self.pos))) 1.675 1.676 #------------------------------------------------------------------- 1.677 # 1.678 @@ -2888,10 +2891,10 @@ 1.679 function = self.py_operation_function() 1.680 code.putln( 1.681 "%s = %s(%s); %s" % ( 1.682 - self.result_code, 1.683 + self.result(), 1.684 function, 1.685 self.operand.py_result(), 1.686 - code.error_goto_if_null(self.result_code, self.pos))) 1.687 + code.error_goto_if_null(self.result(), self.pos))) 1.688 1.689 def type_error(self): 1.690 if not self.operand.type.is_error: 1.691 @@ -2920,7 +2923,7 @@ 1.692 self.type = PyrexTypes.c_bint_type 1.693 1.694 def calculate_result_code(self): 1.695 - return "(!%s)" % self.operand.result_code 1.696 + return "(!%s)" % self.operand.result() 1.697 1.698 def generate_result_code(self, code): 1.699 pass 1.700 @@ -2938,7 +2941,7 @@ 1.701 return "PyNumber_Positive" 1.702 1.703 def calculate_result_code(self): 1.704 - return self.operand.result_code 1.705 + return self.operand.result() 1.706 1.707 1.708 class UnaryMinusNode(UnopNode): 1.709 @@ -2956,7 +2959,7 @@ 1.710 return "PyNumber_Negative" 1.711 1.712 def calculate_result_code(self): 1.713 - return "(-%s)" % self.operand.result_code 1.714 + return "(-%s)" % self.operand.result() 1.715 1.716 1.717 class TildeNode(UnopNode): 1.718 @@ -2972,7 +2975,7 @@ 1.719 return "PyNumber_Invert" 1.720 1.721 def calculate_result_code(self): 1.722 - return "(~%s)" % self.operand.result_code 1.723 + return "(~%s)" % self.operand.result() 1.724 1.725 1.726 class AmpersandNode(ExprNode): 1.727 @@ -3002,7 +3005,7 @@ 1.728 self.result_code = "<error>" 1.729 1.730 def calculate_result_code(self): 1.731 - return "(&%s)" % self.operand.result_code 1.732 + return "(&%s)" % self.operand.result() 1.733 1.734 def generate_result_code(self, code): 1.735 pass 1.736 @@ -3073,8 +3076,7 @@ 1.737 1.738 def calculate_result_code(self): 1.739 opnd = self.operand 1.740 - result_code = self.type.cast_code(opnd.result_code) 1.741 - return result_code 1.742 + return self.type.cast_code(opnd.result()) 1.743 1.744 def result_as(self, type): 1.745 if self.type.is_pyobject and not self.is_temp: 1.746 @@ -3087,9 +3089,9 @@ 1.747 if self.is_temp: 1.748 code.putln( 1.749 "%s = (PyObject *)%s;" % ( 1.750 - self.result_code, 1.751 - self.operand.result_code)) 1.752 - code.put_incref(self.result_code, self.ctype()) 1.753 + self.result(), 1.754 + self.operand.result())) 1.755 + code.put_incref(self.result(), self.ctype()) 1.756 1.757 1.758 class SizeofNode(ExprNode): 1.759 @@ -3158,7 +3160,7 @@ 1.760 self.type = PyrexTypes.c_int_type 1.761 1.762 def calculate_result_code(self): 1.763 - return "(sizeof(%s))" % self.operand.result_code 1.764 + return "(sizeof(%s))" % self.operand.result() 1.765 1.766 def generate_result_code(self, code): 1.767 pass 1.768 @@ -3266,12 +3268,12 @@ 1.769 extra_args = "" 1.770 code.putln( 1.771 "%s = %s(%s, %s%s); %s" % ( 1.772 - self.result_code, 1.773 + self.result(), 1.774 function, 1.775 self.operand1.py_result(), 1.776 self.operand2.py_result(), 1.777 extra_args, 1.778 - code.error_goto_if_null(self.result_code, self.pos))) 1.779 + code.error_goto_if_null(self.result(), self.pos))) 1.780 else: 1.781 if self.is_temp: 1.782 self.generate_c_operation_code(code) 1.783 @@ -3312,9 +3314,9 @@ 1.784 1.785 def calculate_result_code(self): 1.786 return "(%s %s %s)" % ( 1.787 - self.operand1.result_code, 1.788 + self.operand1.result(), 1.789 self.operator, 1.790 - self.operand2.result_code) 1.791 + self.operand2.result()) 1.792 1.793 def py_operation_function(self): 1.794 return self.py_functions[self.operator] 1.795 @@ -3396,9 +3398,9 @@ 1.796 1.797 def calculate_result_code(self): 1.798 return "(%s %s %s)" % ( 1.799 - self.operand1.result_code, 1.800 + self.operand1.result(), 1.801 "/", # c division is by default floor-div 1.802 - self.operand2.result_code) 1.803 + self.operand2.result()) 1.804 1.805 1.806 class ModNode(IntBinopNode): 1.807 @@ -3438,7 +3440,7 @@ 1.808 1.809 def calculate_result_code(self): 1.810 return "pow(%s, %s)" % ( 1.811 - self.operand1.result_code, self.operand2.result_code) 1.812 + self.operand1.result(), self.operand2.result()) 1.813 1.814 1.815 class BoolBinopNode(ExprNode): 1.816 @@ -3492,11 +3494,11 @@ 1.817 # assignments and increfs/decrefs that would otherwise 1.818 # be necessary. 1.819 self.allocate_temp(env, result_code) 1.820 - self.operand1.allocate_temps(env, self.result_code) 1.821 + self.operand1.allocate_temps(env, self.result()) 1.822 if self.temp_bool: 1.823 self.temp_bool.allocate_temp(env) 1.824 self.temp_bool.release_temp(env) 1.825 - self.operand2.allocate_temps(env, self.result_code) 1.826 + self.operand2.allocate_temps(env, self.result()) 1.827 # We haven't called release_temp on either operand, 1.828 # because although they are temp nodes, they don't own 1.829 # their result variable. And because they are temp 1.830 @@ -3511,9 +3513,9 @@ 1.831 1.832 def calculate_result_code(self): 1.833 return "(%s %s %s)" % ( 1.834 - self.operand1.result_code, 1.835 + self.operand1.result(), 1.836 self.py_to_c_op[self.operator], 1.837 - self.operand2.result_code) 1.838 + self.operand2.result()) 1.839 1.840 py_to_c_op = {'and': "&&", 'or': "||"} 1.841 1.842 @@ -3536,14 +3538,14 @@ 1.843 def generate_operand1_test(self, code): 1.844 # Generate code to test the truth of the first operand. 1.845 if self.type.is_pyobject: 1.846 - test_result = self.temp_bool.result_code 1.847 + test_result = self.temp_bool.result() 1.848 code.putln( 1.849 "%s = __Pyx_PyObject_IsTrue(%s); %s" % ( 1.850 test_result, 1.851 self.operand1.py_result(), 1.852 code.error_goto_if_neg(test_result, self.pos))) 1.853 else: 1.854 - test_result = self.operand1.result_code 1.855 + test_result = self.operand1.result() 1.856 return test_result 1.857 1.858 1.859 @@ -3586,8 +3588,8 @@ 1.860 # be necessary. 1.861 self.allocate_temp(env, result_code) 1.862 self.test.allocate_temps(env, result_code) 1.863 - self.true_val.allocate_temps(env, self.result_code) 1.864 - self.false_val.allocate_temps(env, self.result_code) 1.865 + self.true_val.allocate_temps(env, self.result()) 1.866 + self.false_val.allocate_temps(env, self.result()) 1.867 # We haven't called release_temp on either value, 1.868 # because although they are temp nodes, they don't own 1.869 # their result variable. And because they are temp 1.870 @@ -3627,7 +3629,7 @@ 1.871 1.872 def generate_evaluation_code(self, code): 1.873 self.test.generate_evaluation_code(code) 1.874 - code.putln("if (%s) {" % self.test.result_code ) 1.875 + code.putln("if (%s) {" % self.test.result() ) 1.876 self.true_val.generate_evaluation_code(code) 1.877 code.putln("} else {") 1.878 self.false_val.generate_evaluation_code(code) 1.879 @@ -3844,19 +3846,19 @@ 1.880 1.881 def calculate_result_code(self): 1.882 return "(%s %s %s)" % ( 1.883 - self.operand1.result_code, 1.884 + self.operand1.result(), 1.885 self.c_operator(self.operator), 1.886 - self.operand2.result_code) 1.887 + self.operand2.result()) 1.888 1.889 def generate_evaluation_code(self, code): 1.890 self.operand1.generate_evaluation_code(code) 1.891 self.operand2.generate_evaluation_code(code) 1.892 if self.is_temp: 1.893 - self.generate_operation_code(code, self.result_code, 1.894 + self.generate_operation_code(code, self.result(), 1.895 self.operand1, self.operator, self.operand2) 1.896 if self.cascade: 1.897 self.cascade.generate_evaluation_code(code, 1.898 - self.result_code, self.operand2) 1.899 + self.result(), self.operand2) 1.900 self.operand1.generate_disposal_code(code) 1.901 self.operand2.generate_disposal_code(code) 1.902 1.903 @@ -4047,7 +4049,7 @@ 1.904 return self.arg.is_ephemeral() 1.905 1.906 def calculate_result_code(self): 1.907 - return self.arg.result_code 1.908 + return self.arg.result() 1.909 1.910 def generate_result_code(self, code): 1.911 if self.type.typeobj_is_available(): 1.912 @@ -4085,10 +4087,10 @@ 1.913 def generate_result_code(self, code): 1.914 function = self.arg.type.to_py_function 1.915 code.putln('%s = %s(%s); %s' % ( 1.916 - self.result_code, 1.917 + self.result(), 1.918 function, 1.919 - self.arg.result_code, 1.920 - code.error_goto_if_null(self.result_code, self.pos))) 1.921 + self.arg.result(), 1.922 + code.error_goto_if_null(self.result(), self.pos))) 1.923 1.924 1.925 class CoerceFromPyTypeNode(CoercionNode): 1.926 @@ -4117,9 +4119,9 @@ 1.927 if self.type.is_enum: 1.928 rhs = typecast(self.type, c_long_type, rhs) 1.929 code.putln('%s = %s; %s' % ( 1.930 - self.result_code, 1.931 + self.result(), 1.932 rhs, 1.933 - code.error_goto_if(self.type.error_condition(self.result_code), self.pos))) 1.934 + code.error_goto_if(self.type.error_condition(self.result()), self.pos))) 1.935 1.936 1.937 class CoerceToBooleanNode(CoercionNode): 1.938 @@ -4142,15 +4144,15 @@ 1.939 self.arg.check_const() 1.940 1.941 def calculate_result_code(self): 1.942 - return "(%s != 0)" % self.arg.result_code 1.943 + return "(%s != 0)" % self.arg.result() 1.944 1.945 def generate_result_code(self, code): 1.946 if self.arg.type.is_pyobject: 1.947 code.putln( 1.948 "%s = __Pyx_PyObject_IsTrue(%s); %s" % ( 1.949 - self.result_code, 1.950 + self.result(), 1.951 self.arg.py_result(), 1.952 - code.error_goto_if_neg(self.result_code, self.pos))) 1.953 + code.error_goto_if_neg(self.result(), self.pos))) 1.954 1.955 1.956 class CoerceToTempNode(CoercionNode): 1.957 @@ -4176,9 +4178,9 @@ 1.958 #self.arg.generate_evaluation_code(code) # Already done 1.959 # by generic generate_subexpr_evaluation_code! 1.960 code.putln("%s = %s;" % ( 1.961 - self.result_code, self.arg.result_as(self.ctype()))) 1.962 - if self.type.is_pyobject: 1.963 - code.put_incref(self.result_code, self.ctype()) 1.964 + self.result(), self.arg.result_as(self.ctype()))) 1.965 + if self.type.is_pyobject: 1.966 + code.put_incref(self.result(), self.ctype()) 1.967 1.968 1.969 class CloneNode(CoercionNode): 1.970 @@ -4200,7 +4202,7 @@ 1.971 self.entry = arg.entry 1.972 1.973 def calculate_result_code(self): 1.974 - return self.arg.result_code 1.975 + return self.arg.result() 1.976 1.977 def analyse_types(self, env): 1.978 self.type = self.arg.type 1.979 @@ -4249,22 +4251,22 @@ 1.980 self.analyse_counter += 1 1.981 1.982 def calculate_result_code(self): 1.983 - return self.result_code 1.984 + return self.result() 1.985 1.986 def generate_evaluation_code(self, code): 1.987 if self.generate_counter == 0: 1.988 self.arg.generate_evaluation_code(code) 1.989 code.putln("%s = %s;" % ( 1.990 - self.result_code, self.arg.result_as(self.ctype()))) 1.991 - if self.type.is_pyobject: 1.992 - code.put_incref(self.result_code, self.ctype()) 1.993 + self.result(), self.arg.result_as(self.ctype()))) 1.994 + if self.type.is_pyobject: 1.995 + code.put_incref(self.result(), self.ctype()) 1.996 self.arg.generate_disposal_code(code) 1.997 self.generate_counter += 1 1.998 1.999 def generate_disposal_code(self, code): 1.1000 if self.generate_counter == self.uses: 1.1001 if self.type.is_pyobject: 1.1002 - code.put_decref_clear(self.result_code, self.ctype()) 1.1003 + code.put_decref_clear(self.result(), self.ctype()) 1.1004 1.1005 def allocate_temps(self, env, result=None): 1.1006 if self.temp_counter == 0: 1.1007 @@ -4281,7 +4283,7 @@ 1.1008 1.1009 def release_temp(self, env): 1.1010 if self.temp_counter == self.uses: 1.1011 - env.release_temp(self.result_code) 1.1012 + env.release_temp(self.result()) 1.1013 1.1014 #------------------------------------------------------------------------------------ 1.1015 #

2.1 --- a/Cython/Compiler/Nodes.py Tue Sep 23 11:53:34 2008 -0700 2.2 +++ b/Cython/Compiler/Nodes.py Tue Sep 23 13:48:06 2008 -0700 2.3 @@ -439,7 +439,7 @@ 2.4 self.dimension.analyse_const_expression(env) 2.5 if not self.dimension.type.is_int: 2.6 error(self.dimension.pos, "Array dimension not integer") 2.7 - size = self.dimension.result_code 2.8 + size = self.dimension.result() 2.9 else: 2.10 size = None 2.11 if not base_type.is_complete(): 2.12 @@ -529,7 +529,7 @@ 2.13 "Exception value must be a Python exception or cdef function with no arguments.") 2.14 exc_val = self.exception_value 2.15 else: 2.16 - exc_val = self.exception_value.result_code 2.17 + exc_val = self.exception_value.result() 2.18 if not return_type.assignable_from(self.exception_value.type): 2.19 error(self.exception_value.pos, 2.20 "Exception value incompatible with function return type") 2.21 @@ -815,7 +815,7 @@ 2.22 if not self.value.type.is_int: 2.23 self.value = self.value.coerce_to(PyrexTypes.c_int_type, env) 2.24 self.value.analyse_const_expression(env) 2.25 - value = self.value.result_code 2.26 + value = self.value.result() 2.27 else: 2.28 value = self.name 2.29 entry = env.declare_const(self.name, enum_entry.type, 2.30 @@ -1100,7 +1100,7 @@ 2.31 if default.is_temp and default.type.is_pyobject: 2.32 code.putln( 2.33 "%s = 0;" % 2.34 - default.result_code) 2.35 + default.result()) 2.36 # For Python class methods, create and store function object 2.37 if self.assmt: 2.38 self.assmt.generate_execution_code(code) 2.39 @@ -2142,16 +2142,16 @@ 2.40 code.putln("else {") 2.41 else: 2.42 code.putln("else if (unlikely(Py_TYPE(%s)->tp_dictoffset != 0)) {" % self_arg) 2.43 - err = code.error_goto_if_null(self.func_node.result_code, self.pos) 2.44 + err = code.error_goto_if_null(self.func_node.result(), self.pos) 2.45 # need to get attribute manually--scope would return cdef method 2.46 - code.putln("%s = PyObject_GetAttr(%s, %s); %s" % (self.func_node.result_code, self_arg, self.py_func.interned_attr_cname, err)) 2.47 + code.putln("%s = PyObject_GetAttr(%s, %s); %s" % (self.func_node.result(), self_arg, self.py_func.interned_attr_cname, err)) 2.48 # It appears that this type is not anywhere exposed in the Python/C API 2.49 - is_builtin_function_or_method = '(strcmp(Py_TYPE(%s)->tp_name, "builtin_function_or_method") == 0)' % self.func_node.result_code 2.50 - is_overridden = '(PyCFunction_GET_FUNCTION(%s) != (void *)&%s)' % (self.func_node.result_code, self.py_func.entry.func_cname) 2.51 + is_builtin_function_or_method = '(strcmp(Py_TYPE(%s)->tp_name, "builtin_function_or_method") == 0)' % self.func_node.result() 2.52 + is_overridden = '(PyCFunction_GET_FUNCTION(%s) != (void *)&%s)' % (self.func_node.result(), self.py_func.entry.func_cname) 2.53 code.putln('if (!%s || %s) {' % (is_builtin_function_or_method, is_overridden)) 2.54 self.body.generate_execution_code(code) 2.55 code.putln('}') 2.56 - code.put_decref_clear(self.func_node.result_code, PyrexTypes.py_object_type) 2.57 + code.put_decref_clear(self.func_node.result(), PyrexTypes.py_object_type) 2.58 code.putln("}") 2.59 2.60 class ClassDefNode(StatNode, BlockNode): 2.61 @@ -2208,8 +2208,8 @@ 2.62 self.classobj.analyse_expressions(env) 2.63 genv = env.global_scope() 2.64 cenv = self.scope 2.65 - cenv.class_dict_cname = self.dict.result_code 2.66 - cenv.namespace_cname = cenv.class_obj_cname = self.classobj.result_code 2.67 + cenv.class_dict_cname = self.dict.result() 2.68 + cenv.namespace_cname = cenv.class_obj_cname = self.classobj.result() 2.69 self.body.analyse_expressions(cenv) 2.70 self.target.analyse_target_expression(env, self.classobj) 2.71 self.dict.release_temp(env) 2.72 @@ -2418,8 +2418,8 @@ 2.73 2.74 def generate_execution_code(self, code): 2.75 self.expr.generate_evaluation_code(code) 2.76 - if not self.expr.is_temp and self.expr.result_code: 2.77 - code.putln("%s;" % self.expr.result_code) 2.78 + if not self.expr.is_temp and self.expr.result(): 2.79 + code.putln("%s;" % self.expr.result()) 2.80 self.expr.generate_disposal_code(code) 2.81 2.82 def annotate(self, code): 2.83 @@ -2673,8 +2673,8 @@ 2.84 elif self.rhs.type.is_pyobject: 2.85 self.rhs = self.rhs.coerce_to(self.lhs.type, env) 2.86 if self.lhs.type.is_pyobject: 2.87 - self.result = ExprNodes.PyTempNode(self.pos, env).coerce_to(self.lhs.type, env) 2.88 - self.result.allocate_temps(env) 2.89 + self.result_value = ExprNodes.PyTempNode(self.pos, env).coerce_to(self.lhs.type, env) 2.90 + self.result_value.allocate_temps(env) 2.91 # if use_temp: 2.92 # self.rhs = self.rhs.coerce_to_temp(env) 2.93 self.rhs.allocate_temps(env) 2.94 @@ -2689,7 +2689,7 @@ 2.95 self.dup.release_subexpr_temps(env) 2.96 # self.rhs.release_temp(env) 2.97 if self.lhs.type.is_pyobject: 2.98 - self.result.release_temp(env) 2.99 + self.result_value.release_temp(env) 2.100 2.101 def generate_execution_code(self, code): 2.102 self.rhs.generate_evaluation_code(code) 2.103 @@ -2706,16 +2706,16 @@ 2.104 self.dup.generate_result_code(code) 2.105 code.putln( 2.106 "%s = %s(%s, %s%s); %s" % ( 2.107 - self.result.result_code, 2.108 + self.result_value.result(), 2.109 self.py_operation_function(), 2.110 self.dup.py_result(), 2.111 self.rhs.py_result(), 2.112 extra, 2.113 - code.error_goto_if_null(self.result.py_result(), self.pos))) 2.114 - self.result.generate_evaluation_code(code) # May be a type check... 2.115 + code.error_goto_if_null(self.result_value.py_result(), self.pos))) 2.116 + self.result_value.generate_evaluation_code(code) # May be a type check... 2.117 self.rhs.generate_disposal_code(code) 2.118 self.dup.generate_disposal_code(code) 2.119 - self.lhs.generate_assignment_code(self.result, code) 2.120 + self.lhs.generate_assignment_code(self.result_value, code) 2.121 else: 2.122 c_op = self.operator 2.123 if c_op == "//": 2.124 @@ -2730,7 +2730,7 @@ 2.125 self.lhs.generate_buffer_setitem_code(self.rhs, code, c_op) 2.126 else: 2.127 self.dup.generate_result_code(code) 2.128 - code.putln("%s %s= %s;" % (self.lhs.result_code, c_op, self.rhs.result_code) ) 2.129 + code.putln("%s %s= %s;" % (self.lhs.result(), c_op, self.rhs.result()) ) 2.130 self.rhs.generate_disposal_code(code) 2.131 if self.dup.is_temp: 2.132 self.dup.generate_subexpr_disposal_code(code) 2.133 @@ -3090,7 +3090,7 @@ 2.134 self.cond.generate_evaluation_code(code) 2.135 code.putln( 2.136 "if (unlikely(!%s)) {" % 2.137 - self.cond.result_code) 2.138 + self.cond.result()) 2.139 if self.value: 2.140 self.value.generate_evaluation_code(code) 2.141 code.putln( 2.142 @@ -3185,7 +3185,7 @@ 2.143 self.condition.generate_evaluation_code(code) 2.144 code.putln( 2.145 "if (%s) {" % 2.146 - self.condition.result_code) 2.147 + self.condition.result()) 2.148 self.body.generate_execution_code(code) 2.149 #code.putln( 2.150 # "goto %s;" % 2.151 @@ -3283,7 +3283,7 @@ 2.152 self.condition.generate_evaluation_code(code) 2.153 code.putln( 2.154 "if (!%s) break;" % 2.155 - self.condition.result_code) 2.156 + self.condition.result()) 2.157 self.body.generate_execution_code(code) 2.158 code.put_label(code.continue_label) 2.159 code.putln("}") 2.160 @@ -3480,7 +3480,7 @@ 2.161 c_loopvar_node = ExprNodes.TempNode(self.pos, 2.162 PyrexTypes.c_long_type, env) 2.163 c_loopvar_node.allocate_temps(env) 2.164 - self.loopvar_name = c_loopvar_node.result_code 2.165 + self.loopvar_name = c_loopvar_node.result() 2.166 self.py_loopvar_node = \ 2.167 ExprNodes.CloneNode(c_loopvar_node).coerce_to_pyobject(env) 2.168 self.bound1.allocate_temps(env) 2.169 @@ -3509,12 +3509,12 @@ 2.170 offset, incop = self.relation_table[self.relation1] 2.171 if self.step is not None: 2.172 self.step.generate_evaluation_code(code) 2.173 - incop = "%s=%s" % (incop[0], self.step.result_code) 2.174 + incop = "%s=%s" % (incop[0], self.step.result()) 2.175 code.putln( 2.176 "for (%s = %s%s; %s %s %s; %s%s) {" % ( 2.177 self.loopvar_name, 2.178 - self.bound1.result_code, offset, 2.179 - self.loopvar_name, self.relation2, self.bound2.result_code, 2.180 + self.bound1.result(), offset, 2.181 + self.loopvar_name, self.relation2, self.bound2.result(), 2.182 self.loopvar_name, incop)) 2.183 if self.py_loopvar_node: 2.184 self.py_loopvar_node.generate_evaluation_code(code) 2.185 @@ -4180,10 +4180,10 @@ 2.186 for cname, target in self.interned_items: 2.187 code.putln( 2.188 '%s = PyObject_GetAttr(%s, %s); %s' % ( 2.189 - self.item.result_code, 2.190 + self.item.result(), 2.191 self.module.py_result(), 2.192 cname, 2.193 - code.error_goto_if_null(self.item.result_code, self.pos))) 2.194 + code.error_goto_if_null(self.item.result(), self.pos))) 2.195 target.generate_assignment_code(self.item, code) 2.196 self.module.generate_disposal_code(code) 2.197