1 #

2 # Pyrex - Parse tree nodes for expressions

3 #

4

5 import operator

6 from string import join

7

8 from Errors import error, warning, InternalError

9 from Errors import hold_errors, release_errors, held_errors, report_error

10 import StringEncoding

11 import Naming

12 from Nodes import Node

13 import PyrexTypes

14 from PyrexTypes import py_object_type, c_long_type, typecast, error_type

15 from Builtin import list_type, tuple_type, dict_type, unicode_type

16 import Symtab

17 import Options

18 from Annotate import AnnotationItem

19

20 from Cython.Debugging import print_call_chain

21 from DebugFlags import debug_disposal_code, debug_temp_alloc, \

22 debug_coercion

23

24

25 class ExprNode(Node):

26 # subexprs [string] Class var holding names of subexpr node attrs

27 # type PyrexType Type of the result

28 # result_code string Code fragment

29 # result_ctype string C type of result_code if different from type

30 # is_temp boolean Result is in a temporary variable

31 # is_sequence_constructor

32 # boolean Is a list or tuple constructor expression

33 # saved_subexpr_nodes

34 # [ExprNode or [ExprNode or None] or None]

35 # Cached result of subexpr_nodes()

36

37 result_ctype = None

38 type = None

39

40 # The Analyse Expressions phase for expressions is split

41 # into two sub-phases:

42 #

43 # Analyse Types

44 # Determines the result type of the expression based

45 # on the types of its sub-expressions, and inserts

46 # coercion nodes into the expression tree where needed.

47 # Marks nodes which will need to have temporary variables

48 # allocated.

49 #

50 # Allocate Temps

51 # Allocates temporary variables where needed, and fills

52 # in the result_code field of each node.

53 #

54 # ExprNode provides some convenience routines which

55 # perform both of the above phases. These should only

56 # be called from statement nodes, and only when no

57 # coercion nodes need to be added around the expression

58 # being analysed. In that case, the above two phases

59 # should be invoked separately.

60 #

61 # Framework code in ExprNode provides much of the common

62 # processing for the various phases. It makes use of the

63 # 'subexprs' class attribute of ExprNodes, which should

64 # contain a list of the names of attributes which can

65 # hold sub-nodes or sequences of sub-nodes.

66 #

67 # The framework makes use of a number of abstract methods.

68 # Their responsibilities are as follows.

69 #

70 # Declaration Analysis phase

71 #

72 # analyse_target_declaration

73 # Called during the Analyse Declarations phase to analyse

74 # the LHS of an assignment or argument of a del statement.

75 # Nodes which cannot be the LHS of an assignment need not

76 # implement it.

77 #

78 # Expression Analysis phase

79 #

80 # analyse_types

81 # - Call analyse_types on all sub-expressions.

82 # - Check operand types, and wrap coercion nodes around

83 # sub-expressions where needed.

84 # - Set the type of this node.

85 # - If a temporary variable will be required for the

86 # result, set the is_temp flag of this node.

87 #

88 # analyse_target_types

89 # Called during the Analyse Types phase to analyse

90 # the LHS of an assignment or argument of a del

91 # statement. Similar responsibilities to analyse_types.

92 #

93 # allocate_temps

94 # - Call allocate_temps for all sub-nodes.

95 # - Call allocate_temp for this node.

96 # - If a temporary was allocated, call release_temp on

97 # all sub-expressions.

98 #

99 # allocate_target_temps

100 # - Call allocate_temps on sub-nodes and allocate any other

101 # temps used during assignment.

102 # - Fill in result_code with a C lvalue if needed.

103 # - If a rhs node is supplied, call release_temp on it.

104 # - Call release_temp on sub-nodes and release any other

105 # temps used during assignment.

106 #

107 # target_code

108 # Called by the default implementation of allocate_target_temps.

109 # Should return a C lvalue for assigning to the node. The default

110 # implementation calls calculate_result_code.

111 #

112 # check_const

113 # - Check that this node and its subnodes form a

114 # legal constant expression. If so, do nothing,

115 # otherwise call not_const.

116 #

117 # The default implementation of check_const

118 # assumes that the expression is not constant.

119 #

120 # check_const_addr

121 # - Same as check_const, except check that the

122 # expression is a C lvalue whose address is

123 # constant. Otherwise, call addr_not_const.

124 #

125 # The default implementation of calc_const_addr

126 # assumes that the expression is not a constant

127 # lvalue.

128 #

129 # Code Generation phase

130 #

131 # generate_evaluation_code

132 # - Call generate_evaluation_code for sub-expressions.

133 # - Perform the functions of generate_result_code

134 # (see below).

135 # - If result is temporary, call generate_disposal_code

136 # on all sub-expressions.

137 #

138 # A default implementation of generate_evaluation_code

139 # is provided which uses the following abstract methods:

140 #

141 # generate_result_code

142 # - Generate any C statements necessary to calculate

143 # the result of this node from the results of its

144 # sub-expressions.

145 #

146 # calculate_result_code

147 # - Should return a C code fragment evaluating to the

148 # result. This is only called when the result is not

149 # a temporary.

150 #

151 # generate_assignment_code

152 # Called on the LHS of an assignment.

153 # - Call generate_evaluation_code for sub-expressions.

154 # - Generate code to perform the assignment.

155 # - If the assignment absorbed a reference, call

156 # generate_post_assignment_code on the RHS,

157 # otherwise call generate_disposal_code on it.

158 #

159 # generate_deletion_code

160 # Called on an argument of a del statement.

161 # - Call generate_evaluation_code for sub-expressions.

162 # - Generate code to perform the deletion.

163 # - Call generate_disposal_code on all sub-expressions.

164 #

165 #

166

167 is_sequence_constructor = 0

168 is_attribute = 0

169

170 saved_subexpr_nodes = None

171 is_temp = 0

172 is_target = 0

173

174 def get_child_attrs(self):

175 return self.subexprs

176 child_attrs = property(fget=get_child_attrs)

177

178 def not_implemented(self, method_name):

179 print_call_chain(method_name, "not implemented") ###

180 raise InternalError(

181 "%s.%s not implemented" %

182 (self.__class__.__name__, method_name))

183

184 def is_lvalue(self):

185 return 0

186

187 def is_ephemeral(self):

188 # An ephemeral node is one whose result is in

189 # a Python temporary and we suspect there are no

190 # other references to it. Certain operations are

191 # disallowed on such values, since they are

192 # likely to result in a dangling pointer.

193 return self.type.is_pyobject and self.is_temp

194

195 def subexpr_nodes(self):

196 # Extract a list of subexpression nodes based

197 # on the contents of the subexprs class attribute.

198 if self.saved_subexpr_nodes is None:

199 nodes = []

200 for name in self.subexprs:

201 item = getattr(self, name)

202 if item:

203 if isinstance(item, ExprNode):

204 nodes.append(item)

205 else:

206 nodes.extend(item)

207 self.saved_subexpr_nodes = nodes

208 return self.saved_subexpr_nodes

209

210 def result(self):

211 if not self.is_temp or self.is_target:

212 return self.calculate_result_code()

213 else: # i.e. self.is_temp:

214 return self.result_code

215

216 def result_as(self, type = None):

217 # Return the result code cast to the specified C type.

218 return typecast(type, self.ctype(), self.result())

219

220 def py_result(self):

221 # Return the result code cast to PyObject *.

222 return self.result_as(py_object_type)

223

224 def ctype(self):

225 # Return the native C type of the result (i.e. the

226 # C type of the result_code expression).

227 return self.result_ctype or self.type

228

229 def compile_time_value(self, denv):

230 # Return value of compile-time expression, or report error.

231 error(self.pos, "Invalid compile-time expression")

232

233 def compile_time_value_error(self, e):

234 error(self.pos, "Error in compile-time expression: %s: %s" % (

235 e.__class__.__name__, e))

236

237 # ------------- Declaration Analysis ----------------

238

239 def analyse_target_declaration(self, env):

240 error(self.pos, "Cannot assign to or delete this")

241

242 # ------------- Expression Analysis ----------------

243

244 def analyse_const_expression(self, env):

245 # Called during the analyse_declarations phase of a

246 # constant expression. Analyses the expression's type,

247 # checks whether it is a legal const expression,

248 # and determines its value.

249 self.analyse_types(env)

250 self.allocate_temps(env)

251 self.check_const()

252

253 def analyse_expressions(self, env):

254 # Convenience routine performing both the Type

255 # Analysis and Temp Allocation phases for a whole

256 # expression.

257 self.analyse_types(env)

258 self.allocate_temps(env)

259

260 def analyse_target_expression(self, env, rhs):

261 # Convenience routine performing both the Type

262 # Analysis and Temp Allocation phases for the LHS of

263 # an assignment.

264 self.analyse_target_types(env)

265 self.allocate_target_temps(env, rhs)

266

267 def analyse_boolean_expression(self, env):

268 # Analyse expression and coerce to a boolean.

269 self.analyse_types(env)

270 bool = self.coerce_to_boolean(env)

271 bool.allocate_temps(env)

272 return bool

273

274 def analyse_temp_boolean_expression(self, env):

275 # Analyse boolean expression and coerce result into

276 # a temporary. This is used when a branch is to be

277 # performed on the result and we won't have an

278 # opportunity to ensure disposal code is executed

279 # afterwards. By forcing the result into a temporary,

280 # we ensure that all disposal has been done by the

281 # time we get the result.

282 self.analyse_types(env)

283 bool = self.coerce_to_boolean(env)

284 temp_bool = bool.coerce_to_temp(env)

285 temp_bool.allocate_temps(env)

286 return temp_bool

287

288 # --------------- Type Analysis ------------------

289

290 def analyse_as_module(self, env):

291 # If this node can be interpreted as a reference to a

292 # cimported module, return its scope, else None.

293 return None

294

295 def analyse_as_type(self, env):

296 # If this node can be interpreted as a reference to a

297 # type, return that type, else None.

298 return None

299

300 def analyse_as_extension_type(self, env):

301 # If this node can be interpreted as a reference to an

302 # extension type, return its type, else None.

303 return None

304

305 def analyse_types(self, env):

306 self.not_implemented("analyse_types")

307

308 def analyse_target_types(self, env):

309 self.analyse_types(env)

310

311 def gil_assignment_check(self, env):

312 if env.nogil and self.type.is_pyobject:

313 error(self.pos, "Assignment of Python object not allowed without gil")

314

315 def check_const(self):

316 self.not_const()

317

318 def not_const(self):

319 error(self.pos, "Not allowed in a constant expression")

320

321 def check_const_addr(self):

322 self.addr_not_const()

323

324 def addr_not_const(self):

325 error(self.pos, "Address is not constant")

326

327 def gil_check(self, env):

328 if env.nogil and self.type.is_pyobject:

329 self.gil_error()

330

331 # ----------------- Result Allocation -----------------

332

333 def result_in_temp(self):

334 # Return true if result is in a temporary owned by

335 # this node or one of its subexpressions. Overridden

336 # by certain nodes which can share the result of

337 # a subnode.

338 return self.is_temp

339

340 def allocate_target_temps(self, env, rhs):

341 # Perform temp allocation for the LHS of an assignment.

342 if debug_temp_alloc:

343 print("%s Allocating target temps" % self)

344 self.allocate_subexpr_temps(env)

345 self.is_target = True

346 if rhs:

347 rhs.release_temp(env)

348 self.release_subexpr_temps(env)

349

350 def allocate_temps(self, env, result = None):

351 # Allocate temporary variables for this node and

352 # all its sub-expressions. If a result is specified,

353 # this must be a temp node and the specified variable

354 # is used as the result instead of allocating a new

355 # one.

356 if debug_temp_alloc:

357 print("%s Allocating temps" % self)

358 self.allocate_subexpr_temps(env)

359 self.allocate_temp(env, result)

360 if self.is_temp:

361 self.release_subexpr_temps(env)

362

363 def allocate_subexpr_temps(self, env):

364 # Allocate temporary variables for all sub-expressions

365 # of this node.

366 if debug_temp_alloc:

367 print("%s Allocating temps for: %s" % (self, self.subexprs))

368 for node in self.subexpr_nodes():

369 if node:

370 if debug_temp_alloc:

371 print("%s Allocating temps for %s" % (self, node))

372 node.allocate_temps(env)

373

374 def allocate_temp(self, env, result = None):

375 # If this node requires a temporary variable for its

376 # result, allocate one, otherwise set the result to

377 # a C code fragment. If a result is specified,

378 # this must be a temp node and the specified variable

379 # is used as the result instead of allocating a new

380 # one.

381 if debug_temp_alloc:

382 print("%s Allocating temp" % self)

383 if result:

384 if not self.is_temp:

385 raise InternalError("Result forced on non-temp node")

386 self.result_code = result

387 elif self.is_temp:

388 type = self.type

389 if not type.is_void:

390 if type.is_pyobject:

391 type = PyrexTypes.py_object_type

392 self.result_code = env.allocate_temp(type)

393 else:

394 self.result_code = None

395 if debug_temp_alloc:

396 print("%s Allocated result %s" % (self, self.result_code))

397

398 def target_code(self):

399 # Return code fragment for use as LHS of a C assignment.

400 return self.calculate_result_code()

401

402 def calculate_result_code(self):

403 self.not_implemented("calculate_result_code")

404

405 # def release_target_temp(self, env):

406 # # Release temporaries used by LHS of an assignment.

407 # self.release_subexpr_temps(env)

408

409 def release_temp(self, env):

410 # If this node owns a temporary result, release it,

411 # otherwise release results of its sub-expressions.

412 if self.is_temp:

413 if debug_temp_alloc:

414 print("%s Releasing result %s" % (self, self.result_code))

415 env.release_temp(self.result_code)

416 else:

417 self.release_subexpr_temps(env)

418

419 def release_subexpr_temps(self, env):

420 # Release the results of all sub-expressions of

421 # this node.

422 for node in self.subexpr_nodes():

423 if node:

424 node.release_temp(env)

425

426 # ---------------- Code Generation -----------------

427

428 def make_owned_reference(self, code):

429 # If result is a pyobject, make sure we own

430 # a reference to it.

431 if self.type.is_pyobject and not self.result_in_temp():

432 code.put_incref(self.result(), self.ctype())

433

434 def generate_evaluation_code(self, code):

435 code.mark_pos(self.pos)

436 # Generate code to evaluate this node and

437 # its sub-expressions, and dispose of any

438 # temporary results of its sub-expressions.

439 self.generate_subexpr_evaluation_code(code)

440 self.pre_generate_result_code(code)

441 self.generate_result_code(code)

442 if self.is_temp:

443 self.generate_subexpr_disposal_code(code)

444

445 def pre_generate_result_code(self, code):

446 pass

447

448 def generate_subexpr_evaluation_code(self, code):

449 for node in self.subexpr_nodes():

450 node.generate_evaluation_code(code)

451

452 def generate_result_code(self, code):

453 self.not_implemented("generate_result_code")

454

455 def generate_disposal_code(self, code):

456 # If necessary, generate code to dispose of

457 # temporary Python reference.

458 if self.is_temp:

459 if self.type.is_pyobject:

460 code.put_decref_clear(self.result(), self.ctype())

461 else:

462 self.generate_subexpr_disposal_code(code)

463

464 def generate_subexpr_disposal_code(self, code):

465 # Generate code to dispose of temporary results

466 # of all sub-expressions.

467 for node in self.subexpr_nodes():

468 node.generate_disposal_code(code)

469

470 def generate_post_assignment_code(self, code):

471 # Same as generate_disposal_code except that

472 # assignment will have absorbed a reference to

473 # the result if it is a Python object.

474 if self.is_temp:

475 if self.type.is_pyobject:

476 code.putln("%s = 0;" % self.result())

477 else:

478 self.generate_subexpr_disposal_code(code)

479

480 def generate_assignment_code(self, rhs, code):

481 # Stub method for nodes which are not legal as

482 # the LHS of an assignment. An error will have

483 # been reported earlier.

484 pass

485

486 def generate_deletion_code(self, code):

487 # Stub method for nodes that are not legal as

488 # the argument of a del statement. An error

489 # will have been reported earlier.

490 pass

491

492 # ---------------- Annotation ---------------------

493

494 def annotate(self, code):

495 for node in self.subexpr_nodes():

496 node.annotate(code)

497

498 # ----------------- Coercion ----------------------

499

500 def coerce_to(self, dst_type, env):

501 # Coerce the result so that it can be assigned to

502 # something of type dst_type. If processing is necessary,

503 # wraps this node in a coercion node and returns that.

504 # Otherwise, returns this node unchanged.

505 #

506 # This method is called during the analyse_expressions

507 # phase of the src_node's processing.

508 src = self

509 src_type = self.type

510 src_is_py_type = src_type.is_pyobject

511 dst_is_py_type = dst_type.is_pyobject

512

513 if dst_type.is_pyobject:

514 if not src.type.is_pyobject:

515 src = CoerceToPyTypeNode(src, env)

516 if not src.type.subtype_of(dst_type):

517 if not isinstance(src, NoneNode):

518 src = PyTypeTestNode(src, dst_type, env)

519 elif src.type.is_pyobject:

520 src = CoerceFromPyTypeNode(dst_type, src, env)

521 else: # neither src nor dst are py types

522 # Added the string comparison, since for c types that

523 # is enough, but Cython gets confused when the types are

524 # in different files.

525 if not (str(src.type) == str(dst_type) or dst_type.assignable_from(src_type)):

526 error(self.pos, "Cannot assign type '%s' to '%s'" %

527 (src.type, dst_type))

528 return src

529

530 def coerce_to_pyobject(self, env):

531 return self.coerce_to(PyrexTypes.py_object_type, env)

532

533 def coerce_to_boolean(self, env):

