1 #

2 # Pyrex - Parse tree nodes for expressions

3 #

4

5 import operator

6

7 from Errors import error, warning, InternalError

8 from Errors import hold_errors, release_errors, held_errors, report_error

9 from Code import UtilityCode

10 import StringEncoding

11 import Naming

12 import Nodes

13 from Nodes import Node

14 import PyrexTypes

15 from PyrexTypes import py_object_type, c_long_type, typecast, error_type

16 from Builtin import list_type, tuple_type, set_type, dict_type, unicode_type, bytes_type

17 import Builtin

18 import Symtab

19 import Options

20 from Annotate import AnnotationItem

21

22 from Cython.Debugging import print_call_chain

23 from DebugFlags import debug_disposal_code, debug_temp_alloc, \

24 debug_coercion

25

26 try:

27 set

28 except NameError:

29 from sets import Set as set

30

31 class NotConstant(object): pass # just for the name

32 not_a_constant = NotConstant()

33 constant_value_not_set = object()

34

35 class ExprNode(Node):

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

37 # type PyrexType Type of the result

38 # result_code string Code fragment

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

40 # is_temp boolean Result is in a temporary variable

41 # is_sequence_constructor

42 # boolean Is a list or tuple constructor expression

43 # is_starred boolean Is a starred expression (e.g. '*a')

44 # saved_subexpr_nodes

45 # [ExprNode or [ExprNode or None] or None]

46 # Cached result of subexpr_nodes()

47

48 result_ctype = None

49 type = None

50 temp_code = None

51 old_temp = None # error checker for multiple frees etc.

52

53 # The Analyse Expressions phase for expressions is split

54 # into two sub-phases:

55 #

56 # Analyse Types

57 # Determines the result type of the expression based

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

59 # coercion nodes into the expression tree where needed.

60 # Marks nodes which will need to have temporary variables

61 # allocated.

62 #

63 # Allocate Temps

64 # Allocates temporary variables where needed, and fills

65 # in the result_code field of each node.

66 #

67 # ExprNode provides some convenience routines which

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

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

70 # coercion nodes need to be added around the expression

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

72 # should be invoked separately.

73 #

74 # Framework code in ExprNode provides much of the common

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

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

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

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

79 #

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

81 # Their responsibilities are as follows.

82 #

83 # Declaration Analysis phase

84 #

85 # analyse_target_declaration

86 # Called during the Analyse Declarations phase to analyse

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

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

89 # implement it.

90 #

91 # Expression Analysis phase

92 #

93 # analyse_types

94 # - Call analyse_types on all sub-expressions.

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

96 # sub-expressions where needed.

97 # - Set the type of this node.

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

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

100 #

101 # analyse_target_types

102 # Called during the Analyse Types phase to analyse

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

104 # statement. Similar responsibilities to analyse_types.

105 #

106 # target_code

107 # Called by the default implementation of allocate_target_temps.

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

109 # implementation calls calculate_result_code.

110 #

111 # check_const

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

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

114 # otherwise call not_const.

115 #

116 # The default implementation of check_const

117 # assumes that the expression is not constant.

118 #

119 # check_const_addr

120 # - Same as check_const, except check that the

121 # expression is a C lvalue whose address is

122 # constant. Otherwise, call addr_not_const.

123 #

124 # The default implementation of calc_const_addr

125 # assumes that the expression is not a constant

126 # lvalue.

127 #

128 # Code Generation phase

129 #

130 # generate_evaluation_code

131 # - Call generate_evaluation_code for sub-expressions.

132 # - Perform the functions of generate_result_code

133 # (see below).

134 # - If result is temporary, call generate_disposal_code

135 # on all sub-expressions.

136 #

137 # A default implementation of generate_evaluation_code

138 # is provided which uses the following abstract methods:

139 #

140 # generate_result_code

141 # - Generate any C statements necessary to calculate

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

143 # sub-expressions.

144 #

145 # calculate_result_code

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

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

148 # a temporary.

149 #

150 # generate_assignment_code

151 # Called on the LHS of an assignment.

152 # - Call generate_evaluation_code for sub-expressions.

153 # - Generate code to perform the assignment.

154 # - If the assignment absorbed a reference, call

155 # generate_post_assignment_code on the RHS,

156 # otherwise call generate_disposal_code on it.

157 #

158 # generate_deletion_code

159 # Called on an argument of a del statement.

160 # - Call generate_evaluation_code for sub-expressions.

161 # - Generate code to perform the deletion.

162 # - Call generate_disposal_code on all sub-expressions.

163 #

164 #

165

166 is_sequence_constructor = 0

167 is_attribute = 0

168

169 saved_subexpr_nodes = None

170 is_temp = 0

171 is_target = 0

172 is_starred = 0

173

174 constant_result = constant_value_not_set

175

176 try:

177 _get_child_attrs = operator.attrgetter('subexprs')

178 except AttributeError:

179 # Python 2.3

180 def _get_child_attrs(self):

181 return self.subexprs

182 child_attrs = property(fget=_get_child_attrs)

183

184 def not_implemented(self, method_name):

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

186 raise InternalError(

187 "%s.%s not implemented" %

188 (self.__class__.__name__, method_name))

189

190 def is_lvalue(self):

191 return 0

192

193 def is_ephemeral(self):

194 # An ephemeral node is one whose result is in

195 # a Python temporary and we suspect there are no

196 # other references to it. Certain operations are

197 # disallowed on such values, since they are

198 # likely to result in a dangling pointer.

199 return self.type.is_pyobject and self.is_temp

200

201 def subexpr_nodes(self):

202 # Extract a list of subexpression nodes based

203 # on the contents of the subexprs class attribute.

204 nodes = []

205 for name in self.subexprs:

206 item = getattr(self, name)

207 if item is not None:

208 if type(item) is list:

209 nodes.extend(item)

210 else:

211 nodes.append(item)

212 return nodes

213

214 def result(self):

215 if self.is_temp:

216 return self.temp_code

217 else:

218 return self.calculate_result_code()

219

220 def result_as(self, type = None):

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

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

223

224 def py_result(self):

225 # Return the result code cast to PyObject *.

226 return self.result_as(py_object_type)

227

228 def ctype(self):

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

230 # C type of the result_code expression).

231 return self.result_ctype or self.type

232

233 def get_constant_c_result_code(self):

234 # Return the constant value of this node as a result code

235 # string, or None if the node is not constant. This method

236 # can be called when the constant result code is required

237 # before the code generation phase.

238 #

239 # The return value is a string that can represent a simple C

240 # value, a constant C name or a constant C expression. If the

241 # node type depends on Python code, this must return None.

242 return None

243

244 def calculate_constant_result(self):

245 # Calculate the constant compile time result value of this

246 # expression and store it in ``self.constant_result``. Does

247 # nothing by default, thus leaving ``self.constant_result``

248 # unknown. If valid, the result can be an arbitrary Python

249 # value.

250 #

251 # This must only be called when it is assured that all

252 # sub-expressions have a valid constant_result value. The

253 # ConstantFolding transform will do this.

254 pass

255

256 def compile_time_value(self, denv):

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

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

259

260 def compile_time_value_error(self, e):

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

262 e.__class__.__name__, e))

263

264 # ------------- Declaration Analysis ----------------

265

266 def analyse_target_declaration(self, env):

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

268

269 # ------------- Expression Analysis ----------------

270

271 def analyse_const_expression(self, env):

272 # Called during the analyse_declarations phase of a

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

274 # checks whether it is a legal const expression,

275 # and determines its value.

276 self.analyse_types(env)

277 self.check_const()

278

279 def analyse_expressions(self, env):

280 # Convenience routine performing both the Type

281 # Analysis and Temp Allocation phases for a whole

282 # expression.

283 self.analyse_types(env)

284

285 def analyse_target_expression(self, env, rhs):

286 # Convenience routine performing both the Type

287 # Analysis and Temp Allocation phases for the LHS of

288 # an assignment.

289 self.analyse_target_types(env)

290

291 def analyse_boolean_expression(self, env):

292 # Analyse expression and coerce to a boolean.

293 self.analyse_types(env)

294 bool = self.coerce_to_boolean(env)

295 return bool

296

297 def analyse_temp_boolean_expression(self, env):

298 # Analyse boolean expression and coerce result into

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

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

301 # opportunity to ensure disposal code is executed

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

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

304 # time we get the result.

305 self.analyse_types(env)

306 bool = self.coerce_to_boolean(env)

307 temp_bool = bool.coerce_to_temp(env)

308 return temp_bool

309

310 # --------------- Type Analysis ------------------

311

312 def analyse_as_module(self, env):

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

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

315 return None

316

317 def analyse_as_type(self, env):

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

319 # type, return that type, else None.

320 return None

321

322 def analyse_as_extension_type(self, env):

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

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

325 return None

326

327 def analyse_types(self, env):

328 self.not_implemented("analyse_types")

329

330 def analyse_target_types(self, env):

331 self.analyse_types(env)

332

333 def nogil_check(self, env):

334 # By default, any expression based on Python objects is

335 # prevented in nogil environments. Subtypes must override

336 # this if they can work without the GIL.

337 if self.type.is_pyobject:

338 self.gil_error()

339

340 def gil_assignment_check(self, env):

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

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

343

344 def check_const(self):

345 self.not_const()

346

347 def not_const(self):

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

349

350 def check_const_addr(self):

351 self.addr_not_const()

352

353 def addr_not_const(self):

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

355

356 # ----------------- Result Allocation -----------------

357

358 def result_in_temp(self):

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

360 # this node or one of its subexpressions. Overridden

361 # by certain nodes which can share the result of

362 # a subnode.

363 return self.is_temp

364

365 def target_code(self):

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

367 return self.calculate_result_code()

368

369 def calculate_result_code(self):

370 self.not_implemented("calculate_result_code")

371

372 # def release_target_temp(self, env):

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

374 # self.release_subexpr_temps(env)

375

376 def allocate_temp_result(self, code):

377 if self.temp_code:

378 raise RuntimeError("Temp allocated multiple times")

379 type = self.type

380 if not type.is_void:

381 if type.is_pyobject:

382 type = PyrexTypes.py_object_type

383 self.temp_code = code.funcstate.allocate_temp(

384 type, manage_ref=True)

385 else:

386 self.temp_code = None

387

388 def release_temp_result(self, code):

389 if not self.temp_code:

390 if self.old_temp:

391 raise RuntimeError("temp %s released multiple times in %s" % (

392 self.old_temp, self.__class__.__name__))

393 else:

394 raise RuntimeError("no temp, but release requested in %s" % (

395 self.__class__.__name__))

396 code.funcstate.release_temp(self.temp_code)

397 self.old_temp = self.temp_code

398 self.temp_code = None

399

400 # ---------------- Code Generation -----------------

401

402 def make_owned_reference(self, code):

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

404 # a reference to it.

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

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

407

408 def generate_evaluation_code(self, code):

409 code.mark_pos(self.pos)

410

411 # Generate code to evaluate this node and

412 # its sub-expressions, and dispose of any

413 # temporary results of its sub-expressions.

414 self.generate_subexpr_evaluation_code(code)

415

416 if self.is_temp:

417 self.allocate_temp_result(code)

418

419 self.generate_result_code(code)

420 if self.is_temp:

421 # If we are temp we do not need to wait until this node is disposed

422 # before disposing children.

423 self.generate_subexpr_disposal_code(code)

424 self.free_subexpr_temps(code)

425

426 def generate_subexpr_evaluation_code(self, code):

427 for node in self.subexpr_nodes():

428 node.generate_evaluation_code(code)

429

430 def generate_result_code(self, code):

431 self.not_implemented("generate_result_code")

432

433 def generate_disposal_code(self, code):

434 if self.is_temp:

435 if self.type.is_pyobject:

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

437 else:

438 # Already done if self.is_temp

439 self.generate_subexpr_disposal_code(code)

440

441 def generate_subexpr_disposal_code(self, code):

442 # Generate code to dispose of temporary results

443 # of all sub-expressions.

444 for node in self.subexpr_nodes():

445 node.generate_disposal_code(code)

446

447 def generate_post_assignment_code(self, code):

448 if self.is_temp:

449 if self.type.is_pyobject:

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

451 else:

452 self.generate_subexpr_disposal_code(code)

453

454 def generate_assignment_code(self, rhs, code):

455 # Stub method for nodes which are not legal as

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

457 # been reported earlier.

458 pass

459

460 def generate_deletion_code(self, code):

461 # Stub method for nodes that are not legal as

462 # the argument of a del statement. An error

463 # will have been reported earlier.

464 pass

465

466 def free_temps(self, code):

467 if self.is_temp:

468 if not self.type.is_void:

469 self.release_temp_result(code)

470 else:

471 self.free_subexpr_temps(code)

472

473 def free_subexpr_temps(self, code):

474 for sub in self.subexpr_nodes():

475 sub.free_temps(code)

476

477 # ---------------- Annotation ---------------------

478

479 def annotate(self, code):

480 for node in self.subexpr_nodes():

481 node.annotate(code)

482

483 # ----------------- Coercion ----------------------

484

485 def coerce_to(self, dst_type, env):

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

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

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

489 # Otherwise, returns this node unchanged.

490 #

491 # This method is called during the analyse_expressions

492 # phase of the src_node's processing.

493 src = self

494 src_type = self.type

495 src_is_py_type = src_type.is_pyobject

496 dst_is_py_type = dst_type.is_pyobject

497

498 if dst_type.is_pyobject:

499 if not src.type.is_pyobject:

500 src = CoerceToPyTypeNode(src, env)

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

502 if not isinstance(src, NoneNode):

503 src = PyTypeTestNode(src, dst_type, env)

504 elif src.type.is_pyobject:

505 src = CoerceFromPyTypeNode(dst_type, src, env)

506 elif (dst_type.is_complex

507 and src_type != dst_type

508 and dst_type.assignable_from(src_type)

509 and not env.directives['c99_complex']):

510 src = CoerceToComplexNode(src, dst_type, env)

511 else: # neither src nor dst are py types

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

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

514 # in different pxi files.

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

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

517 (src.type, dst_type))

518 return src

519

520 def coerce_to_pyobject(self, env):

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

522

523 def coerce_to_boolean(self, env):

524 # Coerce result to something acceptable as

525 # a boolean value.

526 type = self.type

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

528 return CoerceToBooleanNode(self, env)

529 else:

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

531 error(self.pos,

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

533 return self

534

535 def coerce_to_integer(self, env):

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

537 if self.type.is_int:

538 return self

539 else:

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

541

542 def coerce_to_temp(self, env):

543 # Ensure that the result is in a temporary.

544 if self.result_in_temp():

545 return self

546 else:

547 return CoerceToTempNode(self, env)

548

549 def coerce_to_simple(self, env):

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

551 if self.is_simple():

552 return self

553 else:

554 return self.coerce_to_temp(env)

555

556 def is_simple(self):

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

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

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

560 # reference, or temporary.

561 return self.result_in_temp()

562

563 def as_cython_attribute(self):

564 return None

565

566 class AtomicExprNode(ExprNode):

567 # Abstract base class for expression nodes which have

568 # no sub-expressions.

569

570 subexprs = []

571

572 # Override to optimize -- we know we have no children

573 def generate_subexpr_evaluation_code(self, code):

574 pass

575 def generate_subexpr_disposal_code(self, code):

576 pass

577

578 class PyConstNode(AtomicExprNode):

579 # Abstract base class for constant Python values.

580

581 is_literal = 1

582

583 def is_simple(self):

584 return 1

585

586 def analyse_types(self, env):

587 self.type = py_object_type

588

589 def calculate_result_code(self):

590 return self.value

591

592 def generate_result_code(self, code):

593 pass

594

595

596 class NoneNode(PyConstNode):

597 # The constant value None

598

599 value = "Py_None"

600

601 constant_result = None

602

603 nogil_check = None

604

605 def compile_time_value(self, denv):

606 return None

607

608 class EllipsisNode(PyConstNode):

609 # '...' in a subscript list.

610

611 value = "Py_Ellipsis"

612

613 constant_result = Ellipsis

614

615 def compile_time_value(self, denv):

616 return Ellipsis

617

618

619 class ConstNode(AtomicExprNode):

620 # Abstract base type for literal constant nodes.

621 #

622 # value string C code fragment

623

624 is_literal = 1

625 nogil_check = None

626

627 def is_simple(self):

628 return 1

629

630 def analyse_types(self, env):

631 pass # Types are held in class variables

632

633 def check_const(self):

634 pass

635

636 def get_constant_c_result_code(self):

637 return self.calculate_result_code()

638

639 def calculate_result_code(self):

640 return str(self.value)

641

642 def generate_result_code(self, code):

643 pass

644

645

646 class BoolNode(ConstNode):

647 type = PyrexTypes.c_bint_type

648 # The constant value True or False

649

650 def calculate_constant_result(self):

651 self.constant_result = self.value

652

653 def compile_time_value(self, denv):

654 return self.value

655

656 def calculate_result_code(self):

657 return str(int(self.value))

658

659

660 class NullNode(ConstNode):

661 type = PyrexTypes.c_null_ptr_type

662 value = "NULL"

663 constant_result = 0

664

665 def get_constant_c_result_code(self):

666 return self.value

667

668

669 class CharNode(ConstNode):

670 type = PyrexTypes.c_char_type

671

672 def calculate_constant_result(self):

673 self.constant_result = ord(self.value)

674

675 def compile_time_value(self, denv):

676 return ord(self.value)

677

678 def calculate_result_code(self):

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

680

681

682 class IntNode(ConstNode):

683

684 # unsigned "" or "U"

685 # longness "" or "L" or "LL"

686

687 unsigned = ""

688 longness = ""

689 type = PyrexTypes.c_long_type

690

691 def coerce_to(self, dst_type, env):

692 if dst_type.is_numeric and not dst_type.is_complex:

693 self.type = PyrexTypes.c_long_type

694 return self

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

696 # when coercing to a Python type.

697 if dst_type.is_pyobject:

698 self.type = PyrexTypes.py_object_type

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

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

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

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

703

704 def coerce_to_boolean(self, env):

705 self.type = PyrexTypes.c_bint_type

706 return self

707

708 def generate_evaluation_code(self, code):

709 if self.type.is_pyobject:

710 self.result_code = code.get_py_num(self.value, self.longness)

711 else:

712 self.result_code = self.get_constant_c_result_code()

713

714 def get_constant_c_result_code(self):

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

716

717 def calculate_result_code(self):

718 return self.result_code

719

720 def calculate_constant_result(self):

721 self.constant_result = int(self.value, 0)

722

723 def compile_time_value(self, denv):

724 return int(self.value, 0)

725

726

727 class FloatNode(ConstNode):

728 type = PyrexTypes.c_double_type

729

730 def calculate_constant_result(self):

731 self.constant_result = float(self.value)

732

733 def compile_time_value(self, denv):

734 return float(self.value)

735

736 def calculate_result_code(self):

737 strval = repr(float(self.value))

738 if strval == 'nan':

739 return "(Py_HUGE_VAL * 0)"

740 elif strval == 'inf':

741 return "Py_HUGE_VAL"

742 elif strval == '-inf':

743 return "(-Py_HUGE_VAL)"

744 else:

745 return strval

746

747

748 class StringNode(ConstNode):

749 type = PyrexTypes.c_char_ptr_type

750

751 def compile_time_value(self, denv):

752 return self.value

753

754 def analyse_as_type(self, env):

755 type = PyrexTypes.parse_basic_type(self.value)

756 if type is not None:

757 return type

758 from TreeFragment import TreeFragment

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

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

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

762 sizeof_node.analyse_types(env)

763 if isinstance(sizeof_node, SizeofTypeNode):

764 return sizeof_node.arg_type

765

766 def coerce_to(self, dst_type, env):

767 if dst_type == PyrexTypes.c_char_ptr_type:

768 self.type = PyrexTypes.c_char_ptr_type

769 return self

770

771 if dst_type.is_int:

772 if not self.type.is_pyobject and len(self.value) == 1:

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

774 else:

775 error(self.pos, "Only single-character byte strings can be coerced into ints.")

776 return self

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

778 # when coercing to a Python type.

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

780 node = self.as_py_string_node(env)

781 else:

782 node = self

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

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

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

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

787

788 def as_py_string_node(self, env):

789 # Return a new StringNode with the same value as this node

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

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

792

793 def generate_evaluation_code(self, code):

794 if self.type.is_pyobject:

795 self.result_code = code.get_py_string_const(self.value)

796 else:

797 self.result_code = code.get_string_const(self.value)

798

799 def get_constant_c_result_code(self):

800 return None # FIXME

801

802 def calculate_result_code(self):

803 return self.result_code

804

805

806 class UnicodeNode(PyConstNode):

807 type = unicode_type

808

809 def coerce_to(self, dst_type, env):

810 if dst_type.is_pyobject:

811 return self

812 else:

813 error(self.pos, "Unicode objects do not support coercion to C types.")

814 return self

815

816 def generate_evaluation_code(self, code):

817 if self.type.is_pyobject:

818 self.result_code = code.get_py_string_const(self.value)

819 else:

820 self.result_code = code.get_string_const(self.value)

821

822 def calculate_result_code(self):

823 return self.result_code

824

825 def compile_time_value(self, env):

826 return self.value

827

828

829 class IdentifierStringNode(ConstNode):

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

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

832 type = PyrexTypes.py_object_type

833

834 def generate_evaluation_code(self, code):

835 if self.type.is_pyobject:

836 self.result_code = code.get_py_string_const(self.value, True)

837 else:

838 self.result_code = code.get_string_const(self.value)

839

840 def get_constant_c_result_code(self):

841 return None

842

843 def calculate_result_code(self):

844 return self.result_code

845

846

847 class LongNode(AtomicExprNode):

848 # Python long integer literal

849 #

850 # value string

851

852 def calculate_constant_result(self):

853 self.constant_result = long(self.value)

854

855 def compile_time_value(self, denv):

856 return long(self.value)

857

858 def analyse_types(self, env):

859 self.type = py_object_type

860 self.is_temp = 1

861

862 gil_message = "Constructing Python long int"

863

864 def generate_result_code(self, code):

865 code.putln(

866 '%s = PyLong_FromString((char *)"%s", 0, 0); %s' % (

867 self.result(),

868 self.value,

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

870 code.put_gotref(self.py_result())

871

872

873 class ImagNode(AtomicExprNode):

874 # Imaginary number literal

875 #

876 # value float imaginary part

877

878 type = PyrexTypes.c_double_complex_type

879

880 def calculate_constant_result(self):

881 self.constant_result = complex(0.0, self.value)

882

883 def compile_time_value(self, denv):

884 return complex(0.0, self.value)

885

886 def analyse_types(self, env):

887 self.type.create_declaration_utility_code(env)

888

889 def coerce_to(self, dst_type, env):

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

891 # when coercing to a Python type.

892 if dst_type.is_pyobject:

893 self.is_temp = 1

894 self.type = PyrexTypes.py_object_type

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

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

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

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

899

900 gil_message = "Constructing complex number"

901

902 def calculate_result_code(self):

903 if self.type.is_pyobject:

904 return self.result()

905 elif self.c99_complex:

906 return "%rj" % float(self.value)

907 else:

908 return "%s(0, %r)" % (self.type.from_parts, float(self.value))

909

910 def generate_result_code(self, code):

911 if self.type.is_pyobject:

912 code.putln(

913 "%s = PyComplex_FromDoubles(0.0, %r); %s" % (

914 self.result(),

915 float(self.value),

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

917 code.put_gotref(self.py_result())

918 else:

919 self.c99_complex = code.globalstate.directives['c99_complex']

920

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 # entry Entry Symbol table entry

928 # type_entry Entry For extension type names, the original type entry

929

930 is_name = True

931 is_cython_module = False

932 cython_attribute = None

933 lhs_of_first_assignment = False

934 is_used_as_rvalue = 0

935 entry = None

936 type_entry = None

937

938 def create_analysed_rvalue(pos, env, entry):

939 node = NameNode(pos)

940 node.analyse_types(env, entry=entry)

941 return node

942

943 def as_cython_attribute(self):

944 return self.cython_attribute

945

946 create_analysed_rvalue = staticmethod(create_analysed_rvalue)

947

948 def compile_time_value(self, denv):

949 try:

950 return denv.lookup(self.name)

951 except KeyError:

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

953

954 def get_constant_c_result_code(self):

955 if not self.entry or self.entry.type.is_pyobject:

956 return None

957 return self.entry.cname

958

959 def coerce_to(self, dst_type, env):

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

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

962 # referring to the Python builtin.

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

964 if dst_type is py_object_type:

965 entry = self.entry

966 if entry and entry.is_cfunction:

967 var_entry = entry.as_variable

968 if var_entry:

969 if var_entry.is_builtin and Options.cache_builtins:

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

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

972 node.entry = var_entry

973 node.analyse_rvalue_entry(env)

974 return node

975 return super(NameNode, self).coerce_to(dst_type, env)

976

977 def analyse_as_module(self, env):

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

979 # Returns the module scope, or None.

980 entry = self.entry

981 if not entry:

982 entry = env.lookup(self.name)

983 if entry and entry.as_module:

984 return entry.as_module

985 return None

986

987 def analyse_as_type(self, env):

988 if self.cython_attribute:

989 type = PyrexTypes.parse_basic_type(self.cython_attribute)

990 else:

991 type = PyrexTypes.parse_basic_type(self.name)

992 if type:

993 return type

994 entry = self.entry

995 if not entry:

996 entry = env.lookup(self.name)

997 if entry and entry.is_type:

998 return entry.type

999 else:

1000 return None

1001

1002 def analyse_as_extension_type(self, env):

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

1004 # Returns the extension type, or None.

1005 entry = self.entry

1006 if not entry:

1007 entry = env.lookup(self.name)

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

1009 return entry.type

1010 else:

1011 return None

1012

1013 def analyse_target_declaration(self, env):

1014 if not self.entry:

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

1016 if not self.entry:

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

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

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

1020 if self.entry.is_declared_generic:

1021 self.result_ctype = py_object_type

1022

1023 def analyse_types(self, env):

1024 if self.entry is None:

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

1026 if not self.entry:

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

1028 if not self.entry:

1029 self.type = PyrexTypes.error_type

1030 return

1031 entry = self.entry

1032 if entry:

1033 entry.used = 1

1034 if entry.type.is_buffer:

1035 import Buffer

1036 Buffer.used_buffer_aux_vars(entry)

1037 if entry.utility_code:

1038 env.use_utility_code(entry.utility_code)

1039 self.analyse_rvalue_entry(env)

1040

1041 def analyse_target_types(self, env):

1042 self.analyse_entry(env)

1043 if not self.is_lvalue():

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

1045 % self.name)

1046 self.type = PyrexTypes.error_type

1047 self.entry.used = 1

1048 if self.entry.type.is_buffer:

1049 import Buffer

1050 Buffer.used_buffer_aux_vars(self.entry)

1051

1052 def analyse_rvalue_entry(self, env):

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

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

1055 self.analyse_entry(env)

1056 entry = self.entry

1057 if entry.is_declared_generic:

1058 self.result_ctype = py_object_type

1059 if entry.is_pyglobal or entry.is_builtin:

1060 if Options.cache_builtins and entry.is_builtin:

1061 self.is_temp = 0

1062 else:

1063 self.is_temp = 1

1064 self.is_used_as_rvalue = 1

1065 env.use_utility_code(get_name_interned_utility_code)

1066

1067 def nogil_check(self, env):

1068 if self.is_used_as_rvalue:

1069 entry = self.entry

1070 if entry.is_builtin:

1071 # if not Options.cache_builtins: # cached builtins are ok

1072 self.gil_error()

1073 elif entry.is_pyglobal:

1074 self.gil_error()

1075

1076 gil_message = "Accessing Python global or builtin"

1077

1078 def analyse_entry(self, env):

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

1080 self.check_identifier_kind()

1081 entry = self.entry

1082 type = entry.type

1083 self.type = type

1084

1085 def check_identifier_kind(self):

1086 # Check that this is an appropriate kind of name for use in an

1087 # expression. Also finds the variable entry associated with

1088 # an extension type.

1089 entry = self.entry

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

1091 self.type_entry = entry

1092 if not (entry.is_const or entry.is_variable

1093 or entry.is_builtin or entry.is_cfunction):

1094 if self.entry.as_variable:

1095 self.entry = self.entry.as_variable

1096 else:

1097 error(self.pos,

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

1099

1100 def is_simple(self):

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

1102 return 1

1103

1104 def calculate_target_results(self, env):

1105 pass

1106

1107 def check_const(self):

1108 entry = self.entry

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

1110 self.not_const()

1111

1112 def check_const_addr(self):

1113 entry = self.entry

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

1115 self.addr_not_const()

1116

1117 def is_lvalue(self):

1118 return self.entry.is_variable and \

1119 not self.entry.type.is_array and \

1120 not self.entry.is_readonly

1121

1122 def is_ephemeral(self):

1123 # Name nodes are never ephemeral, even if the

1124 # result is in a temporary.

1125 return 0

1126

1127 def calculate_result_code(self):

1128 entry = self.entry

1129 if not entry:

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

1131 return entry.cname

1132

1133 def generate_result_code(self, code):

1134 assert hasattr(self, 'entry')

1135 entry = self.entry

1136 if entry is None:

1137 return # There was an error earlier

1138 if entry.is_builtin and Options.cache_builtins:

1139 return # Lookup already cached

1140 elif entry.is_pyglobal or entry.is_builtin:

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

1142 interned_cname = code.intern_identifier(self.entry.name)

1143 if entry.is_builtin:

1144 namespace = Naming.builtins_cname

1145 else: # entry.is_pyglobal

1146 namespace = entry.scope.namespace_cname

1147 code.putln(

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

1149 self.result(),

1150 namespace,

1151 interned_cname,

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

1153 code.put_gotref(self.py_result())

1154

1155 elif entry.is_local and False:

1156 # control flow not good enough yet

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

1158 if assigned is False:

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

1160 elif not Options.init_local_none and assigned is None:

1161 code.putln('if (%s == 0) { PyErr_SetString(PyExc_UnboundLocalError, "%s"); %s }' %

1162 (entry.cname, entry.name, code.error_goto(self.pos)))

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

1164

1165 def generate_assignment_code(self, rhs, code):

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

1167 entry = self.entry

1168 if entry is None:

1169 return # There was an error earlier

1170

1171 if (self.entry.type.is_ptr and isinstance(rhs, ListNode)

1172 and not self.lhs_of_first_assignment):

1173 error(self.pos, "Literal list must be assigned to pointer at time of declaration")

1174

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

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

1177 if entry.is_pyglobal:

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

1179 interned_cname = code.intern_identifier(self.entry.name)

1180 namespace = self.entry.scope.namespace_cname

1181 if entry.is_member:

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

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

1184 code.put_error_if_neg(self.pos,

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

1186 namespace,

1187 interned_cname,

1188 rhs.py_result()))

1189 rhs.generate_disposal_code(code)

1190 rhs.free_temps(code)

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

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

1193 entry.scope.parent_type.typeptr_cname)

1194 else:

1195 code.put_error_if_neg(self.pos,

1196 'PyObject_SetAttr(%s, %s, %s)' % (

1197 namespace,

1198 interned_cname,

1199 rhs.py_result()))

1200 if debug_disposal_code:

1201 print("NameNode.generate_assignment_code:")

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

1203 rhs.generate_disposal_code(code)

1204 rhs.free_temps(code)

1205 else:

1206 if self.type.is_buffer:

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

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

1209 # below) will not happen.

1210 #

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

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

1213 # per entry and coupled with it.

1214 self.generate_acquire_buffer(rhs, code)

1215

1216 if self.type.is_pyobject:

1217 rhs.make_owned_reference(code)

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

1219 #print "...from", rhs ###

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

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

1222 if entry.is_cglobal:

1223 code.put_gotref(self.py_result())

1224 if not self.lhs_of_first_assignment:

1225 if entry.is_local and not Options.init_local_none:

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

1227 if initalized is True:

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

1229 elif initalized is None:

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

1231 else:

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

1233 if entry.is_cglobal:

1234 code.put_giveref(rhs.py_result())

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

1236 if debug_disposal_code:

1237 print("NameNode.generate_assignment_code:")

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

1239 rhs.generate_post_assignment_code(code)

1240 rhs.free_temps(code)

1241

1242 def generate_acquire_buffer(self, rhs, code):

1243 # rhstmp is only used in case the rhs is a complicated expression leading to

1244 # the object, to avoid repeating the same C expression for every reference

1245 # to the rhs. It does NOT hold a reference.

1246 pretty_rhs = isinstance(rhs, NameNode) or rhs.is_temp

1247 if pretty_rhs:

1248 rhstmp = rhs.result_as(self.ctype())

1249 else:

1250 rhstmp = code.funcstate.allocate_temp(self.entry.type, manage_ref=False)

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

1252

1253 buffer_aux = self.entry.buffer_aux

1254 bufstruct = buffer_aux.buffer_info_var.cname

1255 import Buffer

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

1257 is_initialized=not self.lhs_of_first_assignment,

1258 pos=self.pos, code=code)

1259

1260 if not pretty_rhs:

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

1262 code.funcstate.release_temp(rhstmp)

1263

1264 def generate_deletion_code(self, code):

1265 if self.entry is None:

1266 return # There was an error earlier

1267 if not self.entry.is_pyglobal:

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

1269 return

1270 code.put_error_if_neg(self.pos,

1271 '__Pyx_DelAttrString(%s, "%s")' % (

1272 Naming.module_cname,

1273 self.entry.name))

1274

1275 def annotate(self, code):

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

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

1278 if self.type.is_pyobject:

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

1280 else:

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

1282

1283 class BackquoteNode(ExprNode):

1284 # `expr`

1285 #

1286 # arg ExprNode

1287

1288 subexprs = ['arg']

1289

1290 def analyse_types(self, env):

1291 self.arg.analyse_types(env)

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

1293 self.type = py_object_type

1294 self.is_temp = 1

1295

1296 gil_message = "Backquote expression"

1297

1298 def calculate_constant_result(self):

1299 self.constant_result = repr(self.arg.constant_result)

1300

1301 def generate_result_code(self, code):

1302 code.putln(

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

1304 self.result(),

1305 self.arg.py_result(),

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

1307 code.put_gotref(self.py_result())

1308

1309

1310

1311 class ImportNode(ExprNode):

1312 # Used as part of import statement implementation.

1313 # Implements result =

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

1315 #

1316 # module_name IdentifierStringNode dotted name of module

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

1318

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

1320

1321 def analyse_types(self, env):

1322 self.module_name.analyse_types(env)

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

1324 if self.name_list:

1325 self.name_list.analyse_types(env)

1326 self.name_list.coerce_to_pyobject(env)

1327 self.type = py_object_type

1328 self.is_temp = 1

1329 env.use_utility_code(import_utility_code)

1330

1331 gil_message = "Python import"

1332

1333 def generate_result_code(self, code):

1334 if self.name_list:

1335 name_list_code = self.name_list.py_result()

1336 else:

1337 name_list_code = "0"

1338 code.putln(

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

1340 self.result(),

1341 self.module_name.py_result(),

1342 name_list_code,

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

1344 code.put_gotref(self.py_result())

1345

1346

1347 class IteratorNode(ExprNode):

1348 # Used as part of for statement implementation.

1349 #

1350 # allocate_counter_temp/release_counter_temp needs to be called

1351 # by parent (ForInStatNode)

1352 #

1353 # Implements result = iter(sequence)

1354 #

1355 # sequence ExprNode

1356

1357 subexprs = ['sequence']

1358

1359 def analyse_types(self, env):

1360 self.sequence.analyse_types(env)

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

1362 self.type = py_object_type

1363 self.is_temp = 1

1364

1365 gil_message = "Iterating over Python object"

1366

1367 def allocate_counter_temp(self, code):

1368 self.counter_cname = code.funcstate.allocate_temp(

1369 PyrexTypes.c_py_ssize_t_type, manage_ref=False)

1370

1371 def release_counter_temp(self, code):

1372 code.funcstate.release_temp(self.counter_cname)

1373

1374 def generate_result_code(self, code):

1375 is_builtin_sequence = self.sequence.type is list_type or \

1376 self.sequence.type is tuple_type

1377 if is_builtin_sequence:

1378 code.putln(

1379 "if (likely(%s != Py_None)) {" % self.sequence.py_result())

1380 else:

1381 code.putln(

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

1383 self.sequence.py_result(),

1384 self.sequence.py_result()))

1385 code.putln(

1386 "%s = 0; %s = %s; __Pyx_INCREF(%s);" % (

1387 self.counter_cname,

1388 self.result(),

1389 self.sequence.py_result(),

1390 self.result()))

1391 code.putln("} else {")

1392 if is_builtin_sequence:

1393 code.putln(

1394 'PyErr_SetString(PyExc_TypeError, "\'NoneType\' object is not iterable"); %s' %

1395 code.error_goto(self.pos))

1396 else:

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

1398 self.counter_cname,

1399 self.result(),

1400 self.sequence.py_result(),

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

1402 code.put_gotref(self.py_result())

1403 code.putln("}")

1404

1405

1406 class NextNode(AtomicExprNode):

1407 # Used as part of for statement implementation.

1408 # Implements result = iterator.next()

1409 # Created during analyse_types phase.

1410 # The iterator is not owned by this node.

1411 #

1412 # iterator ExprNode

1413

1414 def __init__(self, iterator, env):

1415 self.pos = iterator.pos

1416 self.iterator = iterator

1417 self.type = py_object_type

1418 self.is_temp = 1

1419

1420 def generate_result_code(self, code):

1421 if self.iterator.sequence.type is list_type:

1422 type_checks = [(list_type, "List")]

1423 elif self.iterator.sequence.type is tuple_type:

1424 type_checks = [(tuple_type, "Tuple")]

1425 else:

1426 type_checks = [(list_type, "List"), (tuple_type, "Tuple")]

1427

1428 for py_type, prefix in type_checks:

1429 if len(type_checks) > 1:

1430 code.putln(

1431 "if (likely(Py%s_CheckExact(%s))) {" % (

1432 prefix, self.iterator.py_result()))

1433 code.putln(

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

1435 self.iterator.counter_cname,

1436 prefix,

1437 self.iterator.py_result()))

1438 code.putln(

1439 "%s = Py%s_GET_ITEM(%s, %s); __Pyx_INCREF(%s); %s++;" % (

1440 self.result(),

1441 prefix,

1442 self.iterator.py_result(),

1443 self.iterator.counter_cname,

1444 self.result(),

1445 self.iterator.counter_cname))

1446 if len(type_checks) > 1:

1447 code.put("} else ")

1448 if len(type_checks) == 1:

1449 return

1450 code.putln("{")

1451 code.putln(

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

1453 self.result(),

1454 self.iterator.py_result()))

1455 code.putln(

1456 "if (!%s) {" %

1457 self.result())

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

1459 code.putln("break;")

1460 code.putln("}")

1461 code.put_gotref(self.py_result())

1462 code.putln("}")

1463

1464

1465 class ExcValueNode(AtomicExprNode):

1466 # Node created during analyse_types phase

1467 # of an ExceptClauseNode to fetch the current

1468 # exception value.

1469

1470 def __init__(self, pos, env):

1471 ExprNode.__init__(self, pos)

1472 self.type = py_object_type

1473

1474 def set_var(self, var):

1475 self.var = var

1476

1477 def calculate_result_code(self):

1478 return self.var

1479

1480 def generate_result_code(self, code):

1481 pass

1482

1483 def analyse_types(self, env):

1484 pass

1485

1486

1487 class TempNode(ExprNode):

1488 # Node created during analyse_types phase

1489 # of some nodes to hold a temporary value.

1490 #

1491 # Note: One must call "allocate" and "release" on

1492 # the node during code generation to get/release the temp.

1493 # This is because the temp result is often used outside of

1494 # the regular cycle.

1495

1496 subexprs = []

1497

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

1499 ExprNode.__init__(self, pos)

1500 self.type = type

1501 if type.is_pyobject:

1502 self.result_ctype = py_object_type

1503 self.is_temp = 1

1504

1505 def analyse_types(self, env):

1506 return self.type

1507

1508 def generate_result_code(self, code):

1509 pass

1510

1511 def allocate(self, code):

1512 self.temp_cname = code.funcstate.allocate_temp(self.type, manage_ref=True)

1513

1514 def release(self, code):

1515 code.funcstate.release_temp(self.temp_cname)

1516 self.temp_cname = None

1517

1518 def result(self):

1519 try:

1520 return self.temp_cname

1521 except:

1522 assert False, "Remember to call allocate/release on TempNode"

1523 raise

1524

1525 # Do not participate in normal temp alloc/dealloc:

1526 def allocate_temp_result(self, code):

1527 pass

1528

1529 def release_temp_result(self, code):

1530 pass

1531

1532 class PyTempNode(TempNode):

1533 # TempNode holding a Python value.

1534

1535 def __init__(self, pos, env):

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

1537

1538

1539 #-------------------------------------------------------------------

1540 #

1541 # Trailer nodes

1542 #

1543 #-------------------------------------------------------------------

1544

1545 class IndexNode(ExprNode):

1546 # Sequence indexing.

1547 #

1548 # base ExprNode

1549 # index ExprNode

1550 # indices [ExprNode]

1551 # is_buffer_access boolean Whether this is a buffer access.

1552 #

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

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

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

1556

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

1558 indices = None

1559

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

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

1562 self._index = index

1563

1564 def calculate_constant_result(self):

1565 self.constant_result = \

1566 self.base.constant_result[self.index.constant_result]

1567

1568 def compile_time_value(self, denv):

1569 base = self.base.compile_time_value(denv)

1570 index = self.index.compile_time_value(denv)

1571 try:

1572 return base[index]

1573 except Exception, e:

1574 self.compile_time_value_error(e)

1575

1576 def is_ephemeral(self):

1577 return self.base.is_ephemeral()

1578

1579 def analyse_target_declaration(self, env):

1580 pass

1581

1582 def analyse_as_type(self, env):

1583 base_type = self.base.analyse_as_type(env)

1584 if base_type and not base_type.is_pyobject:

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

1586 return None

1587

1588 def analyse_types(self, env):

1589 self.analyse_base_and_index_types(env, getting = 1)

1590

1591 def analyse_target_types(self, env):

1592 self.analyse_base_and_index_types(env, setting = 1)

1593

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

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

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

1597 # needed.

1598

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

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

1601 # when cloning self.indices is copied.

1602 self.is_buffer_access = False

1603

1604 self.base.analyse_types(env)

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

1606 if isinstance(self.base, StringNode):

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

1608

1609 skip_child_analysis = False

1610 buffer_access = False

1611 if self.base.type.is_buffer:

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

1613 if self.indices:

1614 indices = self.indices

1615 else:

1616 if isinstance(self.index, TupleNode):

1617 indices = self.index.args

1618 else:

1619 indices = [self.index]

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

1621 buffer_access = True

1622 skip_child_analysis = True

1623 for x in indices:

1624 x.analyse_types(env)

1625 if not x.type.is_int:

1626 buffer_access = False

1627

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

1629 assert not (buffer_access and isinstance(self.index, CloneNode))

1630

1631 if buffer_access:

1632 self.indices = indices

1633 self.index = None

1634 self.type = self.base.type.dtype

1635 self.is_buffer_access = True

1636 self.buffer_type = self.base.entry.type

1637

1638 if getting and self.type.is_pyobject:

1639 self.is_temp = True

1640 if setting:

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

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

1643 else:

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

1645 else:

1646 if isinstance(self.index, TupleNode):

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

1648 elif not skip_child_analysis:

1649 self.index.analyse_types(env)

1650 self.original_index_type = self.index.type

1651 if self.base.type.is_pyobject:

1652 if self.index.type.is_int:

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

1654 else:

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

1656 self.type = py_object_type

1657 self.is_temp = 1

1658 else:

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

1660 self.type = self.base.type.base_type

1661 else:

1662 error(self.pos,

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

1664 self.base.type)

1665 self.type = PyrexTypes.error_type

1666 if self.index.type.is_pyobject:

1667 self.index = self.index.coerce_to(

1668 PyrexTypes.c_py_ssize_t_type, env)

1669 if not self.index.type.is_int:

1670 error(self.pos,

1671 "Invalid index type '%s'" %

1672 self.index.type)

1673 gil_message = "Indexing Python object"

1674

1675 def nogil_check(self, env):

1676 if self.is_buffer_access:

1677 if env.directives['boundscheck']:

1678 error(self.pos, "Cannot check buffer index bounds without gil; use boundscheck(False) directive")

1679 return

1680 elif self.type.is_pyobject:

1681 error(self.pos, "Cannot access buffer with object dtype without gil")

1682 return

1683 super(IndexNode, self).nogil_check(env)

1684

1685

1686 def check_const_addr(self):

1687 self.base.check_const_addr()

1688 self.index.check_const()

1689

1690 def is_lvalue(self):

1691 return 1

1692

1693 def calculate_result_code(self):

1694 if self.is_buffer_access:

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

1696 else:

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

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

1699

1700 def extra_index_params(self):

1701 if self.index.type.is_int:

1702 if self.original_index_type.signed:

1703 size_adjustment = ""

1704 else:

1705 size_adjustment = "+1"

1706 return ", sizeof(%s)%s, %s" % (self.original_index_type.declaration_code(""), size_adjustment, self.original_index_type.to_py_function)

1707 else:

1708 return ""

1709

1710 def generate_subexpr_evaluation_code(self, code):

1711 self.base.generate_evaluation_code(code)

1712 if not self.indices:

1713 self.index.generate_evaluation_code(code)

1714 else:

1715 for i in self.indices:

1716 i.generate_evaluation_code(code)

1717

1718 def generate_subexpr_disposal_code(self, code):

1719 self.base.generate_disposal_code(code)

1720 if not self.indices:

1721 self.index.generate_disposal_code(code)

1722 else:

1723 for i in self.indices:

1724 i.generate_disposal_code(code)

1725

1726 def free_subexpr_temps(self, code):

1727 self.base.free_temps(code)

1728 if not self.indices:

1729 self.index.free_temps(code)

1730 else:

1731 for i in self.indices:

1732 i.free_temps(code)

1733

1734 def generate_result_code(self, code):

1735 if self.is_buffer_access:

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

1737 self.put_nonecheck(code)

1738 self.buffer_ptr_code = self.buffer_lookup_code(code)

1739 if self.type.is_pyobject:

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

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

1742 code.putln("__Pyx_INCREF((PyObject*)%s);" % self.result())

1743 elif self.type.is_pyobject:

1744 if self.index.type.is_int:

1745 index_code = self.index.result()

1746 if self.base.type is list_type:

1747 function = "__Pyx_GetItemInt_List"

1748 elif self.base.type is tuple_type:

1749 function = "__Pyx_GetItemInt_Tuple"

1750 else:

1751 function = "__Pyx_GetItemInt"

1752 code.globalstate.use_utility_code(getitem_int_utility_code)

1753 else:

1754 function = "PyObject_GetItem"

1755 index_code = self.index.py_result()

1756 sign_code = ""

1757 code.putln(

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

1759 self.result(),

1760 function,

1761 self.base.py_result(),

1762 index_code,

1763 self.extra_index_params(),

1764 self.result(),

1765 code.error_goto(self.pos)))

1766 code.put_gotref(self.py_result())

1767

1768 def generate_setitem_code(self, value_code, code):

1769 if self.index.type.is_int:

1770 function = "__Pyx_SetItemInt"

1771 index_code = self.index.result()

1772 code.globalstate.use_utility_code(setitem_int_utility_code)

1773 else:

1774 index_code = self.index.py_result()

1775 if self.base.type is dict_type:

1776 function = "PyDict_SetItem"

1777 # It would seem that we could specalized lists/tuples, but that

1778 # shouldn't happen here.

1779 # Both PyList_SetItem PyTuple_SetItem and a Py_ssize_t as input,

1780 # not a PyObject*, and bad conversion here would give the wrong

1781 # exception. Also, tuples are supposed to be immutable, and raise

1782 # TypeErrors when trying to set their entries (PyTuple_SetItem

1783 # is for creating new tuples from).

1784 else:

1785 function = "PyObject_SetItem"

1786 code.putln(

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

1788 function,

1789 self.base.py_result(),

1790 index_code,

1791 value_code,

1792 self.extra_index_params(),

1793 code.error_goto(self.pos)))