534 # Coerce result to something acceptable as

535 # a boolean value.

536 type = self.type

537 if type.is_pyobject or type.is_ptr or type.is_float:

538 return CoerceToBooleanNode(self, env)

539 else:

540 if not type.is_int and not type.is_error:

541 error(self.pos,

542 "Type '%s' not acceptable as a boolean" % type)

543 return self

544

545 def coerce_to_integer(self, env):

546 # If not already some C integer type, coerce to longint.

547 if self.type.is_int:

548 return self

549 else:

550 return self.coerce_to(PyrexTypes.c_long_type, env)

551

552 def coerce_to_temp(self, env):

553 # Ensure that the result is in a temporary.

554 if self.result_in_temp():

555 return self

556 else:

557 return CoerceToTempNode(self, env)

558

559 def coerce_to_simple(self, env):

560 # Ensure that the result is simple (see is_simple).

561 if self.is_simple():

562 return self

563 else:

564 return self.coerce_to_temp(env)

565

566 def is_simple(self):

567 # A node is simple if its result is something that can

568 # be referred to without performing any operations, e.g.

569 # a constant, local var, C global var, struct member

570 # reference, or temporary.

571 return self.result_in_temp()

572

573 def magic_cython_method(self):

574 return None

575

576

577 class NewTempExprNode(ExprNode):

578 backwards_compatible_result = None

579

580 def result(self):

581 if self.is_temp:

582 return self.temp_code

583 else:

584 return self.calculate_result_code()

585

586 def allocate_target_temps(self, env, rhs):

587 self.allocate_subexpr_temps(env)

588 rhs.release_temp(rhs)

589 self.release_subexpr_temps(env)

590

591 def allocate_temps(self, env, result = None):

592 self.allocate_subexpr_temps(env)

593 self.backwards_compatible_result = result

594 if self.is_temp:

595 self.release_subexpr_temps(env)

596

597 def allocate_temp(self, env, result = None):

598 assert result is None

599

600 def release_temp(self, env):

601 pass

602

603 def pre_generate_result_code(self, code):

604 if self.is_temp:

605 type = self.type

606 if not type.is_void:

607 if type.is_pyobject:

608 type = PyrexTypes.py_object_type

609 if self.backwards_compatible_result:

610 self.temp_code = self.backwards_compatible_result

611 else:

612 self.temp_code = code.funcstate.allocate_temp(type)

613 else:

614 self.temp_code = None

615

616 def generate_disposal_code(self, code):

617 if self.is_temp:

618 if self.type.is_pyobject:

619 code.put_decref_clear(self.result(), self.ctype())

620 if not self.backwards_compatible_result:

621 code.funcstate.release_temp(self.temp_code)

622 else:

623 self.generate_subexpr_disposal_code(code)

624

625 def generate_post_assignment_code(self, code):

626 if self.is_temp:

627 if self.type.is_pyobject:

628 code.putln("%s = 0;" % self.temp_code)

629 if not self.backwards_compatible_result:

630 code.funcstate.release_temp(self.temp_code)

631 else:

632 self.generate_subexpr_disposal_code(code)

633

634

635

636

637 class AtomicExprNode(ExprNode):

638 # Abstract base class for expression nodes which have

639 # no sub-expressions.

640

641 subexprs = []

642

643

644 class PyConstNode(AtomicExprNode):

645 # Abstract base class for constant Python values.

646

647 is_literal = 1

648

649 def is_simple(self):

650 return 1

651

652 def analyse_types(self, env):

653 self.type = py_object_type

654

655 def calculate_result_code(self):

656 return self.value

657

658 def generate_result_code(self, code):

659 pass

660

661

662 class NoneNode(PyConstNode):

663 # The constant value None

664

665 value = "Py_None"

666

667 def compile_time_value(self, denv):

668 return None

669

670 class EllipsisNode(PyConstNode):

671 # '...' in a subscript list.

672

673 value = "Py_Ellipsis"

674

675 def compile_time_value(self, denv):

676 return Ellipsis

677

678

679 class ConstNode(AtomicExprNode):

680 # Abstract base type for literal constant nodes.

681 #

682 # value string C code fragment

683

684 is_literal = 1

685

686 def is_simple(self):

687 return 1

688

689 def analyse_types(self, env):

690 pass # Types are held in class variables

691

692 def check_const(self):

693 pass

694

695 def calculate_result_code(self):

696 return str(self.value)

697

698 def generate_result_code(self, code):

699 pass

700

701

702 class BoolNode(ConstNode):

703 type = PyrexTypes.c_bint_type

704 # The constant value True or False

705

706 def compile_time_value(self, denv):

707 return self.value

708

709 def calculate_result_code(self):

710 return str(int(self.value))

711

712 class NullNode(ConstNode):

713 type = PyrexTypes.c_null_ptr_type

714 value = "NULL"

715

716

717 class CharNode(ConstNode):

718 type = PyrexTypes.c_char_type

719

720 def compile_time_value(self, denv):

721 return ord(self.value)

722

723 def calculate_result_code(self):

724 return "'%s'" % StringEncoding.escape_character(self.value)

725

726

727 class IntNode(ConstNode):

728

729 # unsigned "" or "U"

730 # longness "" or "L" or "LL"

731

732 unsigned = ""

733 longness = ""

734 type = PyrexTypes.c_long_type

735

736 def coerce_to(self, dst_type, env):

737 if dst_type.is_numeric:

738 self.type = PyrexTypes.c_long_type

739 return self

740 # Arrange for a Python version of the number to be pre-allocated

741 # when coercing to a Python type.

742 if dst_type.is_pyobject:

743 self.entry = env.get_py_num(self.value, self.longness)

744 self.type = PyrexTypes.py_object_type

745 # We still need to perform normal coerce_to processing on the

746 # result, because we might be coercing to an extension type,

747 # in which case a type test node will be needed.

748 return ConstNode.coerce_to(self, dst_type, env)

749

750 def calculate_result_code(self):

751 if self.type.is_pyobject:

752 return self.entry.cname

753 else:

754 return str(self.value) + self.unsigned + self.longness

755

756 def compile_time_value(self, denv):

757 return int(self.value, 0)

758

759

760 class FloatNode(ConstNode):

761 type = PyrexTypes.c_double_type

762

763 def compile_time_value(self, denv):

764 return float(self.value)

765

766 def calculate_result_code(self):

767 strval = str(self.value)

768 if strval == 'nan':

769 return "(Py_HUGE_VAL * 0)"

770 elif strval == 'inf':

771 return "Py_HUGE_VAL"

772 elif strval == '-inf':

773 return "(-Py_HUGE_VAL)"

774 else:

775 return strval

776

777

778 class StringNode(ConstNode):

779 # entry Symtab.Entry

780

781 type = PyrexTypes.c_char_ptr_type

782

783 def compile_time_value(self, denv):

784 return self.value

785

786 def analyse_types(self, env):

787 self.entry = env.add_string_const(self.value)

788

789 def analyse_as_type(self, env):

790 type = PyrexTypes.parse_basic_type(self.value)

791 if type is not None:

792 return type

793 from TreeFragment import TreeFragment

794 pos = (self.pos[0], self.pos[1], self.pos[2]-7)

795 declaration = TreeFragment(u"sizeof(%s)" % self.value, name=pos[0].filename, initial_pos=pos)

796 sizeof_node = declaration.root.stats[0].expr

797 sizeof_node.analyse_types(env)

798 if isinstance(sizeof_node, SizeofTypeNode):

799 return sizeof_node.arg_type

800

801 def coerce_to(self, dst_type, env):

802 if dst_type == PyrexTypes.c_char_ptr_type:

803 self.type = PyrexTypes.c_char_ptr_type

804 return self

805

806 if dst_type.is_int:

807 if not self.type.is_pyobject and len(self.entry.init) == 1:

808 return CharNode(self.pos, value=self.value)

809 else:

810 error(self.pos, "Only coerce single-character ascii strings can be used as ints.")

811 return self

812 # Arrange for a Python version of the string to be pre-allocated

813 # when coercing to a Python type.

814 if dst_type.is_pyobject and not self.type.is_pyobject:

815 node = self.as_py_string_node(env)

816 else:

817 node = self

818 # We still need to perform normal coerce_to processing on the

819 # result, because we might be coercing to an extension type,

820 # in which case a type test node will be needed.

821 return ConstNode.coerce_to(node, dst_type, env)

822

823 def as_py_string_node(self, env):

824 # Return a new StringNode with the same entry as this node

825 # but whose type is a Python type instead of a C type.

826 entry = self.entry

827 env.add_py_string(entry)

828 return StringNode(self.pos, value = self.value, entry = entry, type = py_object_type)

829

830 def calculate_result_code(self):

831 if self.type.is_pyobject:

832 return self.entry.pystring_cname

833 else:

834 return self.entry.cname

835

836

837 class UnicodeNode(PyConstNode):

838 # entry Symtab.Entry

839

840 type = unicode_type

841

842 def analyse_types(self, env):

843 self.entry = env.add_string_const(self.value)

844 env.add_py_string(self.entry)

845

846 def calculate_result_code(self):

847 return self.entry.pystring_cname

848

849 def _coerce_to(self, dst_type, env):

850 if not dst_type.is_pyobject:

851 node = StringNode(self.pos, entry = entry, type = py_object_type)

852 return ConstNode.coerce_to(node, dst_type, env)

853 else:

854 return self

855 # We still need to perform normal coerce_to processing on the

856 # result, because we might be coercing to an extension type,

857 # in which case a type test node will be needed.

858

859 def compile_time_value(self, env):

860 return self.value

861

862

863 class IdentifierStringNode(ConstNode):

864 # A Python string that behaves like an identifier, e.g. for

865 # keyword arguments in a call, or for imported names

866 type = PyrexTypes.py_object_type

867

868 def analyse_types(self, env):

869 self.cname = env.intern_identifier(self.value)

870

871 def calculate_result_code(self):

872 return self.cname

873

874

875 class LongNode(AtomicExprNode):

876 # Python long integer literal

877 #

878 # value string

879

880 def compile_time_value(self, denv):

881 return long(self.value)

882

883 gil_message = "Constructing Python long int"

884

885 def analyse_types(self, env):

886 self.type = py_object_type

887 self.gil_check(env)

888 self.is_temp = 1

889

890 gil_message = "Constructing Python long int"

891

892 def generate_evaluation_code(self, code):

893 code.putln(

894 '%s = PyLong_FromString("%s", 0, 0); %s' % (

895 self.result(),

896 self.value,

897 code.error_goto_if_null(self.result(), self.pos)))

898

899

900 class ImagNode(AtomicExprNode):

901 # Imaginary number literal

902 #

903 # value float imaginary part

904

905 def compile_time_value(self, denv):

906 return complex(0.0, self.value)

907

908 def analyse_types(self, env):

909 self.type = py_object_type

910 self.gil_check(env)

911 self.is_temp = 1

912

913 gil_message = "Constructing complex number"

914

915 def generate_evaluation_code(self, code):

916 code.putln(

917 "%s = PyComplex_FromDoubles(0.0, %s); %s" % (

918 self.result(),

919 self.value,

920 code.error_goto_if_null(self.result(), self.pos)))

921

922

923 class NameNode(AtomicExprNode):

924 # Reference to a local or global variable name.

925 #

926 # name string Python name of the variable

927 #

928 # entry Entry Symbol table entry

929 # interned_cname string

930

931 is_name = True

932 is_cython_module = False

933 cython_attribute = None

934 skip_assignment_decref = False

935 entry = None

936

937 def create_analysed_rvalue(pos, env, entry):

938 node = NameNode(pos)

939 node.analyse_types(env, entry=entry)

940 return node

941

942 def magic_cython_method(self):

943 return self.cython_attribute

944

945 create_analysed_rvalue = staticmethod(create_analysed_rvalue)

946

947 def compile_time_value(self, denv):

948 try:

949 return denv.lookup(self.name)

950 except KeyError:

951 error(self.pos, "Compile-time name '%s' not defined" % self.name)

952

953 def coerce_to(self, dst_type, env):

954 # If coercing to a generic pyobject and this is a builtin

955 # C function with a Python equivalent, manufacture a NameNode

956 # referring to the Python builtin.

957 #print "NameNode.coerce_to:", self.name, dst_type ###

958 if dst_type is py_object_type:

959 entry = self.entry

960 if entry and entry.is_cfunction:

961 var_entry = entry.as_variable

962 if var_entry:

963 if var_entry.is_builtin and Options.cache_builtins:

964 var_entry = env.declare_builtin(var_entry.name, self.pos)

965 node = NameNode(self.pos, name = self.name)

966 node.entry = var_entry

967 node.analyse_rvalue_entry(env)

968 return node

969 return AtomicExprNode.coerce_to(self, dst_type, env)

970

971 def analyse_as_module(self, env):

972 # Try to interpret this as a reference to a cimported module.

973 # Returns the module scope, or None.

974 entry = self.entry

975 if not entry:

976 entry = env.lookup(self.name)

977 if entry and entry.as_module:

978 return entry.as_module

979 return None

980

981 def analyse_as_type(self, env):

982 type = PyrexTypes.parse_basic_type(self.name)

983 if type:

984 return type

985 entry = self.entry

986 if not entry:

987 entry = env.lookup(self.name)

988 if entry and entry.is_type:

989 return entry.type

990 else:

991 return None

992

993 def analyse_as_extension_type(self, env):

994 # Try to interpret this as a reference to an extension type.

995 # Returns the extension type, or None.

996 entry = self.entry

997 if not entry:

998 entry = env.lookup(self.name)

999 if entry and entry.is_type and entry.type.is_extension_type:

1000 return entry.type

1001 else:

1002 return None

1003

1004 def analyse_target_declaration(self, env):

1005 if not self.entry:

1006 self.entry = env.lookup_here(self.name)

1007 if not self.entry:

1008 self.entry = env.declare_var(self.name, py_object_type, self.pos)

1009 env.control_flow.set_state(self.pos, (self.name, 'initalized'), True)

1010 env.control_flow.set_state(self.pos, (self.name, 'source'), 'assignment')

1011 if self.entry.is_declared_generic:

1012 self.result_ctype = py_object_type

1013

1014 def analyse_types(self, env):

1015 if self.entry is None:

1016 self.entry = env.lookup(self.name)

1017 if not self.entry:

1018 self.entry = env.declare_builtin(self.name, self.pos)

1019 if not self.entry:

1020 self.type = PyrexTypes.error_type

1021 return

1022 self.analyse_rvalue_entry(env)

1023

1024 def analyse_target_types(self, env):

1025 self.analyse_entry(env)

1026 if not self.is_lvalue():

1027 error(self.pos, "Assignment to non-lvalue '%s'"

1028 % self.name)

1029 self.type = PyrexTypes.error_type

1030 self.entry.used = 1

1031 if self.entry.type.is_buffer:

1032 import Buffer

1033 Buffer.used_buffer_aux_vars(self.entry)

1034

1035 def analyse_rvalue_entry(self, env):

1036 #print "NameNode.analyse_rvalue_entry:", self.name ###

1037 #print "Entry:", self.entry.__dict__ ###

1038 self.analyse_entry(env)

1039 entry = self.entry

1040 if entry.is_declared_generic:

1041 self.result_ctype = py_object_type

1042 if entry.is_pyglobal or entry.is_builtin:

1043 if Options.cache_builtins and entry.is_builtin:

1044 self.is_temp = 0

1045 else:

1046 self.is_temp = 1

1047 env.use_utility_code(get_name_interned_utility_code)

1048 self.gil_check(env)

1049

1050 gil_message = "Accessing Python global or builtin"

1051

1052 def analyse_entry(self, env):

1053 #print "NameNode.analyse_entry:", self.name ###

1054 self.check_identifier_kind()

1055 entry = self.entry

1056 type = entry.type

1057 self.type = type

1058 if entry.is_pyglobal or entry.is_builtin:

1059 assert type.is_pyobject, "Python global or builtin not a Python object"

1060 self.interned_cname = self.entry.interned_cname = \

1061 env.intern_identifier(self.entry.name)

1062

1063 def check_identifier_kind(self):

1064 #print "NameNode.check_identifier_kind:", self.entry.name ###

1065 #print self.entry.__dict__ ###

1066 entry = self.entry

1067 #entry.used = 1

1068 if not (entry.is_const or entry.is_variable

1069 or entry.is_builtin or entry.is_cfunction):

1070 if self.entry.as_variable:

1071 self.entry = self.entry.as_variable

1072 else:

1073 error(self.pos,

1074 "'%s' is not a constant, variable or function identifier" % self.name)

1075

1076 def is_simple(self):

1077 # If it's not a C variable, it'll be in a temp.

1078 return 1

1079

1080 def calculate_target_results(self, env):

1081 pass

1082

1083 def check_const(self):

1084 entry = self.entry

1085 if entry is not None and not (entry.is_const or entry.is_cfunction or entry.is_builtin):

1086 self.not_const()

1087

1088 def check_const_addr(self):

1089 entry = self.entry

1090 if not (entry.is_cglobal or entry.is_cfunction or entry.is_builtin):

1091 self.addr_not_const()

1092

1093 def is_lvalue(self):

1094 return self.entry.is_variable and \

1095 not self.entry.type.is_array and \

1096 not self.entry.is_readonly

1097

1098 def is_ephemeral(self):

1099 # Name nodes are never ephemeral, even if the

1100 # result is in a temporary.

1101 return 0

1102

1103 def allocate_temp(self, env, result = None):

1104 AtomicExprNode.allocate_temp(self, env, result)

1105 entry = self.entry

1106 if entry:

1107 entry.used = 1

1108 if entry.type.is_buffer:

1109 import Buffer

1110 Buffer.used_buffer_aux_vars(entry)