1794

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

1796 # Used from generate_assignment_code and InPlaceAssignmentNode

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

1798 self.put_nonecheck(code)

1799 ptrexpr = self.buffer_lookup_code(code)

1800 if self.buffer_type.dtype.is_pyobject:

1801 # Must manage refcounts. Decref what is already there

1802 # and incref what we put in.

1803 ptr = code.funcstate.allocate_temp(self.buffer_type.buffer_ptr_type, manage_ref=False)

1804 rhs_code = rhs.result()

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

1806 code.put_gotref("*%s" % ptr)

1807 code.putln("__Pyx_DECREF(*%s); __Pyx_INCREF(%s);" % (

1808 ptr, rhs_code

1809 ))

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

1811 code.put_giveref("*%s" % ptr)

1812 code.funcstate.release_temp(ptr)

1813 else:

1814 # Simple case

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

1816

1817 def generate_assignment_code(self, rhs, code):

1818 self.generate_subexpr_evaluation_code(code)

1819 if self.is_buffer_access:

1820 self.generate_buffer_setitem_code(rhs, code)

1821 elif self.type.is_pyobject:

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

1823 else:

1824 code.putln(

1825 "%s = %s;" % (

1826 self.result(), rhs.result()))

1827 self.generate_subexpr_disposal_code(code)

1828 self.free_subexpr_temps(code)

1829 rhs.generate_disposal_code(code)

1830 rhs.free_temps(code)

1831

1832 def generate_deletion_code(self, code):

1833 self.generate_subexpr_evaluation_code(code)

1834 #if self.type.is_pyobject:

1835 if self.index.type.is_int:

1836 function = "__Pyx_DelItemInt"

1837 index_code = self.index.result()

1838 code.globalstate.use_utility_code(delitem_int_utility_code)

1839 else:

1840 index_code = self.index.py_result()

1841 if self.base.type is dict_type:

1842 function = "PyDict_DelItem"

1843 else:

1844 function = "PyObject_DelItem"

1845 code.putln(

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

1847 function,

1848 self.base.py_result(),

1849 index_code,

1850 self.extra_index_params(),

1851 code.error_goto(self.pos)))

1852 self.generate_subexpr_disposal_code(code)

1853 self.free_subexpr_temps(code)

1854

1855 def buffer_lookup_code(self, code):

1856 # Assign indices to temps

1857 index_temps = [code.funcstate.allocate_temp(i.type, manage_ref=False) for i in self.indices]

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

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

1860 # Generate buffer access code using these temps

1861 import Buffer

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

1863 # options are not propagated.

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

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

1866 index_cnames=index_temps,

1867 directives=code.globalstate.directives,

1868 pos=self.pos, code=code)

1869

1870 def put_nonecheck(self, code):

1871 code.globalstate.use_utility_code(raise_noneindex_error_utility_code)

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

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

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

1875 code.putln("}")

1876

1877 class SliceIndexNode(ExprNode):

1878 # 2-element slice indexing

1879 #

1880 # base ExprNode

1881 # start ExprNode or None

1882 # stop ExprNode or None

1883

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

1885

1886 def calculate_constant_result(self):

1887 self.constant_result = self.base.constant_result[

1888 self.start.constant_result : self.stop.constant_result]

1889

1890 def compile_time_value(self, denv):

1891 base = self.base.compile_time_value(denv)

1892 if self.start is None:

1893 start = 0

1894 else:

1895 start = self.start.compile_time_value(denv)

1896 if self.stop is None:

1897 stop = None

1898 else:

1899 stop = self.stop.compile_time_value(denv)

1900 try:

1901 return base[start:stop]

1902 except Exception, e:

1903 self.compile_time_value_error(e)

1904

1905 def analyse_target_declaration(self, env):

1906 pass

1907

1908 def analyse_target_types(self, env):

1909 self.analyse_types(env)

1910 # when assigning, we must accept any Python type

1911 if self.type.is_pyobject:

1912 self.type = py_object_type

1913

1914 def analyse_types(self, env):

1915 self.base.analyse_types(env)

1916 if self.start:

1917 self.start.analyse_types(env)

1918 if self.stop:

1919 self.stop.analyse_types(env)

1920 base_type = self.base.type

1921 if base_type.is_string:

1922 self.type = bytes_type

1923 elif base_type.is_array or base_type.is_ptr:

1924 # we need a ptr type here instead of an array type, as

1925 # array types can result in invalid type casts in the C

1926 # code

1927 self.type = PyrexTypes.CPtrType(base_type.base_type)

1928 else:

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

1930 self.type = py_object_type

1931 if base_type.is_builtin_type:

1932 # slicing builtin types returns something of the same type

1933 self.type = base_type

1934 c_int = PyrexTypes.c_py_ssize_t_type

1935 if self.start:

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

1937 if self.stop:

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

1939 self.is_temp = 1

1940

1941 nogil_check = Node.gil_error

1942 gil_message = "Slicing Python object"

1943

1944 def generate_result_code(self, code):

1945 if not self.type.is_pyobject:

1946 error(self.pos,

1947 "Slicing is not currently supported for '%s'." % self.type)

1948 return

1949 if self.base.type.is_string:

1950 if self.stop is None:

1951 code.putln(

1952 "%s = __Pyx_PyBytes_FromString(%s + %s); %s" % (

1953 self.result(),

1954 self.base.result(),

1955 self.start_code(),

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

1957 else:

1958 code.putln(

1959 "%s = __Pyx_PyBytes_FromStringAndSize(%s + %s, %s - %s); %s" % (

1960 self.result(),

1961 self.base.result(),

1962 self.start_code(),

1963 self.stop_code(),

1964 self.start_code(),

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

1966 else:

1967 code.putln(

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

1969 self.result(),

1970 self.base.py_result(),

1971 self.start_code(),

1972 self.stop_code(),

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

1974 code.put_gotref(self.py_result())

1975

1976 def generate_assignment_code(self, rhs, code):

1977 self.generate_subexpr_evaluation_code(code)

1978 if self.type.is_pyobject:

1979 code.put_error_if_neg(self.pos,

1980 "PySequence_SetSlice(%s, %s, %s, %s)" % (

1981 self.base.py_result(),

1982 self.start_code(),

1983 self.stop_code(),

1984 rhs.result()))

1985 else:

1986 start_offset = ''

1987 if self.start:

1988 start_offset = self.start_code()

1989 if start_offset == '0':

1990 start_offset = ''

1991 else:

1992 start_offset += '+'

1993 if rhs.type.is_array:

1994 array_length = rhs.type.size

1995 self.generate_slice_guard_code(code, array_length)

1996 else:

1997 error(self.pos,

1998 "Slice assignments from pointers are not yet supported.")

1999 # FIXME: fix the array size according to start/stop

2000 array_length = self.base.type.size

2001 for i in range(array_length):

2002 code.putln("%s[%s%s] = %s[%d];" % (

2003 self.base.result(), start_offset, i,

2004 rhs.result(), i))

2005 self.generate_subexpr_disposal_code(code)

2006 self.free_subexpr_temps(code)

2007 rhs.generate_disposal_code(code)

2008 rhs.free_temps(code)

2009

2010 def generate_deletion_code(self, code):

2011 if not self.base.type.is_pyobject:

2012 error(self.pos,

2013 "Deleting slices is only supported for Python types, not '%s'." % self.type)

2014 return

2015 self.generate_subexpr_evaluation_code(code)

2016 code.put_error_if_neg(self.pos,

2017 "PySequence_DelSlice(%s, %s, %s)" % (

2018 self.base.py_result(),

2019 self.start_code(),

2020 self.stop_code()))

2021 self.generate_subexpr_disposal_code(code)

2022

2023 def generate_slice_guard_code(self, code, target_size):

2024 if not self.base.type.is_array:

2025 return

2026 slice_size = self.base.type.size

2027 start = stop = None

2028 if self.stop:

2029 stop = self.stop.result()

2030 try:

2031 stop = int(stop)

2032 if stop < 0:

2033 slice_size = self.base.type.size + stop

2034 else:

2035 slice_size = stop

2036 stop = None

2037 except ValueError:

2038 pass

2039 if self.start:

2040 start = self.start.result()

2041 try:

2042 start = int(start)

2043 if start < 0:

2044 start = self.base.type.size + start

2045 slice_size -= start

2046 start = None

2047 except ValueError:

2048 pass

2049 check = None

2050 if slice_size < 0:

2051 if target_size > 0:

2052 error(self.pos, "Assignment to empty slice.")

2053 elif start is None and stop is None:

2054 # we know the exact slice length

2055 if target_size != slice_size:

2056 error(self.pos, "Assignment to slice of wrong length, expected %d, got %d" % (

2057 slice_size, target_size))

2058 elif start is not None:

2059 if stop is None:

2060 stop = slice_size

2061 check = "(%s)-(%s)" % (stop, start)

2062 else: # stop is not None:

2063 check = stop

2064 if check:

2065 code.putln("if (unlikely((%s) != %d)) {" % (check, target_size))

2066 code.putln('PyErr_Format(PyExc_ValueError, "Assignment to slice of wrong length, expected %%"PY_FORMAT_SIZE_T"d, got %%"PY_FORMAT_SIZE_T"d", (Py_ssize_t)%d, (Py_ssize_t)(%s));' % (

2067 target_size, check))

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

2069 code.putln("}")

2070

2071 def start_code(self):

2072 if self.start:

2073 return self.start.result()

2074 else:

2075 return "0"

2076

2077 def stop_code(self):

2078 if self.stop:

2079 return self.stop.result()

2080 elif self.base.type.is_array:

2081 return self.base.type.size

2082 else:

2083 return "PY_SSIZE_T_MAX"

2084

2085 def calculate_result_code(self):

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

2087 return "<unused>"

2088

2089

2090 class SliceNode(ExprNode):

2091 # start:stop:step in subscript list

2092 #

2093 # start ExprNode

2094 # stop ExprNode

2095 # step ExprNode

2096

2097 def calculate_constant_result(self):

2098 self.constant_result = self.base.constant_result[

2099 self.start.constant_result : \

2100 self.stop.constant_result : \

2101 self.step.constant_result]

2102

2103 def compile_time_value(self, denv):

2104 start = self.start.compile_time_value(denv)

2105 if self.stop is None:

2106 stop = None

2107 else:

2108 stop = self.stop.compile_time_value(denv)

2109 if self.step is None:

2110 step = None

2111 else:

2112 step = self.step.compile_time_value(denv)

2113 try:

2114 return slice(start, stop, step)

2115 except Exception, e:

2116 self.compile_time_value_error(e)

2117

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

2119

2120 def analyse_types(self, env):

2121 self.start.analyse_types(env)

2122 self.stop.analyse_types(env)

2123 self.step.analyse_types(env)

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

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

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

2127 self.type = py_object_type

2128 self.is_temp = 1

2129

2130 gil_message = "Constructing Python slice object"

2131

2132 def generate_result_code(self, code):

2133 code.putln(

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

2135 self.result(),

2136 self.start.py_result(),

2137 self.stop.py_result(),

2138 self.step.py_result(),

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

2140 code.put_gotref(self.py_result())

2141

2142

2143 class CallNode(ExprNode):

2144 def analyse_as_type_constructor(self, env):

2145 type = self.function.analyse_as_type(env)

2146 if type and type.is_struct_or_union:

2147 args, kwds = self.explicit_args_kwds()

2148 items = []

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

2150 items.append(DictItemNode(pos=arg.pos, key=IdentifierStringNode(pos=arg.pos, value=member.name), value=arg))

2151 if kwds:

2152 items += kwds.key_value_pairs

2153 self.key_value_pairs = items

2154 self.__class__ = DictNode

2155 self.analyse_types(env)

2156 self.coerce_to(type, env)

2157 return True

2158

2159 def nogil_check(self, env):

2160 func_type = self.function_type()

2161 if func_type.is_pyobject:

2162 self.gil_error()

2163 elif not getattr(func_type, 'nogil', False):

2164 self.gil_error()

2165

2166 gil_message = "Calling gil-requiring function"

2167

2168

2169 class SimpleCallNode(CallNode):

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

2171 #

2172 # function ExprNode

2173 # args [ExprNode]

2174 # arg_tuple ExprNode or None used internally

2175 # self ExprNode or None used internally

2176 # coerced_self ExprNode or None used internally

2177 # wrapper_call bool used internally

2178 # has_optional_args bool used internally

2179

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

2181

2182 self = None

2183 coerced_self = None

2184 arg_tuple = None

2185 wrapper_call = False

2186 has_optional_args = False

2187

2188 def compile_time_value(self, denv):

2189 function = self.function.compile_time_value(denv)

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

2191 try:

2192 return function(*args)

2193 except Exception, e:

2194 self.compile_time_value_error(e)

2195

2196 def analyse_as_type(self, env):

2197 attr = self.function.as_cython_attribute()

2198 if attr == 'pointer':

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

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

2201 else:

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

2203 if not type:

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

2205 else:

2206 return PyrexTypes.CPtrType(type)

2207

2208 def explicit_args_kwds(self):

2209 return self.args, None

2210

2211 def analyse_types(self, env):

2212 if self.analyse_as_type_constructor(env):

2213 return

2214 function = self.function

2215 function.is_called = 1

2216 self.function.analyse_types(env)

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

2218 # Take ownership of the object from which the attribute

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

2220 self.self = function.obj

2221 function.obj = CloneNode(self.self)

2222 func_type = self.function_type()

2223 if func_type.is_pyobject:

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

2225 self.arg_tuple.analyse_types(env)

2226 self.args = None

2227 if function.is_name and function.type_entry:

2228 # We are calling an extension type constructor. As

2229 # long as we do not support __new__(), the result type

2230 # is clear

2231 self.type = function.type_entry.type

2232 self.result_ctype = py_object_type

2233 else:

2234 self.type = py_object_type

2235 self.is_temp = 1

2236 else:

2237 for arg in self.args:

2238 arg.analyse_types(env)

2239 if self.self and func_type.args:

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

2241 expected_type = func_type.args[0].type

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

2243 expected_type, env)

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

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

2246 self.analyse_c_function_call(env)

2247

2248 def function_type(self):

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

2250 # pointer to a function if necessary.

2251 func_type = self.function.type

2252 if func_type.is_ptr:

2253 func_type = func_type.base_type

2254 return func_type

2255

2256 def analyse_c_function_call(self, env):

2257 func_type = self.function_type()

2258 # Check function type

2259 if not func_type.is_cfunction:

2260 if not func_type.is_error:

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

2262 func_type)

2263 self.type = PyrexTypes.error_type

2264 self.result_code = "<error>"

2265 return

2266 # Check no. of args

2267 max_nargs = len(func_type.args)

2268 expected_nargs = max_nargs - func_type.optional_arg_count

2269 actual_nargs = len(self.args)

2270 if actual_nargs < expected_nargs \

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

2272 expected_str = str(expected_nargs)

2273 if func_type.has_varargs:

2274 expected_str = "at least " + expected_str

2275 elif func_type.optional_arg_count:

2276 if actual_nargs < max_nargs:

2277 expected_str = "at least " + expected_str

2278 else:

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

2280 error(self.pos,

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

2282 % (expected_str, actual_nargs))

2283 self.args = None

2284 self.type = PyrexTypes.error_type

2285 self.result_code = "<error>"

2286 return

2287 if func_type.optional_arg_count and expected_nargs != actual_nargs:

2288 self.has_optional_args = 1

2289 self.is_temp = 1

2290 # Coerce arguments

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

2292 formal_type = func_type.args[i].type

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

2294 for i in range(max_nargs, actual_nargs):

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

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

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

2298 # Calc result type and code fragment

2299 self.type = func_type.return_type

2300 if self.type.is_pyobject:

2301 self.result_ctype = py_object_type

2302 self.is_temp = 1

2303 elif func_type.exception_value is not None \

2304 or func_type.exception_check:

2305 self.is_temp = 1

2306 # C++ exception handler

2307 if func_type.exception_check == '+':

2308 if func_type.exception_value is None:

2309 env.use_utility_code(cpp_exception_utility_code)

2310

2311 def calculate_result_code(self):

2312 return self.c_call_code()

2313

2314 def c_call_code(self):

2315 func_type = self.function_type()

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

2317 return "<error>"

2318 formal_args = func_type.args

2319 arg_list_code = []

2320 args = zip(formal_args, self.args)

2321 max_nargs = len(func_type.args)

2322 expected_nargs = max_nargs - func_type.optional_arg_count

2323 actual_nargs = len(self.args)

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

2325 arg_code = actual_arg.result_as(formal_arg.type)

2326 arg_list_code.append(arg_code)

2327

2328 if func_type.is_overridable:

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

2330

2331 if func_type.optional_arg_count:

2332 if expected_nargs == actual_nargs:

2333 optional_args = 'NULL'

2334 else:

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

2336 arg_list_code.append(optional_args)

2337

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

2339 arg_list_code.append(actual_arg.result())

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

2341 ', '.join(arg_list_code))

2342 # if self.wrapper_call or \

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

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

2345 return result

2346

2347 def generate_result_code(self, code):

2348 func_type = self.function_type()

2349 if func_type.is_pyobject:

2350 arg_code = self.arg_tuple.py_result()

2351 code.putln(

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

2353 self.result(),

2354 self.function.py_result(),

2355 arg_code,

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

2357 code.put_gotref(self.py_result())

2358 elif func_type.is_cfunction:

2359 if self.has_optional_args:

2360 actual_nargs = len(self.args)

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

2362 self.opt_arg_struct = code.funcstate.allocate_temp(

2363 func_type.op_arg_struct.base_type, manage_ref=True)

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

2365 self.opt_arg_struct,

2366 Naming.pyrex_prefix + "n",

2367 len(self.args) - expected_nargs))

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

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

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

2371 self.opt_arg_struct,

2372 formal_arg.name,

2373 actual_arg.result_as(formal_arg.type)))

2374 exc_checks = []

2375 if self.type.is_pyobject:

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

2377 else:

2378 exc_val = func_type.exception_value

2379 exc_check = func_type.exception_check

2380 if exc_val is not None:

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

2382 if exc_check:

2383 exc_checks.append("PyErr_Occurred()")

2384 if self.is_temp or exc_checks:

2385 rhs = self.c_call_code()

2386 if self.result():

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

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

2389 #return_type = self.type # func_type.return_type

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

2391 # "from", return_type, "to pyobject" ###

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

2393 else:

2394 lhs = ""

2395 if func_type.exception_check == '+':

2396 if func_type.exception_value is None:

2397 raise_py_exception = "__Pyx_CppExn2PyErr()"

2398 elif func_type.exception_value.type.is_pyobject:

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

2400 else:

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

2402 code.putln(

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

2404 lhs,

2405 rhs,

2406 raise_py_exception,

2407 code.error_goto(self.pos)))

2408 else:

2409 if exc_checks:

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

2411 else:

2412 goto_error = ""

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

2414 if self.type.is_pyobject and self.result():

2415 code.put_gotref(self.py_result())

2416 if self.has_optional_args:

2417 code.funcstate.release_temp(self.opt_arg_struct)

2418

2419

2420 class PythonCapiFunctionNode(ExprNode):

2421 subexprs = []

2422 def __init__(self, pos, name, func_type, utility_code = None):

2423 self.pos = pos

2424 self.name = name

2425 self.type = func_type

2426 self.utility_code = utility_code

2427

2428 def generate_result_code(self, code):

2429 if self.utility_code:

2430 code.globalstate.use_utility_code(self.utility_code)

2431

2432 def calculate_result_code(self):

2433 return self.name

2434

2435 class PythonCapiCallNode(SimpleCallNode):

2436 # Python C-API Function call (only created in transforms)

2437

2438 def __init__(self, pos, function_name, func_type,

2439 utility_code = None, **kwargs):

2440 self.type = func_type.return_type

2441 self.result_ctype = self.type

2442 self.function = PythonCapiFunctionNode(

2443 pos, function_name, func_type,

2444 utility_code = utility_code)

2445 # call this last so that we can override the constructed

2446 # attributes above with explicit keyword arguments if required

2447 SimpleCallNode.__init__(self, pos, **kwargs)

2448

2449

2450 class GeneralCallNode(CallNode):

2451 # General Python function call, including keyword,

2452 # * and ** arguments.

2453 #

2454 # function ExprNode

2455 # positional_args ExprNode Tuple of positional arguments

2456 # keyword_args ExprNode or None Dict of keyword arguments

2457 # starstar_arg ExprNode or None Dict of extra keyword args

2458

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

2460

2461 nogil_check = Node.gil_error

2462

2463 def compile_time_value(self, denv):

2464 function = self.function.compile_time_value(denv)

2465 positional_args = self.positional_args.compile_time_value(denv)

2466 keyword_args = self.keyword_args.compile_time_value(denv)

2467 starstar_arg = self.starstar_arg.compile_time_value(denv)

2468 try:

2469 keyword_args.update(starstar_arg)

2470 return function(*positional_args, **keyword_args)

2471 except Exception, e:

2472 self.compile_time_value_error(e)

2473

2474 def explicit_args_kwds(self):

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

2476 raise PostParseError(self.pos,

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

2478 return self.positional_args.args, self.keyword_args

2479

2480 def analyse_types(self, env):

2481 if self.analyse_as_type_constructor(env):

2482 return

2483 self.function.analyse_types(env)

2484 self.positional_args.analyse_types(env)

2485 if self.keyword_args:

2486 self.keyword_args.analyse_types(env)

2487 if self.starstar_arg:

2488 self.starstar_arg.analyse_types(env)

2489 if not self.function.type.is_pyobject:

2490 if hasattr(self.function, 'entry') and not self.function.entry.as_variable:

2491 error(self.pos, "Keyword arguments not allowed in cdef functions.")

2492 else:

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

2494 self.positional_args = \

2495 self.positional_args.coerce_to_pyobject(env)

2496 if self.starstar_arg:

2497 self.starstar_arg = \

2498 self.starstar_arg.coerce_to_pyobject(env)

2499 function = self.function

2500 if function.is_name and function.type_entry:

2501 # We are calling an extension type constructor. As long

2502 # as we do not support __new__(), the result type is clear

2503 self.type = function.type_entry.type

2504 self.result_ctype = py_object_type

2505 else:

2506 self.type = py_object_type

2507 self.is_temp = 1

2508

2509 def generate_result_code(self, code):

2510 if self.keyword_args and self.starstar_arg:

2511 code.put_error_if_neg(self.pos,

2512 "PyDict_Update(%s, %s)" % (

2513 self.keyword_args.py_result(),

2514 self.starstar_arg.py_result()))

2515 keyword_code = self.keyword_args.py_result()

2516 elif self.keyword_args:

2517 keyword_code = self.keyword_args.py_result()

2518 elif self.starstar_arg:

2519 keyword_code = self.starstar_arg.py_result()

2520 else:

2521 keyword_code = None

2522 if not keyword_code:

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

2524 self.function.py_result(),

2525 self.positional_args.py_result())