1111 if entry.utility_code:

1112 env.use_utility_code(entry.utility_code)

1113

1114 def calculate_result_code(self):

1115 entry = self.entry

1116 if not entry:

1117 return "<error>" # There was an error earlier

1118 return entry.cname

1119

1120 def generate_result_code(self, code):

1121 assert hasattr(self, 'entry')

1122 entry = self.entry

1123 if entry is None:

1124 return # There was an error earlier

1125 if entry.is_builtin and Options.cache_builtins:

1126 return # Lookup already cached

1127 elif entry.is_pyglobal or entry.is_builtin:

1128 if entry.is_builtin:

1129 namespace = Naming.builtins_cname

1130 else: # entry.is_pyglobal

1131 namespace = entry.scope.namespace_cname

1132 code.putln(

1133 '%s = __Pyx_GetName(%s, %s); %s' % (

1134 self.result(),

1135 namespace,

1136 self.interned_cname,

1137 code.error_goto_if_null(self.result(), self.pos)))

1138 elif entry.is_local and False:

1139 # control flow not good enough yet

1140 assigned = entry.scope.control_flow.get_state((entry.name, 'initalized'), self.pos)

1141 if assigned is False:

1142 error(self.pos, "local variable '%s' referenced before assignment" % entry.name)

1143 elif not Options.init_local_none and assigned is None:

1144 code.putln('if (%s == 0) { PyErr_SetString(PyExc_UnboundLocalError, "%s"); %s }' % (entry.cname, entry.name, code.error_goto(self.pos)))

1145 entry.scope.control_flow.set_state(self.pos, (entry.name, 'initalized'), True)

1146

1147 def generate_assignment_code(self, rhs, code):

1148 #print "NameNode.generate_assignment_code:", self.name ###

1149 entry = self.entry

1150 if entry is None:

1151 return # There was an error earlier

1152

1153 # is_pyglobal seems to be True for module level-globals only.

1154 # We use this to access class->tp_dict if necessary.

1155 if entry.is_pyglobal:

1156 namespace = self.entry.scope.namespace_cname

1157 if entry.is_member:

1158 # if the entry is a member we have to cheat: SetAttr does not work

1159 # on types, so we create a descriptor which is then added to tp_dict

1160 code.put_error_if_neg(self.pos,

1161 'PyDict_SetItem(%s->tp_dict, %s, %s)' % (

1162 namespace,

1163 self.interned_cname,

1164 rhs.py_result()))

1165 # in Py2.6+, we need to invalidate the method cache

1166 code.putln("PyType_Modified(%s);" %

1167 entry.scope.parent_type.typeptr_cname)

1168 else:

1169 code.put_error_if_neg(self.pos,

1170 'PyObject_SetAttr(%s, %s, %s)' % (

1171 namespace,

1172 self.interned_cname,

1173 rhs.py_result()))

1174 if debug_disposal_code:

1175 print("NameNode.generate_assignment_code:")

1176 print("...generating disposal code for %s" % rhs)

1177 rhs.generate_disposal_code(code)

1178

1179 else:

1180 if self.type.is_buffer:

1181 # Generate code for doing the buffer release/acquisition.

1182 # This might raise an exception in which case the assignment (done

1183 # below) will not happen.

1184 #

1185 # The reason this is not in a typetest-like node is because the

1186 # variables that the acquired buffer info is stored to is allocated

1187 # per entry and coupled with it.

1188 self.generate_acquire_buffer(rhs, code)

1189

1190 if self.type.is_pyobject:

1191 rhs.make_owned_reference(code)

1192 #print "NameNode.generate_assignment_code: to", self.name ###

1193 #print "...from", rhs ###

1194 #print "...LHS type", self.type, "ctype", self.ctype() ###

1195 #print "...RHS type", rhs.type, "ctype", rhs.ctype() ###

1196 if not self.skip_assignment_decref:

1197 if entry.is_local and not Options.init_local_none:

1198 initalized = entry.scope.control_flow.get_state((entry.name, 'initalized'), self.pos)

1199 if initalized is True:

1200 code.put_decref(self.result(), self.ctype())

1201 elif initalized is None:

1202 code.put_xdecref(self.result(), self.ctype())

1203 else:

1204 code.put_decref(self.result(), self.ctype())

1205 code.putln('%s = %s;' % (self.result(), rhs.result_as(self.ctype())))

1206 if debug_disposal_code:

1207 print("NameNode.generate_assignment_code:")

1208 print("...generating post-assignment code for %s" % rhs)

1209 rhs.generate_post_assignment_code(code)

1210

1211 def generate_acquire_buffer(self, rhs, code):

1212 rhstmp = code.funcstate.allocate_temp(self.entry.type)

1213 buffer_aux = self.entry.buffer_aux

1214 bufstruct = buffer_aux.buffer_info_var.cname

1215 code.putln('%s = %s;' % (rhstmp, rhs.result_as(self.ctype())))

1216

1217 import Buffer

1218 Buffer.put_assign_to_buffer(self.result(), rhstmp, buffer_aux, self.entry.type,

1219 is_initialized=not self.skip_assignment_decref,

1220 pos=self.pos, code=code)

1221 code.putln("%s = 0;" % rhstmp)

1222 code.funcstate.release_temp(rhstmp)

1223

1224 def generate_deletion_code(self, code):

1225 if self.entry is None:

1226 return # There was an error earlier

1227 if not self.entry.is_pyglobal:

1228 error(self.pos, "Deletion of local or C global name not supported")

1229 return

1230 code.put_error_if_neg(self.pos,

1231 'PyObject_DelAttrString(%s, "%s")' % (

1232 Naming.module_cname,

1233 self.entry.name))

1234

1235 def annotate(self, code):

1236 if hasattr(self, 'is_called') and self.is_called:

1237 pos = (self.pos[0], self.pos[1], self.pos[2] - len(self.name) - 1)

1238 if self.type.is_pyobject:

1239 code.annotate(pos, AnnotationItem('py_call', 'python function', size=len(self.name)))

1240 else:

1241 code.annotate(pos, AnnotationItem('c_call', 'c function', size=len(self.name)))

1242

1243 class BackquoteNode(ExprNode):

1244 # `expr`

1245 #

1246 # arg ExprNode

1247

1248 subexprs = ['arg']

1249

1250 def analyse_types(self, env):

1251 self.arg.analyse_types(env)

1252 self.arg = self.arg.coerce_to_pyobject(env)

1253 self.type = py_object_type

1254 self.gil_check(env)

1255 self.is_temp = 1

1256

1257 gil_message = "Backquote expression"

1258

1259 def generate_result_code(self, code):

1260 code.putln(

1261 "%s = PyObject_Repr(%s); %s" % (

1262 self.result(),

1263 self.arg.py_result(),

1264 code.error_goto_if_null(self.result(), self.pos)))

1265

1266

1267 class ImportNode(ExprNode):

1268 # Used as part of import statement implementation.

1269 # Implements result =

1270 # __import__(module_name, globals(), None, name_list)

1271 #

1272 # module_name IdentifierStringNode dotted name of module

1273 # name_list ListNode or None list of names to be imported

1274

1275 subexprs = ['module_name', 'name_list']

1276

1277 def analyse_types(self, env):

1278 self.module_name.analyse_types(env)

1279 self.module_name = self.module_name.coerce_to_pyobject(env)

1280 if self.name_list:

1281 self.name_list.analyse_types(env)

1282 self.name_list.coerce_to_pyobject(env)

1283 self.type = py_object_type

1284 self.gil_check(env)

1285 self.is_temp = 1

1286 env.use_utility_code(import_utility_code)

1287

1288 gil_message = "Python import"

1289

1290 def generate_result_code(self, code):

1291 if self.name_list:

1292 name_list_code = self.name_list.py_result()

1293 else:

1294 name_list_code = "0"

1295 code.putln(

1296 "%s = __Pyx_Import(%s, %s); %s" % (

1297 self.result(),

1298 self.module_name.py_result(),

1299 name_list_code,

1300 code.error_goto_if_null(self.result(), self.pos)))

1301

1302

1303 class IteratorNode(ExprNode):

1304 # Used as part of for statement implementation.

1305 # Implements result = iter(sequence)

1306 #

1307 # sequence ExprNode

1308

1309 subexprs = ['sequence']

1310

1311 def analyse_types(self, env):

1312 self.sequence.analyse_types(env)

1313 self.sequence = self.sequence.coerce_to_pyobject(env)

1314 self.type = py_object_type

1315 self.gil_check(env)

1316 self.is_temp = 1

1317

1318 self.counter = TempNode(self.pos, PyrexTypes.c_py_ssize_t_type, env)

1319 self.counter.allocate_temp(env)

1320

1321 gil_message = "Iterating over Python object"

1322

1323 def release_temp(self, env):

1324 env.release_temp(self.result())

1325 self.counter.release_temp(env)

1326

1327 def generate_result_code(self, code):

1328 code.putln(

1329 "if (PyList_CheckExact(%s) || PyTuple_CheckExact(%s)) {" % (

1330 self.sequence.py_result(),

1331 self.sequence.py_result()))

1332 code.putln(

1333 "%s = 0; %s = %s; Py_INCREF(%s);" % (

1334 self.counter.result(),

1335 self.result(),

1336 self.sequence.py_result(),

1337 self.result()))

1338 code.putln("} else {")

1339 code.putln("%s = -1; %s = PyObject_GetIter(%s); %s" % (

1340 self.counter.result(),

1341 self.result(),

1342 self.sequence.py_result(),

1343 code.error_goto_if_null(self.result(), self.pos)))

1344 code.putln("}")

1345

1346

1347 class NextNode(AtomicExprNode):

1348 # Used as part of for statement implementation.

1349 # Implements result = iterator.next()

1350 # Created during analyse_types phase.

1351 # The iterator is not owned by this node.

1352 #

1353 # iterator ExprNode

1354

1355 def __init__(self, iterator, env):

1356 self.pos = iterator.pos

1357 self.iterator = iterator

1358 self.type = py_object_type

1359 self.is_temp = 1

1360

1361 def generate_result_code(self, code):

1362 for py_type in ["List", "Tuple"]:

1363 code.putln(

1364 "if (likely(Py%s_CheckExact(%s))) {" % (py_type, self.iterator.py_result()))

1365 code.putln(

1366 "if (%s >= Py%s_GET_SIZE(%s)) break;" % (

1367 self.iterator.counter.result(),

1368 py_type,

1369 self.iterator.py_result()))

1370 code.putln(

1371 "%s = Py%s_GET_ITEM(%s, %s); Py_INCREF(%s); %s++;" % (

1372 self.result(),

1373 py_type,

1374 self.iterator.py_result(),

1375 self.iterator.counter.result(),

1376 self.result(),

1377 self.iterator.counter.result()))

1378 code.put("} else ")

1379 code.putln("{")

1380 code.putln(

1381 "%s = PyIter_Next(%s);" % (

1382 self.result(),

1383 self.iterator.py_result()))

1384 code.putln(

1385 "if (!%s) {" %

1386 self.result())

1387 code.putln(code.error_goto_if_PyErr(self.pos))

1388 code.putln("break;")

1389 code.putln("}")

1390 code.putln("}")

1391

1392

1393 class ExcValueNode(AtomicExprNode):

1394 # Node created during analyse_types phase

1395 # of an ExceptClauseNode to fetch the current

1396 # exception value.

1397

1398 def __init__(self, pos, env, var):

1399 ExprNode.__init__(self, pos)

1400 self.type = py_object_type

1401 self.var = var

1402

1403 def calculate_result_code(self):

1404 return self.var

1405

1406 def generate_result_code(self, code):

1407 pass

1408

1409 def analyse_types(self, env):

1410 pass

1411

1412

1413 class TempNode(AtomicExprNode):

1414 # Node created during analyse_types phase

1415 # of some nodes to hold a temporary value.

1416

1417 def __init__(self, pos, type, env):

1418 ExprNode.__init__(self, pos)

1419 self.type = type

1420 if type.is_pyobject:

1421 self.result_ctype = py_object_type

1422 self.is_temp = 1

1423

1424 def analyse_types(self, env):

1425 return self.type

1426

1427 def generate_result_code(self, code):

1428 pass

1429

1430

1431 class PyTempNode(TempNode):

1432 # TempNode holding a Python value.

1433

1434 def __init__(self, pos, env):

1435 TempNode.__init__(self, pos, PyrexTypes.py_object_type, env)

1436

1437

1438 #-------------------------------------------------------------------

1439 #

1440 # Trailer nodes

1441 #

1442 #-------------------------------------------------------------------

1443

1444 class IndexNode(ExprNode):

1445 # Sequence indexing.

1446 #

1447 # base ExprNode

1448 # index ExprNode

1449 # indices [ExprNode]

1450 # is_buffer_access boolean Whether this is a buffer access.

1451 #

1452 # indices is used on buffer access, index on non-buffer access.

1453 # The former contains a clean list of index parameters, the

1454 # latter whatever Python object is needed for index access.

1455

1456 subexprs = ['base', 'index', 'indices']

1457 indices = None

1458

1459 def __init__(self, pos, index, *args, **kw):

1460 ExprNode.__init__(self, pos, index=index, *args, **kw)

1461 self._index = index

1462

1463 def compile_time_value(self, denv):

1464 base = self.base.compile_time_value(denv)

1465 index = self.index.compile_time_value(denv)

1466 try:

1467 return base[index]

1468 except Exception, e:

1469 self.compile_time_value_error(e)

1470

1471 def is_ephemeral(self):

1472 return self.base.is_ephemeral()

1473

1474 def analyse_target_declaration(self, env):

1475 pass

1476

1477 def analyse_as_type(self, env):

1478 base_type = self.base.analyse_as_type(env)

1479 if base_type and not base_type.is_pyobject:

1480 return PyrexTypes.CArrayType(base_type, int(self.index.compile_time_value(env)))

1481 return None

1482

1483 def analyse_types(self, env):

1484 self.analyse_base_and_index_types(env, getting = 1)

1485

1486 def analyse_target_types(self, env):

1487 self.analyse_base_and_index_types(env, setting = 1)

1488

1489 def analyse_base_and_index_types(self, env, getting = 0, setting = 0):

1490 # Note: This might be cleaned up by having IndexNode

1491 # parsed in a saner way and only construct the tuple if

1492 # needed.

1493

1494 # Note that this function must leave IndexNode in a cloneable state.

1495 # For buffers, self.index is packed out on the initial analysis, and

1496 # when cloning self.indices is copied.

1497 self.is_buffer_access = False

1498

1499 self.base.analyse_types(env)

1500 # Handle the case where base is a literal char* (and we expect a string, not an int)

1501 if isinstance(self.base, StringNode):

1502 self.base = self.base.coerce_to_pyobject(env)

1503

1504 skip_child_analysis = False

1505 buffer_access = False

1506 if self.base.type.is_buffer:

1507 assert hasattr(self.base, "entry") # Must be a NameNode-like node

1508 if self.indices:

1509 indices = self.indices

1510 else:

1511 # On cloning, indices is cloned. Otherwise, unpack index into indices

1512 assert not isinstance(self.index, CloneNode)

1513 if isinstance(self.index, TupleNode):

1514 indices = self.index.args

1515 else:

1516 indices = [self.index]

1517 if len(indices) == self.base.type.ndim:

1518 buffer_access = True

1519 skip_child_analysis = True

1520 for x in indices:

1521 x.analyse_types(env)

1522 if not x.type.is_int:

1523 buffer_access = False

1524

1525 if buffer_access:

1526 self.indices = indices

1527 self.index = None

1528 self.type = self.base.type.dtype

1529 self.is_buffer_access = True

1530 self.buffer_type = self.base.entry.type

1531

1532 if getting and self.type.is_pyobject:

1533 self.is_temp = True

1534 if setting:

1535 if not self.base.entry.type.writable:

1536 error(self.pos, "Writing to readonly buffer")

1537 else:

1538 self.base.entry.buffer_aux.writable_needed = True

1539 else:

1540 if isinstance(self.index, TupleNode):

1541 self.index.analyse_types(env, skip_children=skip_child_analysis)

1542 elif not skip_child_analysis:

1543 self.index.analyse_types(env)

1544 if self.base.type.is_pyobject:

1545 if self.index.type.is_int and not self.index.type.is_longlong:

1546 self.original_index_type = self.index.type

1547 self.index = self.index.coerce_to(PyrexTypes.c_py_ssize_t_type, env).coerce_to_simple(env)

1548 if getting:

1549 env.use_utility_code(getitem_int_utility_code)

1550 if setting:

1551 env.use_utility_code(setitem_int_utility_code)

1552 else:

1553 self.index = self.index.coerce_to_pyobject(env)

1554 self.type = py_object_type

1555 self.gil_check(env)

1556 self.is_temp = 1

1557 else:

1558 if self.base.type.is_ptr or self.base.type.is_array:

1559 self.type = self.base.type.base_type

1560 else:

1561 error(self.pos,

1562 "Attempting to index non-array type '%s'" %

1563 self.base.type)

1564 self.type = PyrexTypes.error_type

1565 if self.index.type.is_pyobject:

1566 self.index = self.index.coerce_to(

1567 PyrexTypes.c_py_ssize_t_type, env)

1568 if not self.index.type.is_int:

1569 error(self.pos,

1570 "Invalid index type '%s'" %

1571 self.index.type)

1572

1573 gil_message = "Indexing Python object"

1574

1575 def check_const_addr(self):

1576 self.base.check_const_addr()

1577 self.index.check_const()

1578

1579 def is_lvalue(self):

1580 return 1

1581

1582 def calculate_result_code(self):

1583 if self.is_buffer_access:

1584 return "(*%s)" % self.buffer_ptr_code

1585 else:

1586 return "(%s[%s])" % (

1587 self.base.result(), self.index.result())

1588

1589 def index_unsigned_parameter(self):

1590 if self.index.type.is_int:

1591 if self.original_index_type.signed:

1592 return ", 0"

1593 else:

1594 return ", sizeof(Py_ssize_t) <= sizeof(%s)" % self.original_index_type.declaration_code("")

1595 else:

1596 return ""

1597

1598 def generate_subexpr_evaluation_code(self, code):

1599 self.base.generate_evaluation_code(code)

1600 if not self.indices:

1601 self.index.generate_evaluation_code(code)

1602 else:

1603 for i in self.indices:

1604 i.generate_evaluation_code(code)

1605

1606 def generate_subexpr_disposal_code(self, code):

1607 self.base.generate_disposal_code(code)

1608 if not self.indices:

1609 self.index.generate_disposal_code(code)

1610 else:

1611 for i in self.indices:

1612 i.generate_disposal_code(code)

1613

1614 def generate_result_code(self, code):

1615 if self.is_buffer_access:

1616 if code.globalstate.directives['nonecheck']:

1617 self.put_nonecheck(code)

1618 self.buffer_ptr_code = self.buffer_lookup_code(code)

1619 if self.type.is_pyobject:

1620 # is_temp is True, so must pull out value and incref it.

1621 code.putln("%s = *%s;" % (self.result(), self.buffer_ptr_code))

1622 code.putln("Py_INCREF((PyObject*)%s);" % self.result())

1623 elif self.type.is_pyobject:

1624 if self.index.type.is_int:

1625 function = "__Pyx_GetItemInt"

1626 index_code = self.index.result()

1627 else:

1628 function = "PyObject_GetItem"

1629 index_code = self.index.py_result()

1630 sign_code = ""

1631 code.putln(

1632 "%s = %s(%s, %s%s); if (!%s) %s" % (

1633 self.result(),

1634 function,

1635 self.base.py_result(),

1636 index_code,

1637 self.index_unsigned_parameter(),

1638 self.result(),

1639 code.error_goto(self.pos)))

1640

1641 def generate_setitem_code(self, value_code, code):

1642 if self.index.type.is_int:

1643 function = "__Pyx_SetItemInt"

1644 index_code = self.index.result()

1645 else:

1646 function = "PyObject_SetItem"

1647 index_code = self.index.py_result()

1648 code.putln(

1649 "if (%s(%s, %s, %s%s) < 0) %s" % (

1650 function,

1651 self.base.py_result(),

1652 index_code,

1653 value_code,

1654 self.index_unsigned_parameter(),

1655 code.error_goto(self.pos)))

1656

1657 def generate_buffer_setitem_code(self, rhs, code, op=""):

1658 # Used from generate_assignment_code and InPlaceAssignmentNode

1659 if code.globalstate.directives['nonecheck']:

1660 self.put_nonecheck(code)

1661 ptrexpr = self.buffer_lookup_code(code)

1662 if self.buffer_type.dtype.is_pyobject:

1663 # Must manage refcounts. Decref what is already there

1664 # and incref what we put in.

1665 ptr = code.funcstate.allocate_temp(self.buffer_type.buffer_ptr_type)

1666 if rhs.is_temp:

1667 rhs_code = code.funcstate.allocate_temp(rhs.type)

1668 else:

1669 rhs_code = rhs.result()

1670 code.putln("%s = %s;" % (ptr, ptrexpr))

1671 code.putln("Py_DECREF(*%s); Py_INCREF(%s);" % (

1672 ptr, rhs_code

1673 ))

1674 code.putln("*%s %s= %s;" % (ptr, op, rhs_code))

1675 if rhs.is_temp:

1676 code.funcstate.release_temp(rhs_code)

1677 code.funcstate.release_temp(ptr)

1678 else:

1679 # Simple case

1680 code.putln("*%s %s= %s;" % (ptrexpr, op, rhs.result()))

1681

1682 def generate_assignment_code(self, rhs, code):

1683 self.generate_subexpr_evaluation_code(code)

1684 if self.is_buffer_access:

1685 self.generate_buffer_setitem_code(rhs, code)

1686 elif self.type.is_pyobject:

1687 self.generate_setitem_code(rhs.py_result(), code)

1688 else:

1689 code.putln(

1690 "%s = %s;" % (

1691 self.result(), rhs.result()))

1692 self.generate_subexpr_disposal_code(code)

1693 rhs.generate_disposal_code(code)

1694

1695 def generate_deletion_code(self, code):

1696 self.generate_subexpr_evaluation_code(code)

1697 #if self.type.is_pyobject:

1698 if self.index.type.is_int:

1699 function = "PySequence_DelItem"

1700 index_code = self.index.result()

1701 else:

1702 function = "PyObject_DelItem"

1703 index_code = self.index.py_result()

1704 code.putln(

1705 "if (%s(%s, %s) < 0) %s" % (

1706 function,

1707 self.base.py_result(),

1708 index_code,

1709 code.error_goto(self.pos)))

1710 self.generate_subexpr_disposal_code(code)

1711

1712 def buffer_lookup_code(self, code):

1713 # Assign indices to temps

1714 index_temps = [code.funcstate.allocate_temp(i.type) for i in self.indices]

1715 for temp, index in zip(index_temps, self.indices):

1716 code.putln("%s = %s;" % (temp, index.result()))

1717 # Generate buffer access code using these temps

1718 import Buffer

1719 # The above could happen because child_attrs is wrong somewhere so that

1720 # options are not propagated.

1721 return Buffer.put_buffer_lookup_code(entry=self.base.entry,

1722 index_signeds=[i.type.signed for i in self.indices],

1723 index_cnames=index_temps,

1724 options=code.globalstate.directives,

1725 pos=self.pos, code=code)

1726

1727 def put_nonecheck(self, code):

1728 code.globalstate.use_utility_code(raise_noneindex_error_utility_code)

1729 code.putln("if (%s) {" % code.unlikely("%s == Py_None") % self.base.result_as(PyrexTypes.py_object_type))

1730 code.putln("__Pyx_RaiseNoneIndexingError();")

1731 code.putln(code.error_goto(self.pos))

1732 code.putln("}")

1733

1734 class SliceIndexNode(ExprNode):

1735 # 2-element slice indexing

1736 #

1737 # base ExprNode

1738 # start ExprNode or None

1739 # stop ExprNode or None

1740

1741 subexprs = ['base', 'start', 'stop']

1742

1743 def compile_time_value(self, denv):

1744 base = self.base.compile_time_value(denv)

1745 start = self.start.compile_time_value(denv)

1746 stop = self.stop.compile_time_value(denv)

1747 try:

1748 return base[start:stop]

1749 except Exception, e:

1750 self.compile_time_value_error(e)

1751

1752 def analyse_target_declaration(self, env):

1753 pass

1754

1755 def analyse_types(self, env):

1756 self.base.analyse_types(env)

1757 if self.start:

1758 self.start.analyse_types(env)

1759 if self.stop:

1760 self.stop.analyse_types(env)

1761 self.base = self.base.coerce_to_pyobject(env)

1762 c_int = PyrexTypes.c_py_ssize_t_type

1763 if self.start:

1764 self.start = self.start.coerce_to(c_int, env)

1765 if self.stop:

1766 self.stop = self.stop.coerce_to(c_int, env)

1767 self.type = py_object_type

1768 self.gil_check(env)

1769 self.is_temp = 1

1770

1771 gil_message = "Slicing Python object"

1772

1773 def generate_result_code(self, code):

1774 code.putln(

1775 "%s = PySequence_GetSlice(%s, %s, %s); %s" % (

1776 self.result(),

1777 self.base.py_result(),

1778 self.start_code(),

1779 self.stop_code(),

1780 code.error_goto_if_null(self.result(), self.pos)))

1781

1782 def generate_assignment_code(self, rhs, code):

1783 self.generate_subexpr_evaluation_code(code)

1784 code.put_error_if_neg(self.pos,

1785 "PySequence_SetSlice(%s, %s, %s, %s)" % (

1786 self.base.py_result(),

1787 self.start_code(),

1788 self.stop_code(),

1789 rhs.result()))

1790 self.generate_subexpr_disposal_code(code)

1791 rhs.generate_disposal_code(code)

1792

1793 def generate_deletion_code(self, code):

1794 self.generate_subexpr_evaluation_code(code)

1795 code.put_error_if_neg(self.pos,

1796 "PySequence_DelSlice(%s, %s, %s)" % (

1797 self.base.py_result(),

1798 self.start_code(),

1799 self.stop_code()))

1800 self.generate_subexpr_disposal_code(code)

1801

1802 def start_code(self):

1803 if self.start:

1804 return self.start.result()

1805 else:

1806 return "0"

1807

1808 def stop_code(self):

1809 if self.stop:

1810 return self.stop.result()

1811 else:

1812 return "PY_SSIZE_T_MAX"

1813

1814 def calculate_result_code(self):

1815 # self.result() is not used, but this method must exist

1816 return "<unused>"

1817

1818

1819 class SliceNode(ExprNode):

1820 # start:stop:step in subscript list

1821 #

1822 # start ExprNode

1823 # stop ExprNode

1824 # step ExprNode

1825

1826 def compile_time_value(self, denv):

1827 start = self.start.compile_time_value(denv)

1828 stop = self.stop.compile_time_value(denv)

1829 step = step.step.compile_time_value(denv)

1830 try:

1831 return slice(start, stop, step)

1832 except Exception, e:

1833 self.compile_time_value_error(e)

1834

1835 subexprs = ['start', 'stop', 'step']

1836

1837 def analyse_types(self, env):

1838 self.start.analyse_types(env)

1839 self.stop.analyse_types(env)

1840 self.step.analyse_types(env)

1841 self.start = self.start.coerce_to_pyobject(env)

1842 self.stop = self.stop.coerce_to_pyobject(env)

1843 self.step = self.step.coerce_to_pyobject(env)

1844 self.type = py_object_type

1845 self.gil_check(env)

1846 self.is_temp = 1

1847

1848 gil_message = "Constructing Python slice object"

1849

1850 def generate_result_code(self, code):

1851 code.putln(

1852 "%s = PySlice_New(%s, %s, %s); %s" % (

1853 self.result(),

1854 self.start.py_result(),

1855 self.stop.py_result(),

1856 self.step.py_result(),

1857 code.error_goto_if_null(self.result(), self.pos)))

1858

1859

1860 class CallNode(ExprNode):

1861 def gil_check(self, env):

1862 # Make sure we're not in a nogil environment

1863 if env.nogil:

1864 error(self.pos, "Calling gil-requiring function without gil")

1865

1866

1867 class SimpleCallNode(CallNode):

1868 # Function call without keyword, * or ** args.

1869 #

1870 # function ExprNode

1871 # args [ExprNode]

1872 # arg_tuple ExprNode or None used internally

1873 # self ExprNode or None used internally

1874 # coerced_self ExprNode or None used internally

1875 # wrapper_call bool used internally

1876 # has_optional_args bool used internally

1877

1878 subexprs = ['self', 'coerced_self', 'function', 'args', 'arg_tuple']

1879

1880 self = None

1881 coerced_self = None

1882 arg_tuple = None

1883 wrapper_call = False

1884 has_optional_args = False

1885

1886 def compile_time_value(self, denv):

1887 function = self.function.compile_time_value(denv)

1888 args = [arg.compile_time_value(denv) for arg in self.args]

1889 try:

1890 return function(*args)

1891 except Exception, e:

1892 self.compile_time_value_error(e)

1893

1894 def analyse_as_type(self, env):

1895 attr = self.function.magic_cython_method()

1896 if attr == 'pointer':

1897 if len(self.args) != 1:

1898 error(self.args.pos, "only one type allowed.")

1899 else:

1900 type = self.args[0].analyse_as_type(env)

1901 if not type:

1902 error(self.args[0].pos, "Unknown type")

1903 else:

1904 return PyrexTypes.CPtrType(type)

1905

1906 def explicit_args_kwds(self):

1907 return self.args, None

1908

1909 def analyse_types(self, env):

1910 function = self.function

1911 function.is_called = 1

1912 self.function.analyse_types(env)

1913 if function.is_attribute and function.is_py_attr and \

1914 function.attribute == "append" and len(self.args) == 1:

1915 # L.append(x) is almost always applied to a list

1916 self.py_func = self.function

1917 self.function = NameNode(pos=self.function.pos, name="__Pyx_PyObject_Append")

1918 self.function.analyse_types(env)

1919 self.self = self.py_func.obj

1920 function.obj = CloneNode(self.self)

1921 env.use_utility_code(append_utility_code)

1922 if function.is_attribute and function.entry and function.entry.is_cmethod:

1923 # Take ownership of the object from which the attribute

1924 # was obtained, because we need to pass it as 'self'.

1925 self.self = function.obj

1926 function.obj = CloneNode(self.self)

1927 func_type = self.function_type()

1928 if func_type.is_pyobject:

1929 self.arg_tuple = TupleNode(self.pos, args = self.args)

1930 self.arg_tuple.analyse_types(env)

1931 self.args = None

1932 self.type = py_object_type

1933 self.gil_check(env)

1934 self.is_temp = 1

1935 else:

1936 for arg in self.args:

1937 arg.analyse_types(env)

1938 if self.self and func_type.args:

1939 # Coerce 'self' to the type expected by the method.

1940 expected_type = func_type.args[0].type

1941 self.coerced_self = CloneNode(self.self).coerce_to(

1942 expected_type, env)

1943 # Insert coerced 'self' argument into argument list.

1944 self.args.insert(0, self.coerced_self)

1945 self.analyse_c_function_call(env)

1946

1947 def function_type(self):

1948 # Return the type of the function being called, coercing a function

1949 # pointer to a function if necessary.

1950 func_type = self.function.type

1951 if func_type.is_ptr:

1952 func_type = func_type.base_type

1953 return func_type

1954

1955 def analyse_c_function_call(self, env):

1956 func_type = self.function_type()

1957 # Check function type

1958 if not func_type.is_cfunction:

1959 if not func_type.is_error:

1960 error(self.pos, "Calling non-function type '%s'" %

1961 func_type)

1962 self.type = PyrexTypes.error_type

1963 self.result_code = "<error>"

1964 return

1965 # Check no. of args

1966 max_nargs = len(func_type.args)

1967 expected_nargs = max_nargs - func_type.optional_arg_count

1968 actual_nargs = len(self.args)

1969 if actual_nargs < expected_nargs \

1970 or (not func_type.has_varargs and actual_nargs > max_nargs):

1971 expected_str = str(expected_nargs)

1972 if func_type.has_varargs:

1973 expected_str = "at least " + expected_str

1974 elif func_type.optional_arg_count:

1975 if actual_nargs < max_nargs:

1976 expected_str = "at least " + expected_str

1977 else:

1978 expected_str = "at most " + str(max_nargs)

1979 error(self.pos,

1980 "Call with wrong number of arguments (expected %s, got %s)"

1981 % (expected_str, actual_nargs))

1982 self.args = None

1983 self.type = PyrexTypes.error_type

1984 self.result_code = "<error>"

1985 return

1986 if func_type.optional_arg_count and expected_nargs != actual_nargs:

1987 self.has_optional_args = 1

1988 self.is_temp = 1

1989 self.opt_arg_struct = env.allocate_temp(func_type.op_arg_struct.base_type)

1990 env.release_temp(self.opt_arg_struct)

1991 # Coerce arguments

1992 for i in range(min(max_nargs, actual_nargs)):

1993 formal_type = func_type.args[i].type

1994 self.args[i] = self.args[i].coerce_to(formal_type, env)

1995 for i in range(max_nargs, actual_nargs):

1996 if self.args[i].type.is_pyobject:

1997 error(self.args[i].pos,

1998 "Python object cannot be passed as a varargs parameter")

1999 # Calc result type and code fragment

2000 self.type = func_type.return_type

2001 if self.type.is_pyobject \

2002 or func_type.exception_value is not None \

2003 or func_type.exception_check:

2004 self.is_temp = 1

2005 if self.type.is_pyobject:

2006 self.result_ctype = py_object_type

2007 # C++ exception handler

2008 if func_type.exception_check == '+':

2009 if func_type.exception_value is None:

2010 env.use_utility_code(cpp_exception_utility_code)

2011 # Check gil

2012 if not func_type.nogil:

2013 self.gil_check(env)

2014

2015 def calculate_result_code(self):

2016 return self.c_call_code()

2017

2018 def c_call_code(self):

2019 func_type = self.function_type()

2020 if self.args is None or not func_type.is_cfunction:

2021 return "<error>"

2022 formal_args = func_type.args

2023 arg_list_code = []

2024 args = zip(formal_args, self.args)

2025 max_nargs = len(func_type.args)

2026 expected_nargs = max_nargs - func_type.optional_arg_count

2027 actual_nargs = len(self.args)

2028 for formal_arg, actual_arg in args[:expected_nargs]:

2029 arg_code = actual_arg.result_as(formal_arg.type)

2030 arg_list_code.append(arg_code)

2031

2032 if func_type.is_overridable:

2033 arg_list_code.append(str(int(self.wrapper_call or self.function.entry.is_unbound_cmethod)))

2034

2035 if func_type.optional_arg_count:

2036 if expected_nargs == actual_nargs:

2037 optional_args = 'NULL'

2038 else:

2039 optional_args = "&%s" % self.opt_arg_struct

2040 arg_list_code.append(optional_args)

2041

2042 for actual_arg in self.args[len(formal_args):]:

2043 arg_list_code.append(actual_arg.result())

2044 result = "%s(%s)" % (self.function.result(),

2045 join(arg_list_code, ", "))

2046 # if self.wrapper_call or \

2047 # self.function.entry.is_unbound_cmethod and self.function.entry.type.is_overridable:

2048 # result = "(%s = 1, %s)" % (Naming.skip_dispatch_cname, result)

2049 return result

2050

2051 def generate_result_code(self, code):

2052 func_type = self.function_type()

2053 if func_type.is_pyobject:

2054 arg_code = self.arg_tuple.py_result()

2055 code.putln(

2056 "%s = PyObject_Call(%s, %s, NULL); %s" % (

2057 self.result(),

2058 self.function.py_result(),

2059 arg_code,

2060 code.error_goto_if_null(self.result(), self.pos)))

2061 elif func_type.is_cfunction:

2062 if self.has_optional_args:

2063 actual_nargs = len(self.args)

2064 expected_nargs = len(func_type.args) - func_type.optional_arg_count

2065 code.putln("%s.%s = %s;" % (

2066 self.opt_arg_struct,

2067 Naming.pyrex_prefix + "n",

2068 len(self.args) - expected_nargs))

2069 args = zip(func_type.args, self.args)

2070 for formal_arg, actual_arg in args[expected_nargs:actual_nargs]:

2071 code.putln("%s.%s = %s;" % (

2072 self.opt_arg_struct,

2073 formal_arg.name,

2074 actual_arg.result_as(formal_arg.type)))

2075 exc_checks = []

2076 if self.type.is_pyobject:

2077 exc_checks.append("!%s" % self.result())

2078 else:

2079 exc_val = func_type.exception_value

2080 exc_check = func_type.exception_check

2081 if exc_val is not None:

2082 exc_checks.append("%s == %s" % (self.result(), exc_val))

2083 if exc_check:

2084 exc_checks.append("PyErr_Occurred()")

2085 if self.is_temp or exc_checks:

2086 rhs = self.c_call_code()

2087 if self.result():

2088 lhs = "%s = " % self.result()

2089 if self.is_temp and self.type.is_pyobject:

2090 #return_type = self.type # func_type.return_type

2091 #print "SimpleCallNode.generate_result_code: casting", rhs, \

2092 # "from", return_type, "to pyobject" ###

2093 rhs = typecast(py_object_type, self.type, rhs)

2094 else:

2095 lhs = ""

2096 if func_type.exception_check == '+':

2097 if func_type.exception_value is None:

2098 raise_py_exception = "__Pyx_CppExn2PyErr()"

2099 elif func_type.exception_value.type.is_pyobject:

2100 raise_py_exception = 'PyErr_SetString(%s, "")' % func_type.exception_value.entry.cname

2101 else:

2102 raise_py_exception = '%s(); if (!PyErr_Occurred()) PyErr_SetString(PyExc_RuntimeError , "Error converting c++ exception.")' % func_type.exception_value.entry.cname

2103 code.putln(

2104 "try {%s%s;} catch(...) {%s; %s}" % (

2105 lhs,

2106 rhs,

2107 raise_py_exception,

2108 code.error_goto(self.pos)))

2109 else:

2110 if exc_checks:

2111 goto_error = code.error_goto_if(" && ".join(exc_checks), self.pos)

2112 else:

2113 goto_error = ""

2114 code.putln("%s%s; %s" % (lhs, rhs, goto_error))

2115

2116 class GeneralCallNode(CallNode):

2117 # General Python function call, including keyword,

2118 # * and ** arguments.

2119 #

2120 # function ExprNode

2121 # positional_args ExprNode Tuple of positional arguments

2122 # keyword_args ExprNode or None Dict of keyword arguments

2123 # starstar_arg ExprNode or None Dict of extra keyword args

2124

2125 subexprs = ['function', 'positional_args', 'keyword_args', 'starstar_arg']

2126

2127 def compile_time_value(self, denv):

2128 function = self.function.compile_time_value(denv)

2129 positional_args = self.positional_args.compile_time_value(denv)

2130 keyword_args = self.keyword_args.compile_time_value(denv)

2131 starstar_arg = self.starstar_arg.compile_time_value(denv)

2132 try:

2133 keyword_args.update(starstar_arg)

2134 return function(*positional_args, **keyword_args)

2135 except Exception, e:

2136 self.compile_time_value_error(e)

2137

2138 def explicit_args_kwds(self):

2139 if self.starstar_arg or not isinstance(self.positional_args, TupleNode):

2140 raise PostParseError(self.pos,

2141 'Compile-time keyword arguments must be explicit.')

2142 return self.positional_args.args, self.keyword_args

2143

2144 def analyse_types(self, env):

2145 self.function.analyse_types(env)

2146 self.positional_args.analyse_types(env)

2147 if self.keyword_args:

2148 self.keyword_args.analyse_types(env)

2149 if self.starstar_arg:

2150 self.starstar_arg.analyse_types(env)

2151 self.function = self.function.coerce_to_pyobject(env)

2152 self.positional_args = \

2153 self.positional_args.coerce_to_pyobject(env)

2154 if self.starstar_arg:

2155 self.starstar_arg = \

2156 self.starstar_arg.coerce_to_pyobject(env)

2157 self.type = py_object_type

2158 self.gil_check(env)

2159 self.is_temp = 1

2160

2161 def generate_result_code(self, code):

2162 if self.keyword_args and self.starstar_arg:

2163 code.put_error_if_neg(self.pos,

2164 "PyDict_Update(%s, %s)" % (

2165 self.keyword_args.py_result(),

2166 self.starstar_arg.py_result()))

2167 keyword_code = self.keyword_args.py_result()

2168 elif self.keyword_args:

2169 keyword_code = self.keyword_args.py_result()

2170 elif self.starstar_arg:

2171 keyword_code = self.starstar_arg.py_result()

2172 else:

2173 keyword_code = None

2174 if not keyword_code:

2175 call_code = "PyObject_Call(%s, %s, NULL)" % (

2176 self.function.py_result(),

2177 self.positional_args.py_result())

2178 else:

2179 call_code = "PyEval_CallObjectWithKeywords(%s, %s, %s)" % (

2180 self.function.py_result(),

2181 self.positional_args.py_result(),

2182 keyword_code)

2183 code.putln(

2184 "%s = %s; %s" % (

2185 self.result(),

2186 call_code,

2187 code.error_goto_if_null(self.result(), self.pos)))

2188

2189

2190 class AsTupleNode(ExprNode):

2191 # Convert argument to tuple. Used for normalising

2192 # the * argument of a function call.

2193 #

2194 # arg ExprNode

2195

2196 subexprs = ['arg']

2197

2198 def compile_time_value(self, denv):

2199 arg = self.arg.compile_time_value(denv)

2200 try:

2201 return tuple(arg)

2202 except Exception, e:

2203 self.compile_time_value_error(e)

2204

2205 def analyse_types(self, env):

2206 self.arg.analyse_types(env)

2207 self.arg = self.arg.coerce_to_pyobject(env)

2208 self.type = py_object_type

2209 self.gil_check(env)

2210 self.is_temp = 1

2211

2212 gil_message = "Constructing Python tuple"

2213

2214 def generate_result_code(self, code):

2215 code.putln(

2216 "%s = PySequence_Tuple(%s); %s" % (

2217 self.result(),

2218 self.arg.py_result(),

2219 code.error_goto_if_null(self.result(), self.pos)))

2220

2221

2222 class AttributeNode(ExprNode):

2223 # obj.attribute

2224 #

2225 # obj ExprNode

2226 # attribute string

2227 # needs_none_check boolean Used if obj is an extension type.

2228 # If set to True, it is known that the type is not None.

2229 #

2230 # Used internally:

2231 #

2232 # is_py_attr boolean Is a Python getattr operation

2233 # member string C name of struct member

2234 # is_called boolean Function call is being done on result

2235 # entry Entry Symbol table entry of attribute

2236 # interned_attr_cname string C name of interned attribute name

2237

2238 is_attribute = 1

2239 subexprs = ['obj']

2240

2241 type = PyrexTypes.error_type

2242 entry = None

2243 is_called = 0

2244 needs_none_check = True

2245

2246 def magic_cython_method(self):

2247 if isinstance(self.obj, NameNode) and self.obj.is_cython_module:

2248 return self.attribute

2249

2250 def coerce_to(self, dst_type, env):

2251 # If coercing to a generic pyobject and this is a cpdef function

2252 # we can create the corresponding attribute

2253 if dst_type is py_object_type:

2254 entry = self.entry

2255 if entry and entry.is_cfunction and entry.as_variable:

2256 # must be a cpdef function

2257 self.is_temp = 1

2258 self.entry = entry.as_variable

2259 self.analyse_as_python_attribute(env)

2260 return self

2261 return ExprNode.coerce_to(self, dst_type, env)

2262

2263 def compile_time_value(self, denv):

2264 attr = self.attribute

2265 if attr.beginswith("__") and attr.endswith("__"):

2266 self.error("Invalid attribute name '%s' in compile-time expression"

2267 % attr)

2268 return None

2269 obj = self.arg.compile_time_value(denv)

2270 try:

2271 return getattr(obj, attr)

2272 except Exception, e:

2273 self.compile_time_value_error(e)

2274

2275 def analyse_target_declaration(self, env):

2276 pass

2277

2278 def analyse_target_types(self, env):

2279 self.analyse_types(env, target = 1)

2280

2281 def analyse_types(self, env, target = 0):

2282 if self.analyse_as_cimported_attribute(env, target):

2283 return

2284 if not target and self.analyse_as_unbound_cmethod(env):

2285 return

2286 self.analyse_as_ordinary_attribute(env, target)

2287

2288 def analyse_as_cimported_attribute(self, env, target):

2289 # Try to interpret this as a reference to an imported

2290 # C const, type, var or function. If successful, mutates

2291 # this node into a NameNode and returns 1, otherwise

2292 # returns 0.

2293 module_scope = self.obj.analyse_as_module(env)

2294 if module_scope:

2295 entry = module_scope.lookup_here(self.attribute)

2296 if entry and (

2297 entry.is_cglobal or entry.is_cfunction

2298 or entry.is_type or entry.is_const):

2299 self.mutate_into_name_node(env, entry, target)

2300 return 1

2301 return 0

2302

2303 def analyse_as_unbound_cmethod(self, env):

2304 # Try to interpret this as a reference to an unbound

2305 # C method of an extension type. If successful, mutates

2306 # this node into a NameNode and returns 1, otherwise

2307 # returns 0.

2308 type = self.obj.analyse_as_extension_type(env)

2309 if type:

2310 entry = type.scope.lookup_here(self.attribute)

2311 if entry and entry.is_cmethod:

2312 # Create a temporary entry describing the C method

2313 # as an ordinary function.

2314 ubcm_entry = Symtab.Entry(entry.name,

2315 "%s->%s" % (type.vtabptr_cname, entry.cname),

2316 entry.type)

2317 ubcm_entry.is_cfunction = 1

2318 ubcm_entry.func_cname = entry.func_cname

2319 ubcm_entry.is_unbound_cmethod = 1

2320 self.mutate_into_name_node(env, ubcm_entry, None)

2321 return 1

2322 return 0

2323

2324 def analyse_as_type(self, env):

2325 module_scope = self.obj.analyse_as_module(env)

2326 if module_scope:

2327 return module_scope.lookup_type(self.attribute)

2328 return None

2329

2330 def analyse_as_extension_type(self, env):

2331 # Try to interpret this as a reference to an extension type

2332 # in a cimported module. Returns the extension type, or None.

2333 module_scope = self.obj.analyse_as_module(env)

2334 if module_scope:

2335 entry = module_scope.lookup_here(self.attribute)

2336 if entry and entry.is_type and entry.type.is_extension_type:

2337 return entry.type

2338 return None

2339

2340 def analyse_as_module(self, env):

2341 # Try to interpret this as a reference to a cimported module

2342 # in another cimported module. Returns the module scope, or None.

2343 module_scope = self.obj.analyse_as_module(env)

2344 if module_scope:

2345 entry = module_scope.lookup_here(self.attribute)

2346 if entry and entry.as_module:

2347 return entry.as_module

2348 return None

2349

2350 def mutate_into_name_node(self, env, entry, target):

2351 # Mutate this node into a NameNode and complete the

2352 # analyse_types phase.

2353 self.__class__ = NameNode

2354 self.name = self.attribute

2355 self.entry = entry

2356 del self.obj

2357 del self.attribute

2358 if target:

2359 NameNode.analyse_target_types(self, env)

2360 else:

2361 NameNode.analyse_rvalue_entry(self, env)

2362

2363 def analyse_as_ordinary_attribute(self, env, target):

2364 self.obj.analyse_types(env)

2365 self.analyse_attribute(env)

2366 if self.entry and self.entry.is_cmethod and not self.is_called:

2367 # error(self.pos, "C method can only be called")

2368 pass

2369 ## Reference to C array turns into pointer to first element.

2370 #while self.type.is_array:

2371 # self.type = self.type.element_ptr_type()

2372 if self.is_py_attr:

2373 if not target:

2374 self.is_temp = 1

2375 self.result_ctype = py_object_type

2376

2377 def analyse_attribute(self, env):

2378 # Look up attribute and set self.type and self.member.

2379 self.is_py_attr = 0

2380 self.member = self.attribute

2381 if self.obj.type.is_string:

2382 self.obj = self.obj.coerce_to_pyobject(env)

2383 obj_type = self.obj.type

2384 if obj_type.is_ptr or obj_type.is_array:

2385 obj_type = obj_type.base_type

2386 self.op = "->"

2387 elif obj_type.is_extension_type:

2388 self.op = "->"

2389 else:

2390 self.op = "."

2391 if obj_type.has_attributes:

2392 entry = None

2393 if obj_type.attributes_known():

2394 entry = obj_type.scope.lookup_here(self.attribute)

2395 if entry and entry.is_member:

2396 entry = None

2397 else:

2398 error(self.pos,

2399 "Cannot select attribute of incomplete type '%s'"

2400 % obj_type)

2401 self.type = PyrexTypes.error_type

2402 return

2403 self.entry = entry

2404 if entry:

2405 if obj_type.is_extension_type and entry.name == "__weakref__":

2406 error(self.pos, "Illegal use of special attribute __weakref__")

2407 # methods need the normal attribute lookup

2408 # because they do not have struct entries

2409 if entry.is_variable or entry.is_cmethod:

2410 self.type = entry.type

2411 self.member = entry.cname

2412 return

2413 else:

2414 # If it's not a variable or C method, it must be a Python

2415 # method of an extension type, so we treat it like a Python

2416 # attribute.

2417 pass

2418 # If we get here, the base object is not a struct/union/extension

2419 # type, or it is an extension type and the attribute is either not

2420 # declared or is declared as a Python method. Treat it as a Python

2421 # attribute reference.

2422 self.analyse_as_python_attribute(env)

2423

2424 def analyse_as_python_attribute(self, env):

2425 obj_type = self.obj.type

2426 self.member = self.attribute

2427 if obj_type.is_pyobject:

2428 self.type = py_object_type

2429 self.is_py_attr = 1

2430 self.interned_attr_cname = env.intern_identifier(self.attribute)

2431 self.gil_check(env)

2432 else:

2433 if not obj_type.is_error:

2434 error(self.pos,

2435 "Object of type '%s' has no attribute '%s'" %

2436 (obj_type, self.attribute))

2437

2438 gil_message = "Accessing Python attribute"

2439

2440 def is_simple(self):

2441 if self.obj:

2442 return self.result_in_temp() or self.obj.is_simple()

2443 else:

2444 return NameNode.is_simple(self)

2445

2446 def is_lvalue(self):

2447 if self.obj:

2448 return 1

2449 else:

2450 return NameNode.is_lvalue(self)

2451

2452 def is_ephemeral(self):

2453 if self.obj:

2454 return self.obj.is_ephemeral()

2455 else:

2456 return NameNode.is_ephemeral(self)

2457

2458 def calculate_result_code(self):

2459 #print "AttributeNode.calculate_result_code:", self.member ###

2460 #print "...obj node =", self.obj, "code", self.obj.result() ###

2461 #print "...obj type", self.obj.type, "ctype", self.obj.ctype() ###

2462 obj = self.obj

2463 obj_code = obj.result_as(obj.type)

2464 #print "...obj_code =", obj_code ###

2465 if self.entry and self.entry.is_cmethod:

2466 if obj.type.is_extension_type:

2467 return "((struct %s *)%s%s%s)->%s" % (

2468 obj.type.vtabstruct_cname, obj_code, self.op,

2469 obj.type.vtabslot_cname, self.member)

2470 else:

2471 return self.member

2472 else:

2473 return "%s%s%s" % (obj_code, self.op, self.member)

2474

2475 def generate_result_code(self, code):

2476 if self.is_py_attr:

2477 code.putln(

2478 '%s = PyObject_GetAttr(%s, %s); %s' % (

2479 self.result(),

2480 self.obj.py_result(),

2481 self.interned_attr_cname,

2482 code.error_goto_if_null(self.result(), self.pos)))

2483 else:

2484 # result_code contains what is needed, but we may need to insert

2485 # a check and raise an exception

2486 if (self.obj.type.is_extension_type

2487 and self.needs_none_check

2488 and code.globalstate.directives['nonecheck']):

2489 self.put_nonecheck(code)

2490

2491 def generate_assignment_code(self, rhs, code):

2492 self.obj.generate_evaluation_code(code)

2493 if self.is_py_attr:

2494 code.put_error_if_neg(self.pos,

2495 'PyObject_SetAttr(%s, %s, %s)' % (

2496 self.obj.py_result(),

2497 self.interned_attr_cname,

2498 rhs.py_result()))

2499 rhs.generate_disposal_code(code)

2500 else:

2501 if (self.obj.type.is_extension_type

2502 and self.needs_none_check

2503 and code.globalstate.directives['nonecheck']):