2526 else:

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

2528 self.function.py_result(),

2529 self.positional_args.py_result(),

2530 keyword_code)

2531 code.putln(

2532 "%s = %s; %s" % (

2533 self.result(),

2534 call_code,

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

2536 code.put_gotref(self.py_result())

2537

2538

2539 class AsTupleNode(ExprNode):

2540 # Convert argument to tuple. Used for normalising

2541 # the * argument of a function call.

2542 #

2543 # arg ExprNode

2544

2545 subexprs = ['arg']

2546

2547 def calculate_constant_result(self):

2548 self.constant_result = tuple(self.base.constant_result)

2549

2550 def compile_time_value(self, denv):

2551 arg = self.arg.compile_time_value(denv)

2552 try:

2553 return tuple(arg)

2554 except Exception, e:

2555 self.compile_time_value_error(e)

2556

2557 def analyse_types(self, env):

2558 self.arg.analyse_types(env)

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

2560 self.type = tuple_type

2561 self.is_temp = 1

2562

2563 nogil_check = Node.gil_error

2564 gil_message = "Constructing Python tuple"

2565

2566 def generate_result_code(self, code):

2567 code.putln(

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

2569 self.result(),

2570 self.arg.py_result(),

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

2572 code.put_gotref(self.py_result())

2573

2574

2575 class AttributeNode(ExprNode):

2576 # obj.attribute

2577 #

2578 # obj ExprNode

2579 # attribute string

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

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

2582 #

2583 # Used internally:

2584 #

2585 # is_py_attr boolean Is a Python getattr operation

2586 # member string C name of struct member

2587 # is_called boolean Function call is being done on result

2588 # entry Entry Symbol table entry of attribute

2589

2590 is_attribute = 1

2591 subexprs = ['obj']

2592

2593 type = PyrexTypes.error_type

2594 entry = None

2595 is_called = 0

2596 needs_none_check = True

2597

2598 def as_cython_attribute(self):

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

2600 return self.attribute

2601

2602 def coerce_to(self, dst_type, env):

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

2604 # we can create the corresponding attribute

2605 if dst_type is py_object_type:

2606 entry = self.entry

2607 if entry and entry.is_cfunction and entry.as_variable:

2608 # must be a cpdef function

2609 self.is_temp = 1

2610 self.entry = entry.as_variable

2611 self.analyse_as_python_attribute(env)

2612 return self

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

2614

2615 def calculate_constant_result(self):

2616 attr = self.attribute

2617 if attr.startswith("__") and attr.endswith("__"):

2618 return

2619 self.constant_result = getattr(self.obj.constant_result, attr)

2620

2621 def compile_time_value(self, denv):

2622 attr = self.attribute

2623 if attr.startswith("__") and attr.endswith("__"):

2624 error(self.pos,

2625 "Invalid attribute name '%s' in compile-time expression" % attr)

2626 return None

2627 obj = self.obj.compile_time_value(denv)

2628 try:

2629 return getattr(obj, attr)

2630 except Exception, e:

2631 self.compile_time_value_error(e)

2632

2633 def analyse_target_declaration(self, env):

2634 pass

2635

2636 def analyse_target_types(self, env):

2637 self.analyse_types(env, target = 1)

2638

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

2640 if self.analyse_as_cimported_attribute(env, target):

2641 return

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

2643 return

2644 self.analyse_as_ordinary_attribute(env, target)

2645

2646 def analyse_as_cimported_attribute(self, env, target):

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

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

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

2650 # returns 0.

2651 module_scope = self.obj.analyse_as_module(env)

2652 if module_scope:

2653 entry = module_scope.lookup_here(self.attribute)

2654 if entry and (

2655 entry.is_cglobal or entry.is_cfunction

2656 or entry.is_type or entry.is_const):

2657 self.mutate_into_name_node(env, entry, target)

2658 return 1

2659 return 0

2660

2661 def analyse_as_unbound_cmethod(self, env):

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

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

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

2665 # returns 0.

2666 type = self.obj.analyse_as_extension_type(env)

2667 if type:

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

2669 if entry and entry.is_cmethod:

2670 # Create a temporary entry describing the C method

2671 # as an ordinary function.

2672 ubcm_entry = Symtab.Entry(entry.name,

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

2674 entry.type)

2675 ubcm_entry.is_cfunction = 1

2676 ubcm_entry.func_cname = entry.func_cname

2677 ubcm_entry.is_unbound_cmethod = 1

2678 self.mutate_into_name_node(env, ubcm_entry, None)

2679 return 1

2680 return 0

2681

2682 def analyse_as_type(self, env):

2683 module_scope = self.obj.analyse_as_module(env)

2684 if module_scope:

2685 return module_scope.lookup_type(self.attribute)

2686 return None

2687

2688 def analyse_as_extension_type(self, env):

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

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

2691 module_scope = self.obj.analyse_as_module(env)

2692 if module_scope:

2693 entry = module_scope.lookup_here(self.attribute)

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

2695 return entry.type

2696 return None

2697

2698 def analyse_as_module(self, env):

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

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

2701 module_scope = self.obj.analyse_as_module(env)

2702 if module_scope:

2703 entry = module_scope.lookup_here(self.attribute)

2704 if entry and entry.as_module:

2705 return entry.as_module

2706 return None

2707

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

2709 # Mutate this node into a NameNode and complete the

2710 # analyse_types phase.

2711 self.__class__ = NameNode

2712 self.name = self.attribute

2713 self.entry = entry

2714 del self.obj

2715 del self.attribute

2716 if target:

2717 NameNode.analyse_target_types(self, env)

2718 else:

2719 NameNode.analyse_rvalue_entry(self, env)

2720

2721 def analyse_as_ordinary_attribute(self, env, target):

2722 self.obj.analyse_types(env)

2723 self.analyse_attribute(env)

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

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

2726 pass

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

2728 #while self.type.is_array:

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

2730 if self.is_py_attr:

2731 if not target:

2732 self.is_temp = 1

2733 self.result_ctype = py_object_type

2734

2735 def analyse_attribute(self, env):

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

2737 self.is_py_attr = 0

2738 self.member = self.attribute

2739 if self.obj.type.is_string:

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

2741 obj_type = self.obj.type

2742 if obj_type.is_ptr or obj_type.is_array:

2743 obj_type = obj_type.base_type

2744 self.op = "->"

2745 elif obj_type.is_extension_type:

2746 self.op = "->"

2747 else:

2748 self.op = "."

2749 if obj_type.has_attributes:

2750 entry = None

2751 if obj_type.attributes_known():

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

2753 if entry and entry.is_member:

2754 entry = None

2755 else:

2756 error(self.pos,

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

2758 % obj_type)

2759 self.type = PyrexTypes.error_type

2760 return

2761 self.entry = entry

2762 if entry:

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

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

2765 # methods need the normal attribute lookup

2766 # because they do not have struct entries

2767 if entry.is_variable or entry.is_cmethod:

2768 self.type = entry.type

2769 self.member = entry.cname

2770 return

2771 else:

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

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

2774 # attribute.

2775 pass

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

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

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

2779 # attribute reference.

2780 self.analyse_as_python_attribute(env)

2781

2782 def analyse_as_python_attribute(self, env):

2783 obj_type = self.obj.type

2784 self.member = self.attribute

2785 if obj_type.is_pyobject:

2786 self.type = py_object_type

2787 self.is_py_attr = 1

2788 else:

2789 if not obj_type.is_error:

2790 error(self.pos,

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

2792 (obj_type, self.attribute))

2793

2794 def nogil_check(self, env):

2795 if self.is_py_attr:

2796 self.gil_error()

2797

2798 gil_message = "Accessing Python attribute"

2799

2800 def is_simple(self):

2801 if self.obj:

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

2803 else:

2804 return NameNode.is_simple(self)

2805

2806 def is_lvalue(self):

2807 if self.obj:

2808 return 1

2809 else:

2810 return NameNode.is_lvalue(self)

2811

2812 def is_ephemeral(self):

2813 if self.obj:

2814 return self.obj.is_ephemeral()

2815 else:

2816 return NameNode.is_ephemeral(self)

2817

2818 def calculate_result_code(self):

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

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

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

2822 obj = self.obj

2823 obj_code = obj.result_as(obj.type)

2824 #print "...obj_code =", obj_code ###

2825 if self.entry and self.entry.is_cmethod:

2826 if obj.type.is_extension_type:

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

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

2829 obj.type.vtabslot_cname, self.member)

2830 else:

2831 return self.member

2832 elif obj.type.is_complex:

2833 return "__Pyx_%s_PART(%s)" % (self.member.upper(), obj_code)

2834 else:

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

2836

2837 def generate_result_code(self, code):

2838 interned_attr_cname = code.intern_identifier(self.attribute)

2839 if self.is_py_attr:

2840 code.putln(

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

2842 self.result(),

2843 self.obj.py_result(),

2844 interned_attr_cname,

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

2846 code.put_gotref(self.py_result())

2847 else:

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

2849 # a check and raise an exception

2850 if (self.obj.type.is_extension_type

2851 and self.needs_none_check

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

2853 self.put_nonecheck(code)

2854

2855 def generate_assignment_code(self, rhs, code):

2856 interned_attr_cname = code.intern_identifier(self.attribute)

2857 self.obj.generate_evaluation_code(code)

2858 if self.is_py_attr:

2859 code.put_error_if_neg(self.pos,

2860 'PyObject_SetAttr(%s, %s, %s)' % (

2861 self.obj.py_result(),

2862 interned_attr_cname,

2863 rhs.py_result()))

2864 rhs.generate_disposal_code(code)

2865 rhs.free_temps(code)

2866 else:

2867 if (self.obj.type.is_extension_type

2868 and self.needs_none_check

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

2870 self.put_nonecheck(code)

2871

2872 select_code = self.result()

2873 if self.type.is_pyobject:

2874 rhs.make_owned_reference(code)

2875 code.put_giveref(rhs.py_result())

2876 code.put_gotref(select_code)

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

2878 code.putln(

2879 "%s = %s;" % (

2880 select_code,

2881 rhs.result_as(self.ctype())))

2882 #rhs.result()))

2883 rhs.generate_post_assignment_code(code)

2884 rhs.free_temps(code)

2885 self.obj.generate_disposal_code(code)

2886 self.obj.free_temps(code)

2887

2888 def generate_deletion_code(self, code):

2889 interned_attr_cname = code.intern_identifier(self.attribute)

2890 self.obj.generate_evaluation_code(code)

2891 if self.is_py_attr:

2892 code.put_error_if_neg(self.pos,

2893 'PyObject_DelAttr(%s, %s)' % (

2894 self.obj.py_result(),

2895 interned_attr_cname))

2896 else:

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

2898 self.obj.generate_disposal_code(code)

2899 self.obj.free_temps(code)

2900

2901 def annotate(self, code):

2902 if self.is_py_attr:

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

2904 else:

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

2906

2907 def put_nonecheck(self, code):

2908 code.globalstate.use_utility_code(raise_noneattr_error_utility_code)

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

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

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

2912 code.putln("}")

2913

2914

2915 #-------------------------------------------------------------------

2916 #

2917 # Constructor nodes

2918 #

2919 #-------------------------------------------------------------------

2920

2921 class StarredTargetNode(ExprNode):

2922 # A starred expression like "*a"

2923 #

2924 # This is only allowed in sequence assignment targets such as

2925 #

2926 # a, *b = (1,2,3,4) => a = 1 ; b = [2,3,4]

2927 #

2928 # and will be removed during type analysis (or generate an error

2929 # if it's found at unexpected places).

2930 #

2931 # target ExprNode

2932

2933 subexprs = ['target']

2934 is_starred = 1

2935 type = py_object_type

2936

2937 def __init__(self, pos, target):

2938 self.pos = pos

2939 self.target = target

2940

2941 def analyse_declarations(self, env):

2942 error(self.pos, "can use starred expression only as assignment target")

2943 self.target.analyse_declarations(env)

2944

2945 def analyse_types(self, env):

2946 error(self.pos, "can use starred expression only as assignment target")

2947 self.target.analyse_types(env)

2948 self.type = self.target.type

2949

2950 def analyse_target_declaration(self, env):

2951 self.target.analyse_target_declaration(env)

2952

2953 def analyse_target_types(self, env):

2954 self.target.analyse_target_types(env)

2955 self.type = self.target.type

2956

2957 def calculate_result_code(self):

2958 return ""

2959

2960 def generate_result_code(self, code):

2961 pass

2962

2963

2964 class SequenceNode(ExprNode):

2965 # Base class for list and tuple constructor nodes.

2966 # Contains common code for performing sequence unpacking.

2967 #

2968 # args [ExprNode]

2969 # iterator ExprNode

2970 # unpacked_items [ExprNode] or None

2971 # coerced_unpacked_items [ExprNode] or None

2972

2973 subexprs = ['args']

2974

2975 is_sequence_constructor = 1

2976 unpacked_items = None

2977

2978 def compile_time_value_list(self, denv):

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

2980

2981 def replace_starred_target_node(self):

2982 # replace a starred node in the targets by the contained expression

2983 self.starred_assignment = False

2984 args = []

2985 for arg in self.args:

2986 if arg.is_starred:

2987 if self.starred_assignment:

2988 error(arg.pos, "more than 1 starred expression in assignment")

2989 self.starred_assignment = True

2990 arg = arg.target

2991 arg.is_starred = True

2992 args.append(arg)

2993 self.args = args

2994

2995 def analyse_target_declaration(self, env):

2996 self.replace_starred_target_node()

2997 for arg in self.args:

2998 arg.analyse_target_declaration(env)

2999

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

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

3002 arg = self.args[i]

3003 if not skip_children: arg.analyse_types(env)

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

3005 self.type = py_object_type

3006 self.is_temp = 1

3007

3008 def analyse_target_types(self, env):

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

3010 self.unpacked_items = []

3011 self.coerced_unpacked_items = []

3012 for arg in self.args:

3013 arg.analyse_target_types(env)

3014 if arg.is_starred:

3015 if not arg.type.assignable_from(Builtin.list_type):

3016 error(arg.pos,

3017 "starred target must have Python object (list) type")

3018 if arg.type is py_object_type:

3019 arg.type = Builtin.list_type

3020 unpacked_item = PyTempNode(self.pos, env)

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

3022 self.unpacked_items.append(unpacked_item)

3023 self.coerced_unpacked_items.append(coerced_unpacked_item)

3024 self.type = py_object_type

3025

3026 def generate_result_code(self, code):

3027 self.generate_operation_code(code)

3028

3029 def generate_assignment_code(self, rhs, code):

3030 if self.starred_assignment:

3031 self.generate_starred_assignment_code(rhs, code)

3032 else:

3033 self.generate_parallel_assignment_code(rhs, code)

3034

3035 for item in self.unpacked_items:

3036 item.release(code)

3037 rhs.free_temps(code)

3038

3039 def generate_parallel_assignment_code(self, rhs, code):

3040 # Need to work around the fact that generate_evaluation_code

3041 # allocates the temps in a rather hacky way -- the assignment

3042 # is evaluated twice, within each if-block.

3043

3044 code.globalstate.use_utility_code(unpacking_utility_code)

3045

3046 if rhs.type is tuple_type:

3047 tuple_check = "likely(%s != Py_None)"

3048 else:

3049 tuple_check = "PyTuple_CheckExact(%s)"

3050 code.putln(

3051 "if (%s && likely(PyTuple_GET_SIZE(%s) == %s)) {" % (

3052 tuple_check % rhs.py_result(),

3053 rhs.py_result(),

3054 len(self.args)))

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

3056 for item in self.unpacked_items:

3057 item.allocate(code)

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

3059 item = self.unpacked_items[i]

3060 code.put(

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

3062 item.result(),

3063 i))

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

3065 value_node = self.coerced_unpacked_items[i]

3066 value_node.generate_evaluation_code(code)

3067 rhs.generate_disposal_code(code)

3068

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

3070 self.args[i].generate_assignment_code(

3071 self.coerced_unpacked_items[i], code)

3072

3073 code.putln("} else {")

3074

3075 if rhs.type is tuple_type:

3076 code.globalstate.use_utility_code(tuple_unpacking_error_code)

3077 code.putln("__Pyx_UnpackTupleError(%s, %s);" % (

3078 rhs.py_result(), len(self.args)))

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

3080 else:

3081 self.iterator.allocate(code)

3082 code.putln(

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

3084 self.iterator.result(),

3085 rhs.py_result(),

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

3087 code.put_gotref(self.iterator.py_result())

3088 rhs.generate_disposal_code(code)

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

3090 item = self.unpacked_items[i]

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

3092 self.iterator.py_result(), i)

3093 code.putln(

3094 "%s = %s; %s" % (

3095 item.result(),

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

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

3098 code.put_gotref(item.py_result())

3099 value_node = self.coerced_unpacked_items[i]

3100 value_node.generate_evaluation_code(code)

3101 code.put_error_if_neg(self.pos,

3102 "__Pyx_EndUnpack(%s)" % (

3103 self.iterator.py_result()))

3104 if debug_disposal_code:

3105 print("UnpackNode.generate_assignment_code:")

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

3107 self.iterator.generate_disposal_code(code)

3108 self.iterator.free_temps(code)

3109 self.iterator.release(code)

3110

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

3112 self.args[i].generate_assignment_code(

3113 self.coerced_unpacked_items[i], code)

3114

3115 code.putln("}")

3116

3117 def generate_starred_assignment_code(self, rhs, code):

3118 code.globalstate.use_utility_code(unpacking_utility_code)

3119

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

3121 if arg.is_starred:

3122 starred_target = self.unpacked_items[i]

3123 fixed_args_left = self.args[:i]

3124 fixed_args_right = self.args[i+1:]

3125 break

3126

3127 self.iterator.allocate(code)

3128 code.putln(

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

3130 self.iterator.result(),

3131 rhs.py_result(),

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

3133 code.put_gotref(self.iterator.py_result())

3134 rhs.generate_disposal_code(code)

3135

3136 for item in self.unpacked_items:

3137 item.allocate(code)

3138 for i in range(len(fixed_args_left)):

3139 item = self.unpacked_items[i]

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

3141 self.iterator.py_result(), i)

3142 code.putln(

3143 "%s = %s; %s" % (

3144 item.result(),

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

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

3147 code.put_gotref(item.py_result())

3148 value_node = self.coerced_unpacked_items[i]

3149 value_node.generate_evaluation_code(code)

3150

3151 target_list = starred_target.result()

3152 code.putln("%s = PySequence_List(%s); %s" % (

3153 target_list, self.iterator.py_result(),

3154 code.error_goto_if_null(target_list, self.pos)))

3155 code.put_gotref(target_list)

3156 if fixed_args_right:

3157 code.globalstate.use_utility_code(raise_need_more_values_to_unpack)

3158 unpacked_right_args = self.unpacked_items[-len(fixed_args_right):]

3159 code.putln("if (unlikely(PyList_GET_SIZE(%s) < %d)) {" % (

3160 (target_list, len(unpacked_right_args))))

3161 code.put("__Pyx_RaiseNeedMoreValuesError(%d+PyList_GET_SIZE(%s)); %s" % (

3162 len(fixed_args_left), target_list,

3163 code.error_goto(self.pos)))

3164 code.putln('}')

3165 for i, (arg, coerced_arg) in enumerate(zip(unpacked_right_args[::-1],

3166 self.coerced_unpacked_items[::-1])):

3167 code.putln(

3168 "%s = PyList_GET_ITEM(%s, PyList_GET_SIZE(%s)-1); " % (

3169 arg.py_result(),

3170 target_list, target_list))

3171 # resize the list the hard way

3172 code.putln("((PyVarObject*)%s)->ob_size--;" % target_list)

3173 code.put_gotref(arg.py_result())

3174 coerced_arg.generate_evaluation_code(code)

3175

3176 self.iterator.generate_disposal_code(code)

3177 self.iterator.free_temps(code)

3178 self.iterator.release(code)

3179

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

3181 self.args[i].generate_assignment_code(

3182 self.coerced_unpacked_items[i], code)

3183

3184 def annotate(self, code):

3185 for arg in self.args:

3186 arg.annotate(code)

3187 if self.unpacked_items:

3188 for arg in self.unpacked_items:

3189 arg.annotate(code)

3190 for arg in self.coerced_unpacked_items:

3191 arg.annotate(code)

3192

3193

3194 class TupleNode(SequenceNode):

3195 # Tuple constructor.

3196

3197 gil_message = "Constructing Python tuple"

3198

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

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

3201 self.is_temp = 0

3202 self.is_literal = 1

3203 else:

3204 SequenceNode.analyse_types(self, env, skip_children)

3205 self.type = tuple_type

3206

3207 def calculate_result_code(self):

3208 if len(self.args) > 0:

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

3210 else:

3211 return Naming.empty_tuple

3212

3213 def calculate_constant_result(self):

3214 self.constant_result = tuple([

3215 arg.constant_result for arg in self.args])

3216

3217 def compile_time_value(self, denv):

3218 values = self.compile_time_value_list(denv)

3219 try:

3220 return tuple(values)

3221 except Exception, e:

3222 self.compile_time_value_error(e)

3223

3224 def generate_operation_code(self, code):

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

3226 # result_code is Naming.empty_tuple

3227 return

3228 code.putln(

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

3230 self.result(),

3231 len(self.args),

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

3233 code.put_gotref(self.py_result())

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

3235 arg = self.args[i]

3236 if not arg.result_in_temp():

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

3238 code.putln(

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

3240 self.result(),

3241 i,

3242 arg.py_result()))

3243 code.put_giveref(arg.py_result())

3244

3245 def generate_subexpr_disposal_code(self, code):

3246 # We call generate_post_assignment_code here instead

3247 # of generate_disposal_code, because values were stored

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

3249 for arg in self.args:

3250 arg.generate_post_assignment_code(code)

3251 # Should NOT call free_temps -- this is invoked by the default

3252 # generate_evaluation_code which will do that.

3253

3254

3255 class ListNode(SequenceNode):

3256 # List constructor.

3257

3258 # obj_conversion_errors [PyrexError] used internally

3259 # orignial_args [ExprNode] used internally

3260

3261 gil_message = "Constructing Python list"

3262

3263 def analyse_expressions(self, env):

3264 SequenceNode.analyse_expressions(self, env)

3265 self.coerce_to_pyobject(env)

3266

3267 def analyse_types(self, env):

3268 hold_errors()

3269 self.original_args = list(self.args)

3270 SequenceNode.analyse_types(self, env)

3271 self.type = list_type

3272 self.obj_conversion_errors = held_errors()

3273 release_errors(ignore=True)

3274

3275 def coerce_to(self, dst_type, env):

3276 if dst_type.is_pyobject:

3277 for err in self.obj_conversion_errors:

3278 report_error(err)

3279 self.obj_conversion_errors = []

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

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

3282 elif dst_type.is_ptr:

3283 base_type = dst_type.base_type

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

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

3286 arg = self.args[i]

3287 if isinstance(arg, CoerceToPyTypeNode):

3288 arg = arg.arg

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

3290 elif dst_type.is_struct:

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

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

3293 else:

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

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

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

3297 if isinstance(arg, CoerceToPyTypeNode):

3298 arg = arg.arg

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

3300 self.type = dst_type

3301 else:

3302 self.type = error_type

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

3304 return self

3305

3306 def release_temp(self, env):

3307 if self.type.is_array:

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

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

3310 pass

3311 else:

3312 SequenceNode.release_temp(self, env)

3313

3314 def calculate_constant_result(self):

3315 self.constant_result = [

3316 arg.constant_result for arg in self.args]

3317

3318 def compile_time_value(self, denv):

3319 return self.compile_time_value_list(denv)

3320

3321 def generate_operation_code(self, code):

3322 if self.type.is_pyobject:

3323 for err in self.obj_conversion_errors:

3324 report_error(err)

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

3326 (self.result(),

3327 len(self.args),

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

3329 code.put_gotref(self.py_result())

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

3331 arg = self.args[i]

3332 #if not arg.is_temp:

3333 if not arg.result_in_temp():

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

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

3336 (self.result(),

3337 i,

3338 arg.py_result()))

3339 code.put_giveref(arg.py_result())

3340 elif self.type.is_array:

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

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

3343 self.result(),

3344 i,

3345 arg.result()))

3346 elif self.type.is_struct:

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

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

3349 self.result(),

3350 member.cname,

3351 arg.result()))

3352 else:

3353 raise InternalError("List type never specified")

3354

3355 def generate_subexpr_disposal_code(self, code):

3356 # We call generate_post_assignment_code here instead

3357 # of generate_disposal_code, because values were stored

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

3359 for arg in self.args:

3360 arg.generate_post_assignment_code(code)

3361 # Should NOT call free_temps -- this is invoked by the default

3362 # generate_evaluation_code which will do that.

3363

3364

3365 class ComprehensionNode(ExprNode):

3366 subexprs = ["target"]

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

3368

3369 def analyse_types(self, env):

3370 self.target.analyse_expressions(env)

3371 self.type = self.target.type

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

3373 self.loop.analyse_declarations(env)

3374 self.loop.analyse_expressions(env)

3375

3376 def calculate_result_code(self):

3377 return self.target.result()

3378

3379 def generate_result_code(self, code):

3380 self.generate_operation_code(code)

3381

3382 def generate_operation_code(self, code):

3383 self.loop.generate_execution_code(code)

3384

3385 def annotate(self, code):

3386 self.loop.annotate(code)

3387

3388

3389 class ComprehensionAppendNode(ExprNode):

3390 # Need to be careful to avoid infinite recursion:

3391 # target must not be in child_attrs/subexprs

3392 subexprs = ['expr']

3393

3394 def analyse_types(self, env):

3395 self.expr.analyse_types(env)

3396 if not self.expr.type.is_pyobject:

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

3398 self.type = PyrexTypes.c_int_type

3399 self.is_temp = 1

3400

3401 def generate_result_code(self, code):

3402 if self.target.type is list_type:

3403 function = "PyList_Append"

3404 elif self.target.type is set_type:

3405 function = "PySet_Add"

3406 else:

3407 raise InternalError(

3408 "Invalid type for comprehension node: %s" % self.target.type)

3409

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

3411 (self.result(),

3412 function,

3413 self.target.result(),

3414 self.expr.result(),

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

3416

3417 class DictComprehensionAppendNode(ComprehensionAppendNode):

3418 subexprs = ['key_expr', 'value_expr']

3419

3420 def analyse_types(self, env):

3421 self.key_expr.analyse_types(env)

3422 if not self.key_expr.type.is_pyobject:

3423 self.key_expr = self.key_expr.coerce_to_pyobject(env)

3424 self.value_expr.analyse_types(env)

3425 if not self.value_expr.type.is_pyobject:

3426 self.value_expr = self.value_expr.coerce_to_pyobject(env)

3427 self.type = PyrexTypes.c_int_type

3428 self.is_temp = 1

3429

3430 def generate_result_code(self, code):

3431 code.putln("%s = PyDict_SetItem(%s, (PyObject*)%s, (PyObject*)%s); %s" %

3432 (self.result(),

3433 self.target.result(),

3434 self.key_expr.result(),

3435 self.value_expr.result(),

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

3437

3438

3439 class SetNode(ExprNode):

3440 # Set constructor.

3441

3442 subexprs = ['args']

3443

3444 gil_message = "Constructing Python set"

3445

3446 def analyse_types(self, env):

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

3448 arg = self.args[i]

3449 arg.analyse_types(env)

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

3451 self.type = set_type

3452 self.is_temp = 1

3453

3454 def calculate_constant_result(self):

3455 self.constant_result = set([

3456 arg.constant_result for arg in self.args])

3457

3458 def compile_time_value(self, denv):

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

3460 try:

3461 return set(values)

3462 except Exception, e:

3463 self.compile_time_value_error(e)

3464

3465 def generate_evaluation_code(self, code):

3466 code.globalstate.use_utility_code(Builtin.py23_set_utility_code)

3467 self.allocate_temp_result(code)

3468 code.putln(

3469 "%s = PySet_New(0); %s" % (

3470 self.result(),

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

3472 code.put_gotref(self.py_result())

3473 for arg in self.args:

3474 arg.generate_evaluation_code(code)

3475 code.putln(

3476 code.error_goto_if_neg(

3477 "PySet_Add(%s, %s)" % (self.result(), arg.py_result()),

3478 self.pos))

3479 arg.generate_disposal_code(code)

3480 arg.free_temps(code)

3481

3482

3483 class DictNode(ExprNode):

3484 # Dictionary constructor.

3485 #

3486 # key_value_pairs [DictItemNode]

3487 #

3488 # obj_conversion_errors [PyrexError] used internally

3489

3490 subexprs = ['key_value_pairs']

3491

3492 def calculate_constant_result(self):

3493 self.constant_result = dict([

3494 item.constant_result for item in self.key_value_pairs])

3495

3496 def compile_time_value(self, denv):

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

3498 for item in self.key_value_pairs]

3499 try:

3500 return dict(pairs)

3501 except Exception, e:

3502 self.compile_time_value_error(e)

3503

3504 def analyse_types(self, env):

3505 hold_errors()

3506 self.type = dict_type

3507 for item in self.key_value_pairs:

3508 item.analyse_types(env)

3509 self.obj_conversion_errors = held_errors()

3510 release_errors(ignore=True)

3511 self.is_temp = 1

3512

3513 def coerce_to(self, dst_type, env):

3514 if dst_type.is_pyobject:

3515 self.release_errors()

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

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

3518 elif dst_type.is_struct_or_union:

3519 self.type = dst_type

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

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

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

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

3524 for item in self.key_value_pairs:

3525 if isinstance(item.key, CoerceToPyTypeNode):

3526 item.key = item.key.arg

3527 if not isinstance(item.key, (StringNode, IdentifierStringNode)):

3528 error(item.key.pos, "Invalid struct field identifier")

3529 item.key = IdentifierStringNode(item.key.pos, value="<error>")

3530 else:

3531 member = dst_type.scope.lookup_here(item.key.value)

3532 if not member:

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

3534 else:

3535 value = item.value

3536 if isinstance(value, CoerceToPyTypeNode):

3537 value = value.arg

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

3539 else:

3540 self.type = error_type

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

3542 return self

3543

3544 def release_errors(self):

3545 for err in self.obj_conversion_errors:

3546 report_error(err)

3547 self.obj_conversion_errors = []

3548

3549 gil_message = "Constructing Python dict"

3550

3551 def generate_evaluation_code(self, code):

3552 # Custom method used here because key-value

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

3554 code.mark_pos(self.pos)

3555 self.allocate_temp_result(code)

3556 if self.type.is_pyobject:

3557 self.release_errors()

3558 code.putln(

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

3560 self.result(),

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

3562 code.put_gotref(self.py_result())

3563 for item in self.key_value_pairs:

3564 item.generate_evaluation_code(code)

3565 if self.type.is_pyobject:

3566 code.put_error_if_neg(self.pos,

3567 "PyDict_SetItem(%s, %s, %s)" % (

3568 self.result(),

3569 item.key.py_result(),

3570 item.value.py_result()))

3571 else:

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

3573 self.result(),

3574 item.key.value,

3575 item.value.result()))

3576 item.generate_disposal_code(code)

3577 item.free_temps(code)

3578

3579 def annotate(self, code):

3580 for item in self.key_value_pairs:

3581 item.annotate(code)

3582

3583 class DictItemNode(ExprNode):

3584 # Represents a single item in a DictNode

3585 #

3586 # key ExprNode

3587 # value ExprNode

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

3589

3590 nogil_check = None # Parent DictNode takes care of it

3591

3592 def calculate_constant_result(self):

3593 self.constant_result = (

3594 self.key.constant_result, self.value.constant_result)

3595

3596 def analyse_types(self, env):

3597 self.key.analyse_types(env)

3598 self.value.analyse_types(env)

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

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

3601

3602 def generate_evaluation_code(self, code):

3603 self.key.generate_evaluation_code(code)

3604 self.value.generate_evaluation_code(code)

3605

3606 def generate_disposal_code(self, code):

3607 self.key.generate_disposal_code(code)

3608 self.value.generate_disposal_code(code)

3609

3610 def free_temps(self, code):

3611 self.key.free_temps(code)

3612 self.value.free_temps(code)

3613

3614 def __iter__(self):

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

3616

3617

3618 class ClassNode(ExprNode):

3619 # Helper class used in the implementation of Python

3620 # class definitions. Constructs a class object given

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

3622 #

3623 # name EncodedString Name of the class

3624 # bases ExprNode Base class tuple

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

3626 # doc ExprNode or None Doc string

3627 # module_name string Name of defining module

3628

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

3630

3631 def analyse_types(self, env):

3632 self.bases.analyse_types(env)

3633 if self.doc:

3634 self.doc.analyse_types(env)

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

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

3637 self.type = py_object_type

3638 self.is_temp = 1

3639 env.use_utility_code(create_class_utility_code);

3640

3641 gil_message = "Constructing Python class"

3642

3643 def generate_result_code(self, code):

3644 cname = code.intern_identifier(self.name)

3645 if self.doc:

3646 code.put_error_if_neg(self.pos,

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

3648 self.dict.py_result(),

3649 self.doc.py_result()))

3650 code.putln(

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

3652 self.result(),

3653 self.bases.py_result(),

3654 self.dict.py_result(),

3655 cname,

3656 self.module_name,

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

3658 code.put_gotref(self.py_result())

3659

3660

3661 class UnboundMethodNode(ExprNode):

3662 # Helper class used in the implementation of Python

3663 # class definitions. Constructs an unbound method

3664 # object from a class and a function.

3665 #

3666 # function ExprNode Function object

3667

3668 subexprs = ['function']

3669

3670 def analyse_types(self, env):

3671 self.function.analyse_types(env)

3672 self.type = py_object_type

3673 self.is_temp = 1

3674

3675 gil_message = "Constructing an unbound method"

3676

3677 def generate_result_code(self, code):

3678 class_cname = code.pyclass_stack[-1].classobj.result()

3679 code.putln(

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

3681 self.result(),

3682 self.function.py_result(),

3683 class_cname,

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

3685 code.put_gotref(self.py_result())

3686

3687 class PyCFunctionNode(AtomicExprNode):

3688 # Helper class used in the implementation of Python

3689 # class definitions. Constructs a PyCFunction object

3690 # from a PyMethodDef struct.

3691 #

3692 # pymethdef_cname string PyMethodDef structure

3693

3694 def analyse_types(self, env):

3695 self.type = py_object_type

3696 self.is_temp = 1

3697

3698 gil_message = "Constructing Python function"

3699

3700 def generate_result_code(self, code):

3701 code.putln(

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

3703 self.result(),

3704 self.pymethdef_cname,

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

3706 code.put_gotref(self.py_result())

3707

3708 #-------------------------------------------------------------------

3709 #

3710 # Unary operator nodes

3711 #

3712 #-------------------------------------------------------------------

3713

3714 compile_time_unary_operators = {

3715 'not': operator.not_,

3716 '~': operator.inv,

3717 '-': operator.neg,

3718 '+': operator.pos,

3719 }

3720

3721 class UnopNode(ExprNode):

3722 # operator string

3723 # operand ExprNode

3724 #

3725 # Processing during analyse_expressions phase:

3726 #

3727 # analyse_c_operation

3728 # Called when the operand is not a pyobject.

3729 # - Check operand type and coerce if needed.

3730 # - Determine result type and result code fragment.

3731 # - Allocate temporary for result if needed.

3732

3733 subexprs = ['operand']

3734 infix = True

3735

3736 def calculate_constant_result(self):

3737 func = compile_time_unary_operators[self.operator]

3738 self.constant_result = func(self.operand.constant_result)

3739

3740 def compile_time_value(self, denv):

3741 func = compile_time_unary_operators.get(self.operator)

3742 if not func:

3743 error(self.pos,

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

3745 % self.operator)

3746 operand = self.operand.compile_time_value(denv)

3747 try:

3748 return func(operand)

3749 except Exception, e:

3750 self.compile_time_value_error(e)

3751

3752 def analyse_types(self, env):

3753 self.operand.analyse_types(env)

3754 if self.is_py_operation():

3755 self.coerce_operand_to_pyobject(env)

3756 self.type = py_object_type

3757 self.is_temp = 1

3758 else:

3759 self.analyse_c_operation(env)

3760

3761 def check_const(self):

3762 self.operand.check_const()

3763

3764 def is_py_operation(self):

3765 return self.operand.type.is_pyobject

3766

3767 def nogil_check(self, env):

3768 if self.is_py_operation():

3769 self.gil_error()

3770

3771 def coerce_operand_to_pyobject(self, env):

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

3773

3774 def generate_result_code(self, code):

3775 if self.operand.type.is_pyobject:

3776 self.generate_py_operation_code(code)

3777

3778 def generate_py_operation_code(self, code):

3779 function = self.py_operation_function()

3780 code.putln(

3781 "%s = %s(%s); %s" % (

3782 self.result(),

3783 function,

3784 self.operand.py_result(),

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

3786 code.put_gotref(self.py_result())

3787

3788 def type_error(self):

3789 if not self.operand.type.is_error:

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

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

3792 self.type = PyrexTypes.error_type

3793

3794

3795 class NotNode(ExprNode):

3796 # 'not' operator

3797 #

3798 # operand ExprNode

3799

3800 def calculate_constant_result(self):

3801 self.constant_result = not self.operand.constant_result

3802

3803 def compile_time_value(self, denv):

3804 operand = self.operand.compile_time_value(denv)

3805 try:

3806 return not operand

3807 except Exception, e:

3808 self.compile_time_value_error(e)

3809

3810 subexprs = ['operand']

3811

3812 def analyse_types(self, env):

3813 self.operand.analyse_types(env)

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

3815 self.type = PyrexTypes.c_bint_type

3816

3817 def calculate_result_code(self):

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

3819

3820 def generate_result_code(self, code):

3821 pass

3822

3823

3824 class UnaryPlusNode(UnopNode):

3825 # unary '+' operator

3826

3827 operator = '+'

3828

3829 def analyse_c_operation(self, env):

3830 self.type = self.operand.type

3831

3832 def py_operation_function(self):

3833 return "PyNumber_Positive"

3834

3835 def calculate_result_code(self):

3836 return self.operand.result()

3837

3838

3839 class UnaryMinusNode(UnopNode):

3840 # unary '-' operator

3841

3842 operator = '-'

3843

3844 def analyse_c_operation(self, env):

3845 if self.operand.type.is_numeric:

3846 self.type = self.operand.type

3847 else:

3848 self.type_error()

3849 if self.type.is_complex:

3850 self.infix = env.directives['c99_complex']

3851

3852 def py_operation_function(self):

3853 return "PyNumber_Negative"

3854

3855 def calculate_result_code(self):

3856 if self.infix:

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

3858 else:

3859 return "%s(%s)" % (self.operand.type.unary_op('-'), self.operand.result())

3860

3861 class TildeNode(UnopNode):

3862 # unary '~' operator

3863

3864 def analyse_c_operation(self, env):

3865 if self.operand.type.is_int:

3866 self.type = self.operand.type

3867 else:

3868 self.type_error()

3869

3870 def py_operation_function(self):

3871 return "PyNumber_Invert"

3872

3873 def calculate_result_code(self):

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

3875

3876

3877 class AmpersandNode(ExprNode):

3878 # The C address-of operator.

3879 #

3880 # operand ExprNode

3881

3882 subexprs = ['operand']

3883

3884 def analyse_types(self, env):

3885 self.operand.analyse_types(env)

3886 argtype = self.operand.type

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

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

3889 return

3890 if argtype.is_pyobject:

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

3892 return

3893 self.type = PyrexTypes.c_ptr_type(argtype)

3894

3895 def check_const(self):

3896 self.operand.check_const_addr()

3897

3898 def error(self, mess):

3899 error(self.pos, mess)

3900 self.type = PyrexTypes.error_type

3901 self.result_code = "<error>"

3902

3903 def calculate_result_code(self):

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

3905

3906 def generate_result_code(self, code):

3907 pass

3908

3909

3910 unop_node_classes = {

3911 "+": UnaryPlusNode,

3912 "-": UnaryMinusNode,

3913 "~": TildeNode,

3914 }

3915

3916 def unop_node(pos, operator, operand):

3917 # Construct unnop node of appropriate class for

3918 # given operator.

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

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

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

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

3923 return unop_node_classes[operator](pos,

3924 operator = operator,

3925 operand = operand)

3926

3927

3928 class TypecastNode(ExprNode):

3929 # C type cast

3930 #

3931 # operand ExprNode

3932 # base_type CBaseTypeNode

3933 # declarator CDeclaratorNode

3934 #

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

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

3937

3938 subexprs = ['operand']

3939 base_type = declarator = type = None

3940

3941 def analyse_types(self, env):

3942 if self.type is None:

3943 base_type = self.base_type.analyse(env)

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

3945 if self.type.is_cfunction:

3946 error(self.pos,

3947 "Cannot cast to a function type")

3948 self.type = PyrexTypes.error_type

3949 self.operand.analyse_types(env)

3950 to_py = self.type.is_pyobject

3951 from_py = self.operand.type.is_pyobject

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

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

3954 if to_py and not from_py:

3955 if (self.operand.type.to_py_function and

3956 self.operand.type.create_to_py_utility_code(env)):

3957 self.result_ctype = py_object_type

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

3959 else:

3960 if not (self.operand.type.is_ptr and self.operand.type.base_type.is_void):

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

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

3963 elif from_py and not to_py:

3964 if self.type.from_py_function:

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

3966 elif self.type.is_ptr and not (self.type.base_type.is_void or self.type.base_type.is_struct):

3967 error(self.pos, "Python objects cannot be casted to pointers of primitive types")

3968 else:

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

3970 elif from_py and to_py:

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

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