2504 self.put_nonecheck(code)

2505

2506 select_code = self.result()

2507 if self.type.is_pyobject:

2508 rhs.make_owned_reference(code)

2509 code.put_decref(select_code, self.ctype())

2510 code.putln(

2511 "%s = %s;" % (

2512 select_code,

2513 rhs.result_as(self.ctype())))

2514 #rhs.result()))

2515 rhs.generate_post_assignment_code(code)

2516 self.obj.generate_disposal_code(code)

2517

2518 def generate_deletion_code(self, code):

2519 self.obj.generate_evaluation_code(code)

2520 if self.is_py_attr:

2521 code.put_error_if_neg(self.pos,

2522 'PyObject_DelAttr(%s, %s)' % (

2523 self.obj.py_result(),

2524 self.interned_attr_cname))

2525 else:

2526 error(self.pos, "Cannot delete C attribute of extension type")

2527 self.obj.generate_disposal_code(code)

2528

2529 def annotate(self, code):

2530 if self.is_py_attr:

2531 code.annotate(self.pos, AnnotationItem('py_attr', 'python attribute', size=len(self.attribute)))

2532 else:

2533 code.annotate(self.pos, AnnotationItem('c_attr', 'c attribute', size=len(self.attribute)))

2534

2535 def put_nonecheck(self, code):

2536 code.globalstate.use_utility_code(raise_noneattr_error_utility_code)

2537 code.putln("if (%s) {" % code.unlikely("%s == Py_None") % self.obj.result_as(PyrexTypes.py_object_type))

2538 code.putln("__Pyx_RaiseNoneAttributeError(\"%s\");" % self.attribute.encode("UTF-8")) # todo: fix encoding

2539 code.putln(code.error_goto(self.pos))

2540 code.putln("}")

2541

2542

2543 #-------------------------------------------------------------------

2544 #

2545 # Constructor nodes

2546 #

2547 #-------------------------------------------------------------------

2548

2549 class SequenceNode(ExprNode):

2550 # Base class for list and tuple constructor nodes.

2551 # Contains common code for performing sequence unpacking.

2552 #

2553 # args [ExprNode]

2554 # iterator ExprNode

2555 # unpacked_items [ExprNode] or None

2556 # coerced_unpacked_items [ExprNode] or None

2557

2558 subexprs = ['args']

2559

2560 is_sequence_constructor = 1

2561 unpacked_items = None

2562

2563 def compile_time_value_list(self, denv):

2564 return [arg.compile_time_value(denv) for arg in self.args]

2565

2566 def analyse_target_declaration(self, env):

2567 for arg in self.args:

2568 arg.analyse_target_declaration(env)

2569

2570 def analyse_types(self, env, skip_children=False):

2571 for i in range(len(self.args)):

2572 arg = self.args[i]

2573 if not skip_children: arg.analyse_types(env)

2574 self.args[i] = arg.coerce_to_pyobject(env)

2575 self.type = py_object_type

2576 self.gil_check(env)

2577 self.is_temp = 1

2578

2579 def analyse_target_types(self, env):

2580 self.iterator = PyTempNode(self.pos, env)

2581 self.unpacked_items = []

2582 self.coerced_unpacked_items = []

2583 for arg in self.args:

2584 arg.analyse_target_types(env)

2585 unpacked_item = PyTempNode(self.pos, env)

2586 coerced_unpacked_item = unpacked_item.coerce_to(arg.type, env)

2587 self.unpacked_items.append(unpacked_item)

2588 self.coerced_unpacked_items.append(coerced_unpacked_item)

2589 self.type = py_object_type

2590 env.use_utility_code(unpacking_utility_code)

2591

2592 def allocate_target_temps(self, env, rhs):

2593 self.iterator.allocate_temps(env)

2594 for arg, node in zip(self.args, self.coerced_unpacked_items):

2595 node.allocate_temps(env)

2596 arg.allocate_target_temps(env, node)

2597 #arg.release_target_temp(env)

2598 #node.release_temp(env)

2599 if rhs:

2600 rhs.release_temp(env)

2601 self.iterator.release_temp(env)

2602

2603 # def release_target_temp(self, env):

2604 # #for arg in self.args:

2605 # # arg.release_target_temp(env)

2606 # #for node in self.coerced_unpacked_items:

2607 # # node.release_temp(env)

2608 # self.iterator.release_temp(env)

2609

2610 def generate_result_code(self, code):

2611 self.generate_operation_code(code)

2612

2613 def generate_assignment_code(self, rhs, code):

2614 code.putln(

2615 "if (PyTuple_CheckExact(%s) && PyTuple_GET_SIZE(%s) == %s) {" % (

2616 rhs.py_result(),

2617 rhs.py_result(),

2618 len(self.args)))

2619 code.putln("PyObject* tuple = %s;" % rhs.py_result())

2620 for i in range(len(self.args)):

2621 item = self.unpacked_items[i]

2622 code.putln(

2623 "%s = PyTuple_GET_ITEM(tuple, %s);" % (

2624 item.result(),

2625 i))

2626 code.put_incref(item.result(), item.ctype())

2627 value_node = self.coerced_unpacked_items[i]

2628 value_node.generate_evaluation_code(code)

2629 self.args[i].generate_assignment_code(value_node, code)

2630

2631 rhs.generate_disposal_code(code)

2632 code.putln("}")

2633 code.putln("else {")

2634

2635 code.putln(

2636 "%s = PyObject_GetIter(%s); %s" % (

2637 self.iterator.result(),

2638 rhs.py_result(),

2639 code.error_goto_if_null(self.iterator.result(), self.pos)))

2640 rhs.generate_disposal_code(code)

2641 for i in range(len(self.args)):

2642 item = self.unpacked_items[i]

2643 unpack_code = "__Pyx_UnpackItem(%s, %d)" % (

2644 self.iterator.py_result(), i)

2645 code.putln(

2646 "%s = %s; %s" % (

2647 item.result(),

2648 typecast(item.ctype(), py_object_type, unpack_code),

2649 code.error_goto_if_null(item.result(), self.pos)))

2650 value_node = self.coerced_unpacked_items[i]

2651 value_node.generate_evaluation_code(code)

2652 self.args[i].generate_assignment_code(value_node, code)

2653 code.put_error_if_neg(self.pos,

2654 "__Pyx_EndUnpack(%s)" % (

2655 self.iterator.py_result()))

2656 if debug_disposal_code:

2657 print("UnpackNode.generate_assignment_code:")

2658 print("...generating disposal code for %s" % self.iterator)

2659 self.iterator.generate_disposal_code(code)

2660

2661 code.putln("}")

2662

2663 def annotate(self, code):

2664 for arg in self.args:

2665 arg.annotate(code)

2666 if self.unpacked_items:

2667 for arg in self.unpacked_items:

2668 arg.annotate(code)

2669 for arg in self.coerced_unpacked_items:

2670 arg.annotate(code)

2671

2672

2673 class TupleNode(SequenceNode):

2674 # Tuple constructor.

2675

2676 gil_message = "Constructing Python tuple"

2677

2678 def analyse_types(self, env, skip_children=False):

2679 if len(self.args) == 0:

2680 self.is_temp = 0

2681 self.is_literal = 1

2682 else:

2683 SequenceNode.analyse_types(self, env, skip_children)

2684 self.type = tuple_type

2685

2686 def calculate_result_code(self):

2687 if len(self.args) > 0:

2688 error(self.pos, "Positive length tuples must be constructed.")

2689 else:

2690 return Naming.empty_tuple

2691

2692 def compile_time_value(self, denv):

2693 values = self.compile_time_value_list(denv)

2694 try:

2695 return tuple(values)

2696 except Exception, e:

2697 self.compile_time_value_error(e)

2698

2699 def generate_operation_code(self, code):

2700 if len(self.args) == 0:

2701 # result_code is Naming.empty_tuple

2702 return

2703 code.putln(

2704 "%s = PyTuple_New(%s); %s" % (

2705 self.result(),

2706 len(self.args),

2707 code.error_goto_if_null(self.result(), self.pos)))

2708 for i in range(len(self.args)):

2709 arg = self.args[i]

2710 if not arg.result_in_temp():

2711 code.put_incref(arg.result(), arg.ctype())

2712 code.putln(

2713 "PyTuple_SET_ITEM(%s, %s, %s);" % (

2714 self.result(),

2715 i,

2716 arg.py_result()))

2717

2718 def generate_subexpr_disposal_code(self, code):

2719 # We call generate_post_assignment_code here instead

2720 # of generate_disposal_code, because values were stored

2721 # in the tuple using a reference-stealing operation.

2722 for arg in self.args:

2723 arg.generate_post_assignment_code(code)

2724

2725

2726 class ListNode(SequenceNode):

2727 # List constructor.

2728

2729 # obj_conversion_errors [PyrexError] used internally

2730 # orignial_args [ExprNode] used internally

2731

2732 gil_message = "Constructing Python list"

2733

2734 def analyse_expressions(self, env):

2735 ExprNode.analyse_expressions(self, env)

2736 self.coerce_to_pyobject(env)

2737

2738 def analyse_types(self, env):

2739 hold_errors()

2740 self.original_args = list(self.args)

2741 SequenceNode.analyse_types(self, env)

2742 self.type = list_type

2743 self.obj_conversion_errors = held_errors()

2744 release_errors(ignore=True)

2745

2746 def coerce_to(self, dst_type, env):

2747 if dst_type.is_pyobject:

2748 for err in self.obj_conversion_errors:

2749 report_error(err)

2750 self.obj_conversion_errors = []

2751 if not self.type.subtype_of(dst_type):

2752 error(self.pos, "Cannot coerce list to type '%s'" % dst_type)

2753 elif dst_type.is_ptr:

2754 base_type = dst_type.base_type

2755 self.type = PyrexTypes.CArrayType(base_type, len(self.args))

2756 for i in range(len(self.original_args)):

2757 arg = self.args[i]

2758 if isinstance(arg, CoerceToPyTypeNode):

2759 arg = arg.arg

2760 self.args[i] = arg.coerce_to(base_type, env)

2761 elif dst_type.is_struct:

2762 if len(self.args) > len(dst_type.scope.var_entries):

2763 error(self.pos, "Too may members for '%s'" % dst_type)

2764 else:

2765 if len(self.args) < len(dst_type.scope.var_entries):

2766 warning(self.pos, "Too few members for '%s'" % dst_type, 1)

2767 for i, (arg, member) in enumerate(zip(self.original_args, dst_type.scope.var_entries)):

2768 if isinstance(arg, CoerceToPyTypeNode):

2769 arg = arg.arg

2770 self.args[i] = arg.coerce_to(member.type, env)

2771 self.type = dst_type

2772 else:

2773 self.type = error_type

2774 error(self.pos, "Cannot coerce list to type '%s'" % dst_type)

2775 return self

2776

2777 def release_temp(self, env):

2778 if self.type.is_array:

2779 # To be valid C++, we must allocate the memory on the stack

2780 # manually and be sure not to reuse it for something else.

2781 pass

2782 else:

2783 SequenceNode.release_temp(self, env)

2784

2785 def compile_time_value(self, denv):

2786 return self.compile_time_value_list(denv)

2787

2788 def generate_operation_code(self, code):

2789 if self.type.is_pyobject:

2790 for err in self.obj_conversion_errors:

2791 report_error(err)

2792 code.putln("%s = PyList_New(%s); %s" %

2793 (self.result(),

2794 len(self.args),

2795 code.error_goto_if_null(self.result(), self.pos)))

2796 for i in range(len(self.args)):

2797 arg = self.args[i]

2798 #if not arg.is_temp:

2799 if not arg.result_in_temp():

2800 code.put_incref(arg.result(), arg.ctype())

2801 code.putln("PyList_SET_ITEM(%s, %s, %s);" %

2802 (self.result(),

2803 i,

2804 arg.py_result()))

2805 elif self.type.is_array:

2806 for i, arg in enumerate(self.args):

2807 code.putln("%s[%s] = %s;" % (

2808 self.result(),

2809 i,

2810 arg.result()))

2811 elif self.type.is_struct or 1:

2812 for arg, member in zip(self.args, self.type.scope.var_entries):

2813 code.putln("%s.%s = %s;" % (

2814 self.result(),

2815 member.cname,

2816 arg.result()))

2817 else:

2818 raise InternalError("List type never specified")

2819

2820 def generate_subexpr_disposal_code(self, code):

2821 # We call generate_post_assignment_code here instead

2822 # of generate_disposal_code, because values were stored

2823 # in the list using a reference-stealing operation.

2824 for arg in self.args:

2825 arg.generate_post_assignment_code(code)

2826

2827

2828 class ListComprehensionNode(SequenceNode):

2829

2830 subexprs = []

2831 is_sequence_constructor = 0 # not unpackable

2832

2833 child_attrs = ["loop", "append"]

2834

2835 def analyse_types(self, env):

2836 self.type = list_type

2837 self.is_temp = 1

2838 self.append.target = self # this is a CloneNode used in the PyList_Append in the inner loop

2839

2840 def allocate_temps(self, env, result = None):

2841 if debug_temp_alloc:

2842 print("%s Allocating temps" % self)

2843 self.allocate_temp(env, result)

2844 self.loop.analyse_declarations(env)

2845 self.loop.analyse_expressions(env)

2846

2847 def generate_operation_code(self, code):

2848 code.putln("%s = PyList_New(%s); %s" %

2849 (self.result(),

2850 0,

2851 code.error_goto_if_null(self.result(), self.pos)))

2852 self.loop.generate_execution_code(code)

2853

2854 def annotate(self, code):

2855 self.loop.annotate(code)

2856

2857

2858 class ListComprehensionAppendNode(ExprNode):

2859

2860 # Need to be careful to avoid infinite recursion:

2861 # target must not be in child_attrs/subexprs

2862 subexprs = ['expr']

2863

2864 def analyse_types(self, env):

2865 self.expr.analyse_types(env)

2866 if self.expr.type != py_object_type:

2867 self.expr = self.expr.coerce_to_pyobject(env)

2868 self.type = PyrexTypes.c_int_type

2869 self.is_temp = 1

2870

2871 def generate_result_code(self, code):

2872 code.putln("%s = PyList_Append(%s, (PyObject*)%s); %s" %

2873 (self.result(),

2874 self.target.result(),

2875 self.expr.result(),

2876 code.error_goto_if(self.result(), self.pos)))

2877

2878

2879 class DictNode(ExprNode):

2880 # Dictionary constructor.

2881 #

2882 # key_value_pairs [DictItemNode]

2883 #

2884 # obj_conversion_errors [PyrexError] used internally

2885

2886 subexprs = ['key_value_pairs']

2887

2888 def compile_time_value(self, denv):

2889 pairs = [(item.key.compile_time_value(denv), item.value.compile_time_value(denv))

2890 for item in self.key_value_pairs]

2891 try:

2892 return dict(pairs)

2893 except Exception, e:

2894 self.compile_time_value_error(e)

2895

2896 def analyse_types(self, env):

2897 hold_errors()

2898 for item in self.key_value_pairs:

2899 item.analyse_types(env)

2900 self.gil_check(env)

2901 self.obj_conversion_errors = held_errors()

2902 release_errors(ignore=True)

2903 self.type = dict_type

2904 self.is_temp = 1

2905

2906 def coerce_to(self, dst_type, env):

2907 if dst_type.is_pyobject:

2908 self.release_errors()

2909 if not self.type.subtype_of(dst_type):

2910 error(self.pos, "Cannot interpret dict as type '%s'" % dst_type)

2911 elif dst_type.is_struct_or_union:

2912 self.type = dst_type

2913 if not dst_type.is_struct and len(self.key_value_pairs) != 1:

2914 error(self.pos, "Exactly one field must be specified to convert to union '%s'" % dst_type)

2915 elif dst_type.is_struct and len(self.key_value_pairs) < len(dst_type.scope.var_entries):

2916 warning(self.pos, "Not all members given for struct '%s'" % dst_type, 1)

2917 for item in self.key_value_pairs:

2918 if isinstance(item.key, CoerceToPyTypeNode):

2919 item.key = item.key.arg

2920 if isinstance(item.key, (StringNode, IdentifierStringNode)):

2921 item.key = NameNode(pos=item.key.pos, name=item.key.value)

2922 if not isinstance(item.key, NameNode):

2923 print item.key

2924 error(item.key.pos, "Struct field must be a name")

2925 else:

2926 member = dst_type.scope.lookup_here(item.key.name)

2927 if not member:

2928 error(item.key.pos, "struct '%s' has no field '%s'" % (dst_type, item.key.name))

2929 else:

2930 value = item.value

2931 if isinstance(value, CoerceToPyTypeNode):

2932 value = value.arg

2933 item.value = value.coerce_to(member.type, env)

2934 else:

2935 self.type = error_type

2936 error(self.pos, "Cannot interpret dict as type '%s'" % dst_type)

2937 return self

2938

2939 def release_errors(self):

2940 for err in self.obj_conversion_errors:

2941 report_error(err)

2942 self.obj_conversion_errors = []

2943

2944 gil_message = "Constructing Python dict"

2945

2946 def allocate_temps(self, env, result = None):

2947 # Custom method used here because key-value

2948 # pairs are evaluated and used one at a time.

2949 self.allocate_temp(env, result)

2950 for item in self.key_value_pairs:

2951 item.key.allocate_temps(env)

2952 item.value.allocate_temps(env)

2953 item.key.release_temp(env)

2954 item.value.release_temp(env)

2955

2956 def generate_evaluation_code(self, code):

2957 # Custom method used here because key-value

2958 # pairs are evaluated and used one at a time.

2959 if self.type.is_pyobject:

2960 self.release_errors()

2961 code.putln(

2962 "%s = PyDict_New(); %s" % (

2963 self.result(),

2964 code.error_goto_if_null(self.result(), self.pos)))

2965 for item in self.key_value_pairs:

2966 item.generate_evaluation_code(code)

2967 if self.type.is_pyobject:

2968 code.put_error_if_neg(self.pos,

2969 "PyDict_SetItem(%s, %s, %s)" % (

2970 self.result(),

2971 item.key.py_result(),

2972 item.value.py_result()))

2973 else:

2974 code.putln("%s.%s = %s;" % (

2975 self.result(),

2976 item.key.name,

2977 item.value.result()))

2978 item.generate_disposal_code(code)

2979

2980 def annotate(self, code):

2981 for item in self.key_value_pairs:

2982 item.annotate(code)

2983

2984 class DictItemNode(ExprNode):

2985 # Represents a single item in a DictNode

2986 #

2987 # key ExprNode

2988 # value ExprNode

2989 subexprs = ['key', 'value']

2990

2991 def analyse_types(self, env):

2992 self.key.analyse_types(env)

2993 self.value.analyse_types(env)

2994 self.key = self.key.coerce_to_pyobject(env)

2995 self.value = self.value.coerce_to_pyobject(env)

2996

2997 def generate_evaluation_code(self, code):

2998 self.key.generate_evaluation_code(code)

2999 self.value.generate_evaluation_code(code)

3000

3001 def generate_disposal_code(self, code):

3002 self.key.generate_disposal_code(code)

3003 self.value.generate_disposal_code(code)

3004

3005 def __iter__(self):

3006 return iter([self.key, self.value])

3007

3008

3009 class ClassNode(ExprNode):

3010 # Helper class used in the implementation of Python

3011 # class definitions. Constructs a class object given

3012 # a name, tuple of bases and class dictionary.

3013 #

3014 # name EncodedString Name of the class

3015 # cname string Class name as a Python string

3016 # bases ExprNode Base class tuple

3017 # dict ExprNode Class dict (not owned by this node)

3018 # doc ExprNode or None Doc string

3019 # module_name string Name of defining module

3020

3021 subexprs = ['bases', 'doc']

3022

3023 def analyse_types(self, env):

3024 self.cname = env.intern_identifier(self.name)

3025 self.bases.analyse_types(env)

3026 if self.doc:

3027 self.doc.analyse_types(env)

3028 self.doc = self.doc.coerce_to_pyobject(env)

3029 self.module_name = env.global_scope().qualified_name

3030 self.type = py_object_type

3031 self.gil_check(env)

3032 self.is_temp = 1

3033 env.use_utility_code(create_class_utility_code);

3034

3035 gil_message = "Constructing Python class"

3036

3037 def generate_result_code(self, code):

3038 if self.doc:

3039 code.put_error_if_neg(self.pos,

3040 'PyDict_SetItemString(%s, "__doc__", %s)' % (

3041 self.dict.py_result(),

3042 self.doc.py_result()))

3043 code.putln(

3044 '%s = __Pyx_CreateClass(%s, %s, %s, "%s"); %s' % (

3045 self.result(),

3046 self.bases.py_result(),

3047 self.dict.py_result(),

3048 self.cname,

3049 self.module_name,

3050 code.error_goto_if_null(self.result(), self.pos)))

3051

3052

3053 class UnboundMethodNode(ExprNode):

3054 # Helper class used in the implementation of Python

3055 # class definitions. Constructs an unbound method

3056 # object from a class and a function.

3057 #

3058 # class_cname string C var holding the class object

3059 # function ExprNode Function object

3060

3061 subexprs = ['function']

3062

3063 def analyse_types(self, env):

3064 self.function.analyse_types(env)

3065 self.type = py_object_type

3066 self.gil_check(env)

3067 self.is_temp = 1

3068

3069 gil_message = "Constructing an unbound method"

3070

3071 def generate_result_code(self, code):

3072 code.putln(

3073 "%s = PyMethod_New(%s, 0, %s); %s" % (

3074 self.result(),

3075 self.function.py_result(),

3076 self.class_cname,

3077 code.error_goto_if_null(self.result(), self.pos)))

3078

3079

3080 class PyCFunctionNode(AtomicExprNode):

3081 # Helper class used in the implementation of Python

3082 # class definitions. Constructs a PyCFunction object

3083 # from a PyMethodDef struct.

3084 #

3085 # pymethdef_cname string PyMethodDef structure

3086

3087 def analyse_types(self, env):

3088 self.type = py_object_type

3089 self.gil_check(env)

3090 self.is_temp = 1

3091

3092 gil_message = "Constructing Python function"

3093

3094 def generate_result_code(self, code):

3095 code.putln(

3096 "%s = PyCFunction_New(&%s, 0); %s" % (

3097 self.result(),

3098 self.pymethdef_cname,

3099 code.error_goto_if_null(self.result(), self.pos)))

3100

3101 #-------------------------------------------------------------------

3102 #

3103 # Unary operator nodes

3104 #

3105 #-------------------------------------------------------------------

3106

3107 compile_time_unary_operators = {

3108 'not': operator.not_,

3109 '~': operator.inv,

3110 '-': operator.neg,

3111 '+': operator.pos,

3112 }

3113

3114 class UnopNode(ExprNode):

3115 # operator string

3116 # operand ExprNode

3117 #

3118 # Processing during analyse_expressions phase:

3119 #

3120 # analyse_c_operation

3121 # Called when the operand is not a pyobject.

3122 # - Check operand type and coerce if needed.

3123 # - Determine result type and result code fragment.

3124 # - Allocate temporary for result if needed.

3125

3126 subexprs = ['operand']

3127

3128 def compile_time_value(self, denv):

3129 func = compile_time_unary_operators.get(self.operator)

3130 if not func:

3131 error(self.pos,

3132 "Unary '%s' not supported in compile-time expression"

3133 % self.operator)

3134 operand = self.operand.compile_time_value(denv)

3135 try:

3136 return func(operand)

3137 except Exception, e:

3138 self.compile_time_value_error(e)

3139

3140 def analyse_types(self, env):

3141 self.operand.analyse_types(env)

3142 if self.is_py_operation():

3143 self.coerce_operand_to_pyobject(env)

3144 self.type = py_object_type

3145 self.gil_check(env)

3146 self.is_temp = 1

3147 else:

3148 self.analyse_c_operation(env)

3149

3150 def check_const(self):

3151 self.operand.check_const()

3152

3153 def is_py_operation(self):

3154 return self.operand.type.is_pyobject

3155

3156 def coerce_operand_to_pyobject(self, env):

3157 self.operand = self.operand.coerce_to_pyobject(env)

3158

3159 def generate_result_code(self, code):

3160 if self.operand.type.is_pyobject:

3161 self.generate_py_operation_code(code)

3162 else:

3163 if self.is_temp:

3164 self.generate_c_operation_code(code)

3165

3166 def generate_py_operation_code(self, code):

3167 function = self.py_operation_function()

3168 code.putln(

3169 "%s = %s(%s); %s" % (

3170 self.result(),

3171 function,

3172 self.operand.py_result(),

3173 code.error_goto_if_null(self.result(), self.pos)))

3174

3175 def type_error(self):

3176 if not self.operand.type.is_error:

3177 error(self.pos, "Invalid operand type for '%s' (%s)" %

3178 (self.operator, self.operand.type))

3179 self.type = PyrexTypes.error_type

3180

3181

3182 class NotNode(ExprNode):

3183 # 'not' operator

3184 #

3185 # operand ExprNode

3186

3187 def compile_time_value(self, denv):

3188 operand = self.operand.compile_time_value(denv)

3189 try:

3190 return not operand

3191 except Exception, e:

3192 self.compile_time_value_error(e)

3193

3194 subexprs = ['operand']

3195

3196 def analyse_types(self, env):

3197 self.operand.analyse_types(env)

3198 self.operand = self.operand.coerce_to_boolean(env)

3199 self.type = PyrexTypes.c_bint_type

3200

3201 def calculate_result_code(self):

3202 return "(!%s)" % self.operand.result()

3203

3204 def generate_result_code(self, code):

3205 pass

3206

3207

3208 class UnaryPlusNode(UnopNode):

3209 # unary '+' operator

3210

3211 operator = '+'

3212

3213 def analyse_c_operation(self, env):

3214 self.type = self.operand.type

3215

3216 def py_operation_function(self):

3217 return "PyNumber_Positive"

3218

3219 def calculate_result_code(self):

3220 return self.operand.result()

3221

3222

3223 class UnaryMinusNode(UnopNode):

3224 # unary '-' operator

3225

3226 operator = '-'

3227

3228 def analyse_c_operation(self, env):

3229 if self.operand.type.is_numeric:

3230 self.type = self.operand.type

3231 else:

3232 self.type_error()

3233

3234 def py_operation_function(self):

3235 return "PyNumber_Negative"

3236

3237 def calculate_result_code(self):

3238 return "(-%s)" % self.operand.result()

3239

3240

3241 class TildeNode(UnopNode):

3242 # unary '~' operator

3243

3244 def analyse_c_operation(self, env):

3245 if self.operand.type.is_int:

3246 self.type = self.operand.type

3247 else:

3248 self.type_error()

3249

3250 def py_operation_function(self):

3251 return "PyNumber_Invert"

3252

3253 def calculate_result_code(self):

3254 return "(~%s)" % self.operand.result()

3255

3256

3257 class AmpersandNode(ExprNode):

3258 # The C address-of operator.

3259 #

3260 # operand ExprNode

3261

3262 subexprs = ['operand']

3263

3264 def analyse_types(self, env):

3265 self.operand.analyse_types(env)

3266 argtype = self.operand.type

3267 if not (argtype.is_cfunction or self.operand.is_lvalue()):

3268 self.error("Taking address of non-lvalue")

3269 return

3270 if argtype.is_pyobject:

3271 self.error("Cannot take address of Python variable")

3272 return

3273 self.type = PyrexTypes.c_ptr_type(argtype)

3274

3275 def check_const(self):

3276 self.operand.check_const_addr()

3277

3278 def error(self, mess):

3279 error(self.pos, mess)

3280 self.type = PyrexTypes.error_type

3281 self.result_code = "<error>"

3282

3283 def calculate_result_code(self):

3284 return "(&%s)" % self.operand.result()

3285

3286 def generate_result_code(self, code):

3287 pass

3288

3289

3290 unop_node_classes = {

3291 "+": UnaryPlusNode,

3292 "-": UnaryMinusNode,

3293 "~": TildeNode,

3294 }

3295

3296 def unop_node(pos, operator, operand):

3297 # Construct unnop node of appropriate class for

3298 # given operator.

3299 if isinstance(operand, IntNode) and operator == '-':

3300 return IntNode(pos = operand.pos, value = str(-int(operand.value, 0)))

3301 elif isinstance(operand, UnopNode) and operand.operator == operator:

3302 warning(pos, "Python has no increment/decrement operator: %s%sx = %s(%sx) = x" % ((operator,)*4), 5)

3303 return unop_node_classes[operator](pos,

3304 operator = operator,

3305 operand = operand)

3306

3307

3308 class TypecastNode(ExprNode):

3309 # C type cast

3310 #

3311 # operand ExprNode

3312 # base_type CBaseTypeNode

3313 # declarator CDeclaratorNode

3314 #

3315 # If used from a transform, one can if wanted specify the attribute

3316 # "type" directly and leave base_type and declarator to None

3317

3318 subexprs = ['operand']

3319 base_type = declarator = type = None

3320

3321 def analyse_types(self, env):

3322 if self.type is None:

3323 base_type = self.base_type.analyse(env)

3324 _, self.type = self.declarator.analyse(base_type, env)

3325 if self.type.is_cfunction:

3326 error(self.pos,

3327 "Cannot cast to a function type")

3328 self.type = PyrexTypes.error_type

3329 self.operand.analyse_types(env)

3330 to_py = self.type.is_pyobject

3331 from_py = self.operand.type.is_pyobject

3332 if from_py and not to_py and self.operand.is_ephemeral() and not self.type.is_numeric:

3333 error(self.pos, "Casting temporary Python object to non-numeric non-Python type")

3334 if to_py and not from_py:

3335 if self.operand.type.to_py_function:

3336 self.result_ctype = py_object_type

3337 self.operand = self.operand.coerce_to_pyobject(env)

3338 else:

3339 warning(self.pos, "No conversion from %s to %s, python object pointer used." % (self.operand.type, self.type))

3340 self.operand = self.operand.coerce_to_simple(env)

3341 elif from_py and not to_py:

3342 if self.type.from_py_function:

3343 self.operand = self.operand.coerce_to(self.type, env)

3344 else:

3345 warning(self.pos, "No conversion from %s to %s, python object pointer used." % (self.type, self.operand.type))

3346 elif from_py and to_py:

3347 if self.typecheck and self.type.is_extension_type:

3348 self.operand = PyTypeTestNode(self.operand, self.type, env)

3349

3350 def check_const(self):

3351 self.operand.check_const()

3352

3353 def calculate_result_code(self):

3354 opnd = self.operand

3355 return self.type.cast_code(opnd.result())

3356

3357 def result_as(self, type):

3358 if self.type.is_pyobject and not self.is_temp:

3359 # Optimise away some unnecessary casting

3360 return self.operand.result_as(type)

3361 else:

3362 return ExprNode.result_as(self, type)

3363

3364 def generate_result_code(self, code):

3365 if self.is_temp:

3366 code.putln(

3367 "%s = (PyObject *)%s;" % (

3368 self.result(),

3369 self.operand.result()))

3370 code.put_incref(self.result(), self.ctype())

3371

3372

3373 class SizeofNode(ExprNode):

3374 # Abstract base class for sizeof(x) expression nodes.

3375

3376 type = PyrexTypes.c_int_type

3377

3378 def check_const(self):

3379 pass

3380

3381 def generate_result_code(self, code):

3382 pass

3383

3384

3385 class SizeofTypeNode(SizeofNode):

3386 # C sizeof function applied to a type

3387 #

3388 # base_type CBaseTypeNode

3389 # declarator CDeclaratorNode

3390

3391 subexprs = []

3392 arg_type = None

3393

3394 def analyse_types(self, env):

3395 # we may have incorrectly interpreted a dotted name as a type rather than an attribute

3396 # this could be better handled by more uniformly treating types as runtime-available objects

3397 if 0 and self.base_type.module_path:

3398 path = self.base_type.module_path

3399 obj = env.lookup(path[0])

3400 if obj.as_module is None:

3401 operand = NameNode(pos=self.pos, name=path[0])

3402 for attr in path[1:]:

3403 operand = AttributeNode(pos=self.pos, obj=operand, attribute=attr)

3404 operand = AttributeNode(pos=self.pos, obj=operand, attribute=self.base_type.name)

3405 self.operand = operand

3406 self.__class__ = SizeofVarNode

3407 self.analyse_types(env)

3408 return

3409 if self.arg_type is None:

3410 base_type = self.base_type.analyse(env)

3411 _, arg_type = self.declarator.analyse(base_type, env)

3412 self.arg_type = arg_type

3413 self.check_type()

3414

3415 def check_type(self):

3416 arg_type = self.arg_type

3417 if arg_type.is_pyobject and not arg_type.is_extension_type:

3418 error(self.pos, "Cannot take sizeof Python object")

3419 elif arg_type.is_void:

3420 error(self.pos, "Cannot take sizeof void")

3421 elif not arg_type.is_complete():

3422 error(self.pos, "Cannot take sizeof incomplete type '%s'" % arg_type)

3423

3424 def calculate_result_code(self):

3425 if self.arg_type.is_extension_type:

3426 # the size of the pointer is boring

3427 # we want the size of the actual struct

3428 arg_code = self.arg_type.declaration_code("", deref=1)

3429 else:

3430 arg_code = self.arg_type.declaration_code("")

3431 return "(sizeof(%s))" % arg_code

3432

3433

3434 class SizeofVarNode(SizeofNode):

3435 # C sizeof function applied to a variable

3436 #

3437 # operand ExprNode

3438

3439 subexprs = ['operand']

3440

3441 def analyse_types(self, env):

3442 # We may actually be looking at a type rather than a variable...

3443 # If we are, traditional analysis would fail...

3444 operand_as_type = self.operand.analyse_as_type(env)

3445 if operand_as_type:

3446 self.arg_type = operand_as_type

3447 self.__class__ = SizeofTypeNode

3448 self.check_type()

3449 else:

3450 self.operand.analyse_types(env)

3451

3452 def calculate_result_code(self):

3453 return "(sizeof(%s))" % self.operand.result()

3454

3455 def generate_result_code(self, code):

3456 pass

3457

3458

3459 #-------------------------------------------------------------------

3460 #

3461 # Binary operator nodes

3462 #

3463 #-------------------------------------------------------------------

3464

3465 def _not_in(x, seq):

3466 return x not in seq

3467

3468 compile_time_binary_operators = {

3469 '<': operator.lt,

3470 '<=': operator.le,

3471 '==': operator.eq,

3472 '!=': operator.ne,

3473 '>=': operator.ge,

3474 '>': operator.gt,

3475 'is': operator.is_,

3476 'is_not': operator.is_not,

3477 '+': operator.add,

3478 '&': operator.and_,

3479 '/': operator.div,

3480 '//': operator.floordiv,

3481 '<<': operator.lshift,

3482 '%': operator.mod,

3483 '*': operator.mul,

3484 '|': operator.or_,

3485 '**': operator.pow,

3486 '>>': operator.rshift,

3487 '-': operator.sub,

3488 #'/': operator.truediv,

3489 '^': operator.xor,

3490 'in': operator.contains,

3491 'not_in': _not_in,

3492 }

3493

3494 def get_compile_time_binop(node):

3495 func = compile_time_binary_operators.get(node.operator)

3496 if not func:

3497 error(node.pos,

3498 "Binary '%s' not supported in compile-time expression"

3499 % node.operator)

3500 return func

3501

3502 class BinopNode(NewTempExprNode):

3503 # operator string

3504 # operand1 ExprNode

3505 # operand2 ExprNode

3506 #

3507 # Processing during analyse_expressions phase:

3508 #

3509 # analyse_c_operation

3510 # Called when neither operand is a pyobject.

3511 # - Check operand types and coerce if needed.

3512 # - Determine result type and result code fragment.

3513 # - Allocate temporary for result if needed.

3514

3515 subexprs = ['operand1', 'operand2']

3516

3517 def compile_time_value(self, denv):

3518 func = get_compile_time_binop(self)

3519 operand1 = self.operand1.compile_time_value(denv)

3520 operand2 = self.operand2.compile_time_value(denv)

3521 try:

3522 return func(operand1, operand2)

3523 except Exception, e:

3524 self.compile_time_value_error(e)

3525

3526 def analyse_types(self, env):

3527 self.operand1.analyse_types(env)

3528 self.operand2.analyse_types(env)

3529 if self.is_py_operation():

3530 self.coerce_operands_to_pyobjects(env)

3531 self.type = py_object_type

3532 self.gil_check(env)

3533 self.is_temp = 1

3534 if Options.incref_local_binop and self.operand1.type.is_pyobject:

3535 self.operand1 = self.operand1.coerce_to_temp(env)

3536 else:

3537 self.analyse_c_operation(env)

3538

3539 def is_py_operation(self):

3540 return (self.operand1.type.is_pyobject

3541 or self.operand2.type.is_pyobject)

3542

3543 def coerce_operands_to_pyobjects(self, env):

3544 self.operand1 = self.operand1.coerce_to_pyobject(env)

3545 self.operand2 = self.operand2.coerce_to_pyobject(env)

3546

3547 def check_const(self):

3548 self.operand1.check_const()

3549 self.operand2.check_const()

3550

3551 def generate_result_code(self, code):

3552 #print "BinopNode.generate_result_code:", self.operand1, self.operand2 ###

3553 if self.operand1.type.is_pyobject:

3554 function = self.py_operation_function()

3555 if function == "PyNumber_Power":

3556 extra_args = ", Py_None"

3557 else:

3558 extra_args = ""

3559 code.putln(

3560 "%s = %s(%s, %s%s); %s" % (

3561 self.result(),

3562 function,

3563 self.operand1.py_result(),

3564 self.operand2.py_result(),

3565 extra_args,

3566 code.error_goto_if_null(self.result(), self.pos)))

3567 else:

3568 if self.is_temp:

3569 self.generate_c_operation_code(code)

3570

3571 def type_error(self):

3572 if not (self.operand1.type.is_error

3573 or self.operand2.type.is_error):

3574 error(self.pos, "Invalid operand types for '%s' (%s; %s)" %

3575 (self.operator, self.operand1.type,

3576 self.operand2.type))

3577 self.type = PyrexTypes.error_type

3578

3579

3580 class NumBinopNode(BinopNode):

3581 # Binary operation taking numeric arguments.

3582

3583 def analyse_c_operation(self, env):

3584 type1 = self.operand1.type

3585 type2 = self.operand2.type

3586 if self.operator == "**" and type1.is_int and type2.is_int:

3587 error(self.pos, "** with two C int types is ambiguous")

3588 self.type = error_type

3589 return

3590 self.type = self.compute_c_result_type(type1, type2)

3591 if not self.type:

3592 self.type_error()

3593

3594 def compute_c_result_type(self, type1, type2):

3595 if self.c_types_okay(type1, type2):

3596 return PyrexTypes.widest_numeric_type(type1, type2)

3597 else:

3598 return None

3599

3600 def c_types_okay(self, type1, type2):

3601 #print "NumBinopNode.c_types_okay:", type1, type2 ###

3602 return (type1.is_numeric or type1.is_enum) \

3603 and (type2.is_numeric or type2.is_enum)

3604

3605 def calculate_result_code(self):

3606 return "(%s %s %s)" % (

3607 self.operand1.result(),

3608 self.operator,

3609 self.operand2.result())

3610

3611 def py_operation_function(self):

3612 return self.py_functions[self.operator]

3613

3614 py_functions = {

3615 "|": "PyNumber_Or",

3616 "^": "PyNumber_Xor",

3617 "&": "PyNumber_And",

3618 "<<": "PyNumber_Lshift",

3619 ">>": "PyNumber_Rshift",

3620 "+": "PyNumber_Add",

3621 "-": "PyNumber_Subtract",

3622 "*": "PyNumber_Multiply",

3623 "/": "__Pyx_PyNumber_Divide",

3624 "//": "PyNumber_FloorDivide",

3625 "%": "PyNumber_Remainder",

3626 "**": "PyNumber_Power"

3627 }

3628

3629

3630 class IntBinopNode(NumBinopNode):

3631 # Binary operation taking integer arguments.

3632

3633 def c_types_okay(self, type1, type2):

3634 #print "IntBinopNode.c_types_okay:", type1, type2 ###

3635 return (type1.is_int or type1.is_enum) \

3636 and (type2.is_int or type2.is_enum)

3637

3638

3639 class AddNode(NumBinopNode):

3640 # '+' operator.

3641

3642 def is_py_operation(self):

3643 if self.operand1.type.is_string \

3644 and self.operand2.type.is_string:

3645 return 1

3646 else:

3647 return NumBinopNode.is_py_operation(self)

3648

3649 def compute_c_result_type(self, type1, type2):

3650 #print "AddNode.compute_c_result_type:", type1, self.operator, type2 ###

3651 if (type1.is_ptr or type1.is_array) and (type2.is_int or type2.is_enum):

3652 return type1

3653 elif (type2.is_ptr or type2.is_array) and (type1.is_int or type1.is_enum):

3654 return type2

3655 else:

3656 return NumBinopNode.compute_c_result_type(

3657 self, type1, type2)

3658

3659

3660 class SubNode(NumBinopNode):

3661 # '-' operator.

3662

3663 def compute_c_result_type(self, type1, type2):

3664 if (type1.is_ptr or type1.is_array) and (type2.is_int or type2.is_enum):

3665 return type1

3666 elif (type1.is_ptr or type1.is_array) and (type2.is_ptr or type2.is_array):

3667 return PyrexTypes.c_int_type

3668 else:

3669 return NumBinopNode.compute_c_result_type(

3670 self, type1, type2)

3671

3672

3673 class MulNode(NumBinopNode):

3674 # '*' operator.

3675

3676 def is_py_operation(self):

3677 type1 = self.operand1.type

3678 type2 = self.operand2.type

3679 if (type1.is_string and type2.is_int) \

3680 or (type2.is_string and type1.is_int):

3681 return 1

3682 else:

3683 return NumBinopNode.is_py_operation(self)

3684

3685

3686 class FloorDivNode(NumBinopNode):

3687 # '//' operator.

3688

3689 def calculate_result_code(self):

3690 return "(%s %s %s)" % (

3691 self.operand1.result(),

3692 "/", # c division is by default floor-div

3693 self.operand2.result())

3694

3695

3696 class ModNode(NumBinopNode):

3697 # '%' operator.

3698

3699 def is_py_operation(self):

3700 return (self.operand1.type.is_string

3701 or self.operand2.type.is_string

3702 or NumBinopNode.is_py_operation(self))

3703

3704 def calculate_result_code(self):

3705 if self.operand1.type.is_float or self.operand2.type.is_float:

3706 return "fmod(%s, %s)" % (

3707 self.operand1.result(),

3708 self.operand2.result())

3709 else:

3710 return "(%s %% %s)" % (

3711 self.operand1.result(),

3712 self.operand2.result())

3713

3714 class PowNode(NumBinopNode):

3715 # '**' operator.

3716

3717 def compute_c_result_type(self, type1, type2):

3718 if self.c_types_okay(type1, type2):

3719 return PyrexTypes.c_double_type

3720 else:

3721 return None

3722

3723 def c_types_okay(self, type1, type2):

3724 return (type1.is_float or type2.is_float) and \

3725 NumBinopNode.c_types_okay(self, type1, type2)

3726

3727 def type_error(self):

3728 if not (self.operand1.type.is_error or self.operand2.type.is_error):

3729 if self.operand1.type.is_int and self.operand2.type.is_int:

3730 error(self.pos, "C has no integer powering, use python ints or floats instead '%s' (%s; %s)" %

3731 (self.operator, self.operand1.type, self.operand2.type))

3732 else:

3733 NumBinopNode.type_error(self)

3734 self.type = PyrexTypes.error_type

3735

3736 def calculate_result_code(self):

3737 return "pow(%s, %s)" % (

3738 self.operand1.result(), self.operand2.result())

3739

3740

3741 class BoolBinopNode(ExprNode):

3742 # Short-circuiting boolean operation.

3743 #

3744 # operator string

3745 # operand1 ExprNode

3746 # operand2 ExprNode

3747 # temp_bool ExprNode used internally

3748

3749 temp_bool = None

3750

3751 subexprs = ['operand1', 'operand2', 'temp_bool']

3752

3753 def compile_time_value(self, denv):

3754 if self.operator == 'and':

3755 return self.operand1.compile_time_value(denv) \

3756 and self.operand2.compile_time_value(denv)

3757 else:

3758 return self.operand1.compile_time_value(denv) \

3759 or self.operand2.compile_time_value(denv)

3760

3761 def analyse_types(self, env):

3762 self.operand1.analyse_types(env)

3763 self.operand2.analyse_types(env)

3764 if self.operand1.type.is_pyobject or \

3765 self.operand2.type.is_pyobject:

3766 self.operand1 = self.operand1.coerce_to_pyobject(env)

3767 self.operand2 = self.operand2.coerce_to_pyobject(env)

3768 self.temp_bool = TempNode(self.pos, PyrexTypes.c_bint_type, env)

3769 self.type = py_object_type

3770 self.gil_check(env)

3771 else:

3772 self.operand1 = self.operand1.coerce_to_boolean(env)

3773 self.operand2 = self.operand2.coerce_to_boolean(env)

3774 self.type = PyrexTypes.c_bint_type

3775 # For what we're about to do, it's vital that

3776 # both operands be temp nodes.

3777 self.operand1 = self.operand1.coerce_to_temp(env) #CTT

3778 self.operand2 = self.operand2.coerce_to_temp(env)

3779 self.is_temp = 1

3780

3781 gil_message = "Truth-testing Python object"

3782

3783 def allocate_temps(self, env, result_code = None):

3784 # We don't need both operands at the same time, and

3785 # one of the operands will also be our result. So we

3786 # use an allocation strategy here which results in

3787 # this node and both its operands sharing the same

3788 # result variable. This allows us to avoid some

3789 # assignments and increfs/decrefs that would otherwise

3790 # be necessary.

3791 self.allocate_temp(env, result_code)

3792 self.operand1.allocate_temps(env, self.result())

3793 if self.temp_bool:

3794 self.temp_bool.allocate_temp(env)

3795 self.temp_bool.release_temp(env)

3796 self.operand2.allocate_temps(env, self.result())

3797 # We haven't called release_temp on either operand,

3798 # because although they are temp nodes, they don't own

3799 # their result variable. And because they are temp

3800 # nodes, any temps in their subnodes will have been

3801 # released before their allocate_temps returned.

3802 # Therefore, they contain no temp vars that need to

3803 # be released.

3804

3805 def check_const(self):

3806 self.operand1.check_const()

3807 self.operand2.check_const()

3808

3809 def calculate_result_code(self):

3810 return "(%s %s %s)" % (

3811 self.operand1.result(),

3812 self.py_to_c_op[self.operator],

3813 self.operand2.result())

3814

3815 py_to_c_op = {'and': "&&", 'or': "||"}

3816

3817 def generate_evaluation_code(self, code):

3818 self.operand1.generate_evaluation_code(code)

3819 test_result = self.generate_operand1_test(code)

3820 if self.operator == 'and':

3821 sense = ""

3822 else:

3823 sense = "!"

3824 code.putln(

3825 "if (%s%s) {" % (

3826 sense,

3827 test_result))

3828 self.operand1.generate_disposal_code(code)

3829 self.operand2.generate_evaluation_code(code)

3830 code.putln(

3831 "}")

3832

3833 def generate_operand1_test(self, code):

3834 # Generate code to test the truth of the first operand.

3835 if self.type.is_pyobject:

3836 test_result = self.temp_bool.result()

3837 code.putln(

3838 "%s = __Pyx_PyObject_IsTrue(%s); %s" % (

3839 test_result,

3840 self.operand1.py_result(),

3841 code.error_goto_if_neg(test_result, self.pos)))

3842 else:

3843 test_result = self.operand1.result()

3844 return test_result

3845

3846

3847 class CondExprNode(ExprNode):

3848 # Short-circuiting conditional expression.

3849 #

3850 # test ExprNode

3851 # true_val ExprNode

3852 # false_val ExprNode

3853

3854 temp_bool = None

3855 true_val = None

3856 false_val = None

3857

3858 subexprs = ['test', 'true_val', 'false_val']

3859

3860 def analyse_types(self, env):

3861 self.test.analyse_types(env)

3862 self.test = self.test.coerce_to_boolean(env)

3863 self.true_val.analyse_types(env)

3864 self.false_val.analyse_types(env)

3865 self.type = self.compute_result_type(self.true_val.type, self.false_val.type)

3866 if self.true_val.type.is_pyobject or self.false_val.type.is_pyobject:

3867 self.true_val = self.true_val.coerce_to(self.type, env)

3868 self.false_val = self.false_val.coerce_to(self.type, env)

3869 # must be tmp variables so they can share a result

3870 self.true_val = self.true_val.coerce_to_temp(env)

3871 self.false_val = self.false_val.coerce_to_temp(env)

3872 self.is_temp = 1

3873 if self.type == PyrexTypes.error_type:

3874 self.type_error()

3875

3876 def allocate_temps(self, env, result_code = None):

3877 # We only ever evaluate one side, and this is

3878 # after evaluating the truth value, so we may

3879 # use an allocation strategy here which results in

3880 # this node and both its operands sharing the same

3881 # result variable. This allows us to avoid some

3882 # assignments and increfs/decrefs that would otherwise

3883 # be necessary.

3884 self.allocate_temp(env, result_code)

3885 self.test.allocate_temps(env, result_code)

3886 self.true_val.allocate_temps(env, self.result())

3887 self.false_val.allocate_temps(env, self.result())

3888 # We haven't called release_temp on either value,

3889 # because although they are temp nodes, they don't own

3890 # their result variable. And because they are temp

3891 # nodes, any temps in their subnodes will have been

3892 # released before their allocate_temps returned.

3893 # Therefore, they contain no temp vars that need to

3894 # be released.

3895

3896 def compute_result_type(self, type1, type2):

3897 if type1 == type2:

3898 return type1

3899 elif type1.is_numeric and type2.is_numeric:

3900 return PyrexTypes.widest_numeric_type(type1, type2)

3901 elif type1.is_extension_type and type1.subtype_of_resolved_type(type2):

3902 return type2

3903 elif type2.is_extension_type and type2.subtype_of_resolved_type(type1):

3904 return type1

3905 elif type1.is_pyobject or type2.is_pyobject:

3906 return py_object_type

3907 elif type1.assignable_from(type2):

3908 return type1

3909 elif type2.assignable_from(type1):

3910 return type2

3911 else:

3912 return PyrexTypes.error_type

3913

3914 def type_error(self):

3915 if not (self.true_val.type.is_error or self.false_val.type.is_error):

3916 error(self.pos, "Incompatable types in conditional expression (%s; %s)" %

3917 (self.true_val.type, self.false_val.type))

3918 self.type = PyrexTypes.error_type

3919

3920 def check_const(self):

3921 self.test.check_const()

3922 self.true_val.check_const()

3923 self.false_val.check_const()

3924

3925 def generate_evaluation_code(self, code):

3926 self.test.generate_evaluation_code(code)

3927 code.putln("if (%s) {" % self.test.result() )

3928 self.true_val.generate_evaluation_code(code)

3929 code.putln("} else {")

3930 self.false_val.generate_evaluation_code(code)

3931 code.putln("}")

3932 self.test.generate_disposal_code(code)

3933

3934 richcmp_constants = {

3935 "<" : "Py_LT",

3936 "<=": "Py_LE",

3937 "==": "Py_EQ",

3938 "!=": "Py_NE",

3939 "<>": "Py_NE",

3940 ">" : "Py_GT",

3941 ">=": "Py_GE",

3942 }

3943

3944 class CmpNode:

3945 # Mixin class containing code common to PrimaryCmpNodes

3946 # and CascadedCmpNodes.

3947

3948 def cascaded_compile_time_value(self, operand1, denv):

3949 func = get_compile_time_binop(self)

3950 operand2 = self.operand2.compile_time_value(denv)

3951 try:

3952 result = func(operand1, operand2)

3953 except Exception, e:

3954 self.compile_time_value_error(e)

3955 result = None

3956 if result:

3957 cascade = self.cascade

3958 if cascade:

3959 result = result and cascade.compile_time_value(operand2, denv)

3960 return result

3961

3962 def is_python_comparison(self):

3963 return (self.has_python_operands()

3964 or (self.cascade and self.cascade.is_python_comparison())

3965 or self.operator in ('in', 'not_in'))

3966

3967 def is_python_result(self):

3968 return ((self.has_python_operands() and self.operator not in ('is', 'is_not', 'in', 'not_in'))

3969 or (self.cascade and self.cascade.is_python_result()))

3970

3971 def check_types(self, env, operand1, op, operand2):

3972 if not self.types_okay(operand1, op, operand2):