cython-devel: b9d8cecc8975 Cython/Compiler/ExprNodes.py

Cython has moved to github.

cython-devel

view Cython/Compiler/ExprNodes.py @ 2194:b9d8cecc8975

general optimisation support for calls to builtin types and their methods

currently providing optimisations for
- getattr(o,a)
- getattr(o,a,d)
- X.append(o)
- L.append(o)
- list.append(L,x)

author	Stefan Behnel <scoder@users.berlios.de>
date	Sun Mar 29 13:27:55 2009 +0200 (3 years ago)
parents	2f3176c9ae7f
children	222e9c9a8967

line source

1 #

2 # Pyrex - Parse tree nodes for expressions

3 #

5 import operator

7 from Errors import error, warning, InternalError

8 from Errors import hold_errors, release_errors, held_errors, report_error

9 from Cython.Utils import UtilityCode

10 import StringEncoding

11 import Naming

12 from Nodes import Node

13 import PyrexTypes

14 from PyrexTypes import py_object_type, c_long_type, typecast, error_type

15 from Builtin import list_type, tuple_type, set_type, dict_type, unicode_type

16 import Builtin

17 import Symtab

18 import Options

19 from Annotate import AnnotationItem

21 from Cython.Debugging import print_call_chain

22 from DebugFlags import debug_disposal_code, debug_temp_alloc, \

23 debug_coercion

25 try:

26 set

27 except NameError:

28 from sets import Set as set

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

31 not_a_constant = NotConstant()

32 constant_value_not_set = object()

34 class ExprNode(Node):

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

36 # type PyrexType Type of the result

37 # result_code string Code fragment

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

39 # is_temp boolean Result is in a temporary variable

40 # is_sequence_constructor

41 # boolean Is a list or tuple constructor expression

42 # saved_subexpr_nodes

43 # [ExprNode or [ExprNode or None] or None]

44 # Cached result of subexpr_nodes()

46 result_ctype = None

47 type = None

49 # The Analyse Expressions phase for expressions is split

50 # into two sub-phases:

51 #

52 # Analyse Types

53 # Determines the result type of the expression based

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

55 # coercion nodes into the expression tree where needed.

56 # Marks nodes which will need to have temporary variables

57 # allocated.

58 #

59 # Allocate Temps

60 # Allocates temporary variables where needed, and fills

61 # in the result_code field of each node.

62 #

63 # ExprNode provides some convenience routines which

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

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

66 # coercion nodes need to be added around the expression

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

68 # should be invoked separately.

69 #

70 # Framework code in ExprNode provides much of the common

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

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

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

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

75 #

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

77 # Their responsibilities are as follows.

78 #

79 # Declaration Analysis phase

80 #

81 # analyse_target_declaration

82 # Called during the Analyse Declarations phase to analyse

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

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

85 # implement it.

86 #

87 # Expression Analysis phase

88 #

89 # analyse_types

90 # - Call analyse_types on all sub-expressions.

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

92 # sub-expressions where needed.

93 # - Set the type of this node.

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

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

96 #

97 # analyse_target_types

98 # Called during the Analyse Types phase to analyse

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

100 # statement. Similar responsibilities to analyse_types.

101 #

102 # allocate_temps

103 # - Call allocate_temps for all sub-nodes.

104 # - Call allocate_temp for this node.

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

106 # all sub-expressions.

107 #

108 # allocate_target_temps

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

110 # temps used during assignment.

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

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

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

114 # temps used during assignment.

115 #

116 # target_code

117 # Called by the default implementation of allocate_target_temps.

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

119 # implementation calls calculate_result_code.

120 #

121 # check_const

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

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

124 # otherwise call not_const.

125 #

126 # The default implementation of check_const

127 # assumes that the expression is not constant.

128 #

129 # check_const_addr

130 # - Same as check_const, except check that the

131 # expression is a C lvalue whose address is

132 # constant. Otherwise, call addr_not_const.

133 #

134 # The default implementation of calc_const_addr

135 # assumes that the expression is not a constant

136 # lvalue.

137 #

138 # Code Generation phase

139 #

140 # generate_evaluation_code

141 # - Call generate_evaluation_code for sub-expressions.

142 # - Perform the functions of generate_result_code

143 # (see below).

144 # - If result is temporary, call generate_disposal_code

145 # on all sub-expressions.

146 #

147 # A default implementation of generate_evaluation_code

148 # is provided which uses the following abstract methods:

149 #

150 # generate_result_code

151 # - Generate any C statements necessary to calculate

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

153 # sub-expressions.

154 #

155 # calculate_result_code

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

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

158 # a temporary.

159 #

160 # generate_assignment_code

161 # Called on the LHS of an assignment.

162 # - Call generate_evaluation_code for sub-expressions.

163 # - Generate code to perform the assignment.

164 # - If the assignment absorbed a reference, call

165 # generate_post_assignment_code on the RHS,

166 # otherwise call generate_disposal_code on it.

167 #

168 # generate_deletion_code

169 # Called on an argument of a del statement.

170 # - Call generate_evaluation_code for sub-expressions.

171 # - Generate code to perform the deletion.

172 # - Call generate_disposal_code on all sub-expressions.

173 #

174 #

175

176 is_sequence_constructor = 0

177 is_attribute = 0

178

179 saved_subexpr_nodes = None

180 is_temp = 0

181 is_target = 0

182

183 constant_result = constant_value_not_set

184

185 try:

186 _get_child_attrs = operator.attrgetter('subexprs')

187 except AttributeError:

188 # Python 2.3

189 def _get_child_attrs(self):

190 return self.subexprs

191 child_attrs = property(fget=_get_child_attrs)

192

193 def not_implemented(self, method_name):

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

195 raise InternalError(

196 "%s.%s not implemented" %

197 (self.__class__.__name__, method_name))

198

199 def is_lvalue(self):

200 return 0

201

202 def is_ephemeral(self):

203 # An ephemeral node is one whose result is in

204 # a Python temporary and we suspect there are no

205 # other references to it. Certain operations are

206 # disallowed on such values, since they are

207 # likely to result in a dangling pointer.

208 return self.type.is_pyobject and self.is_temp

209

210 def subexpr_nodes(self):

211 # Extract a list of subexpression nodes based

212 # on the contents of the subexprs class attribute.

213 nodes = []

214 for name in self.subexprs:

215 item = getattr(self, name)

216 if item is not None:

217 if type(item) is list:

218 nodes.extend(item)

219 else:

220 nodes.append(item)

221 return nodes

222

223 def result(self):

224 if not self.is_temp or self.is_target:

225 return self.calculate_result_code()

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

227 return self.result_code

228

229 def result_as(self, type = None):

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

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

232

233 def py_result(self):

234 # Return the result code cast to PyObject *.

235 return self.result_as(py_object_type)

236

237 def ctype(self):

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

239 # C type of the result_code expression).

240 return self.result_ctype or self.type

241

242 def get_constant_result_code(self):

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

244 # string, or None if the node is not constant.

245 return None

246

247 def calculate_constant_result(self):

248 # Calculate the constant result of this expression and store

249 # it in ``self.constant_result``. Does nothing by default,

250 # thus leaving ``self.constant_result`` unknown.

251 #

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

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

254 # ConstantFolding transform will do this.

255 pass

256

257 def compile_time_value(self, denv):

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

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

260

261 def compile_time_value_error(self, e):

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

263 e.__class__.__name__, e))

264

265 # ------------- Declaration Analysis ----------------

266

267 def analyse_target_declaration(self, env):

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

269

270 # ------------- Expression Analysis ----------------

271

272 def analyse_const_expression(self, env):

273 # Called during the analyse_declarations phase of a

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

275 # checks whether it is a legal const expression,

276 # and determines its value.

277 self.analyse_types(env)

278 self.allocate_temps(env)

279 self.check_const()

280

281 def analyse_expressions(self, env):

282 # Convenience routine performing both the Type

283 # Analysis and Temp Allocation phases for a whole

284 # expression.

285 self.analyse_types(env)

286 self.allocate_temps(env)

287

288 def analyse_target_expression(self, env, rhs):

289 # Convenience routine performing both the Type

290 # Analysis and Temp Allocation phases for the LHS of

291 # an assignment.

292 self.analyse_target_types(env)

293 self.allocate_target_temps(env, rhs)

294

295 def analyse_boolean_expression(self, env):

296 # Analyse expression and coerce to a boolean.

297 self.analyse_types(env)

298 bool = self.coerce_to_boolean(env)

299 bool.allocate_temps(env)

300 return bool

301

302 def analyse_temp_boolean_expression(self, env):

303 # Analyse boolean expression and coerce result into

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

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

306 # opportunity to ensure disposal code is executed

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

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

309 # time we get the result.

310 self.analyse_types(env)

311 bool = self.coerce_to_boolean(env)

312 temp_bool = bool.coerce_to_temp(env)

313 temp_bool.allocate_temps(env)

314 return temp_bool

315

316 # --------------- Type Analysis ------------------

317

318 def analyse_as_module(self, env):

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

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

321 return None

322

323 def analyse_as_type(self, env):

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

325 # type, return that type, else None.

326 return None

327

328 def analyse_as_extension_type(self, env):

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

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

331 return None

332

333 def analyse_types(self, env):

334 self.not_implemented("analyse_types")

335

336 def analyse_target_types(self, env):

337 self.analyse_types(env)

338

339 def gil_check(self, env):

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

341 # prevented in nogil environments. Subtypes must override

342 # this if they can work without the GIL.

343 if self.type.is_pyobject:

344 self._gil_check(env)

345

346 def gil_assignment_check(self, env):

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

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

349

350 def check_const(self):

351 self.not_const()

352

353 def not_const(self):

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

355

356 def check_const_addr(self):

357 self.addr_not_const()

358

359 def addr_not_const(self):

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

361

362 # ----------------- Result Allocation -----------------

363

364 def result_in_temp(self):

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

366 # this node or one of its subexpressions. Overridden

367 # by certain nodes which can share the result of

368 # a subnode.

369 return self.is_temp

370

371 def allocate_target_temps(self, env, rhs):

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

373 if debug_temp_alloc:

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

375 self.allocate_subexpr_temps(env)

376 self.is_target = True

377 if rhs:

378 rhs.release_temp(env)

379 self.release_subexpr_temps(env)

380

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

382 # Allocate temporary variables for this node and

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

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

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

386 # one.

387 if debug_temp_alloc:

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

389 self.allocate_subexpr_temps(env)

390 self.allocate_temp(env, result)

391 if self.is_temp:

392 self.release_subexpr_temps(env)

393

394 def allocate_subexpr_temps(self, env):

395 # Allocate temporary variables for all sub-expressions

396 # of this node.

397 if debug_temp_alloc:

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

399 for node in self.subexpr_nodes():

400 if node:

401 if debug_temp_alloc:

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

403 node.allocate_temps(env)

404

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

406 # If this node requires a temporary variable for its

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

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

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

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

411 # one.

412 if debug_temp_alloc:

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

414 if result:

415 if not self.is_temp:

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

417 self.result_code = result

418 elif self.is_temp:

419 type = self.type

420 if not type.is_void:

421 if type.is_pyobject:

422 type = PyrexTypes.py_object_type

423 self.result_code = env.allocate_temp(type)

424 else:

425 self.result_code = None

426 if debug_temp_alloc:

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

428

429 def target_code(self):

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

431 return self.calculate_result_code()

432

433 def calculate_result_code(self):

434 self.not_implemented("calculate_result_code")

435

436 # def release_target_temp(self, env):

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

438 # self.release_subexpr_temps(env)

439

440 def release_temp(self, env):

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

442 # otherwise release results of its sub-expressions.

443 if self.is_temp:

444 if debug_temp_alloc:

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

446 env.release_temp(self.result_code)

447 else:

448 self.release_subexpr_temps(env)

449

450 def release_subexpr_temps(self, env):

451 # Release the results of all sub-expressions of

452 # this node.

453 for node in self.subexpr_nodes():

454 if node:

455 node.release_temp(env)

456

457 # ---------------- Code Generation -----------------

458

459 def make_owned_reference(self, code):

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

461 # a reference to it.

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

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

464

465 def generate_evaluation_code(self, code):

466 code.mark_pos(self.pos)

467 # Generate code to evaluate this node and

468 # its sub-expressions, and dispose of any

469 # temporary results of its sub-expressions.

470 self.generate_subexpr_evaluation_code(code)

471 self.generate_result_code(code)

472 if self.is_temp:

473 self.generate_subexpr_disposal_code(code)

474 self.free_subexpr_temps(code)

475

476 def generate_subexpr_evaluation_code(self, code):

477 for node in self.subexpr_nodes():

478 node.generate_evaluation_code(code)

479

480 def generate_result_code(self, code):

481 self.not_implemented("generate_result_code")

482

483 def generate_disposal_code(self, code):

484 # If necessary, generate code to dispose of

485 # temporary Python reference.

486 if self.is_temp:

487 if self.type.is_pyobject:

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

489 else:

490 self.generate_subexpr_disposal_code(code)

491

492 def generate_subexpr_disposal_code(self, code):

493 # Generate code to dispose of temporary results

494 # of all sub-expressions.

495 for node in self.subexpr_nodes():

496 node.generate_disposal_code(code)

497

498 def generate_post_assignment_code(self, code):

499 # Same as generate_disposal_code except that

500 # assignment will have absorbed a reference to

501 # the result if it is a Python object.

502 if self.is_temp:

503 if self.type.is_pyobject:

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

505 else:

506 self.generate_subexpr_disposal_code(code)

507

508 def generate_assignment_code(self, rhs, code):

509 # Stub method for nodes which are not legal as

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

511 # been reported earlier.

512 pass

513

514 def generate_deletion_code(self, code):

515 # Stub method for nodes that are not legal as

516 # the argument of a del statement. An error

517 # will have been reported earlier.

518 pass

519

520 def free_temps(self, code):

521 if not self.is_temp:

522 self.free_subexpr_temps(code)

523 # otherwise, already freed in generate_evaluation_code

524

525 def free_subexpr_temps(self, code):

526 for sub in self.subexpr_nodes():

527 sub.free_temps(code)

528

529 # ---------------- Annotation ---------------------

530

531 def annotate(self, code):

532 for node in self.subexpr_nodes():

533 node.annotate(code)

534

535 # ----------------- Coercion ----------------------

536

537 def coerce_to(self, dst_type, env):

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

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

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

541 # Otherwise, returns this node unchanged.

542 #

543 # This method is called during the analyse_expressions

544 # phase of the src_node's processing.

545 src = self

546 src_type = self.type

547 src_is_py_type = src_type.is_pyobject

548 dst_is_py_type = dst_type.is_pyobject

549

550 if dst_type.is_pyobject:

551 if not src.type.is_pyobject:

552 src = CoerceToPyTypeNode(src, env)

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

554 if not isinstance(src, NoneNode):

555 src = PyTypeTestNode(src, dst_type, env)

556 elif src.type.is_pyobject:

557 src = CoerceFromPyTypeNode(dst_type, src, env)

558 else: # neither src nor dst are py types

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

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

561 # in different files.

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

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

564 (src.type, dst_type))

565 return src

566

567 def coerce_to_pyobject(self, env):

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

569

570 def coerce_to_boolean(self, env):

571 # Coerce result to something acceptable as

572 # a boolean value.

573 type = self.type

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

575 return CoerceToBooleanNode(self, env)

576 else:

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

578 error(self.pos,

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

580 return self

581

582 def coerce_to_integer(self, env):

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

584 if self.type.is_int:

585 return self

586 else:

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

588

589 def coerce_to_temp(self, env):

590 # Ensure that the result is in a temporary.

591 if self.result_in_temp():

592 return self

593 else:

594 return CoerceToTempNode(self, env)

595

596 def coerce_to_simple(self, env):

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

598 if self.is_simple():

599 return self

600 else:

601 return self.coerce_to_temp(env)

602

603 def is_simple(self):

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

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

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

607 # reference, or temporary.

608 return self.result_in_temp()

609

610 def as_cython_attribute(self):

611 return None

612

613

614 class RemoveAllocateTemps(type):

615 def __init__(cls, name, bases, dct):

616 super(RemoveAllocateTemps, cls).__init__(name, bases, dct)

617 def noop(self, env): pass

618 setattr(cls, 'allocate_temps', noop)

619 setattr(cls, 'allocate_temp', noop)

620 setattr(cls, 'release_temp', noop)

621

622 class NewTempExprNode(ExprNode):

623 backwards_compatible_result = None

624 temp_code = None

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

626

627 # Do not enable this unless you are trying to make all ExprNodes

628 # NewTempExprNodes (child nodes reached via recursion may not have

629 # transferred).

630 # __metaclass__ = RemoveAllocateTemps

631

632 def result(self):

633 if self.is_temp:

634 return self.temp_code

635 else:

636 return self.calculate_result_code()

637

638 def allocate_target_temps(self, env, rhs):

639 self.allocate_subexpr_temps(env)

640 self.is_target = True

641 if rhs:

642 rhs.release_temp(env)

643 self.release_subexpr_temps(env)

644

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

646 self.allocate_subexpr_temps(env)

647 self.backwards_compatible_result = result

648 if self.is_temp:

649 self.release_subexpr_temps(env)

650

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

652 assert result is None

653

654 def release_temp(self, env):

655 if self.is_temp:

656 pass

657 else:

658 self.release_subexpr_temps(env)

659

660 def allocate_temp_result(self, code):

661 if self.temp_code:

662 raise RuntimeError("Temp allocated multiple times")

663 type = self.type

664 if not type.is_void:

665 if type.is_pyobject:

666 type = PyrexTypes.py_object_type

667 if self.backwards_compatible_result:

668 self.temp_code = self.backwards_compatible_result

669 else:

670 self.temp_code = code.funcstate.allocate_temp(

671 type, manage_ref=True)

672 else:

673 self.temp_code = None

674

675 def release_temp_result(self, code):

676 if not self.temp_code:

677 if self.old_temp:

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

679 self.old_temp, self.__class__.__name__))

680 else:

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

682 self.__class__.__name__))

683 code.funcstate.release_temp(self.temp_code)

684 self.old_temp = self.temp_code

685 self.temp_code = None

686

687 def generate_evaluation_code(self, code):

688 code.mark_pos(self.pos)

689

690 # Generate code to evaluate this node and

691 # its sub-expressions, and dispose of any

692 # temporary results of its sub-expressions.

693 self.generate_subexpr_evaluation_code(code)

694

695 if self.is_temp:

696 self.allocate_temp_result(code)

697

698 self.generate_result_code(code)

699 if self.is_temp:

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

701 # before disposing children.

702 self.generate_subexpr_disposal_code(code)

703 self.free_subexpr_temps(code)

704

705 def generate_disposal_code(self, code):

706 if self.is_temp:

707 if self.type.is_pyobject:

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

709 else:

710 # Already done if self.is_temp

711 self.generate_subexpr_disposal_code(code)

712

713 def generate_post_assignment_code(self, code):

714 if self.is_temp:

715 if self.type.is_pyobject:

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

717 else:

718 self.generate_subexpr_disposal_code(code)

719

720 def free_temps(self, code):

721 if self.is_temp:

722 if not self.type.is_void:

723 self.release_temp_result(code)

724 else:

725 self.free_subexpr_temps(code)

726

727 # ExprNode = NewTempExprNode

728

729 class AtomicExprNode(ExprNode):

730 # Abstract base class for expression nodes which have

731 # no sub-expressions.

732

733 subexprs = []

734

735 class AtomicNewTempExprNode(NewTempExprNode):

736 # I do not dare to convert NameNode yet. This is now

737 # ancestor of all former AtomicExprNode except

738 # NameNode. Should be renamed to AtomicExprNode

739 # when done.

740

741 # Abstract base class for expression nodes which have

742 # no sub-expressions.

743

744 subexprs = []

745

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

747 def generate_subexpr_evaluation_code(self, code):

748 pass

749 def generate_subexpr_disposal_code(self, code):

750 pass

751

752 class PyConstNode(AtomicNewTempExprNode):

753 # Abstract base class for constant Python values.

754

755 is_literal = 1

756

757 def is_simple(self):

758 return 1

759

760 def analyse_types(self, env):

761 self.type = py_object_type

762

763 def calculate_result_code(self):

764 return self.value

765

766 def generate_result_code(self, code):

767 pass

768

769

770 class NoneNode(PyConstNode):

771 # The constant value None

772

773 value = "Py_None"

774

775 constant_result = None

776 gil_check = None

777

778 def compile_time_value(self, denv):

779 return None

780

781 class EllipsisNode(PyConstNode):

782 # '...' in a subscript list.

783

784 value = "Py_Ellipsis"

785

786 constant_result = Ellipsis

787

788 def compile_time_value(self, denv):

789 return Ellipsis

790

791

792 class ConstNode(AtomicNewTempExprNode):

793 # Abstract base type for literal constant nodes.

794 #

795 # value string C code fragment

796

797 is_literal = 1

798 gil_check = None

799

800 def is_simple(self):

801 return 1

802

803 def analyse_types(self, env):

804 pass # Types are held in class variables

805

806 def check_const(self):

807 pass

808

809 def get_constant_result_code(self):

810 return self.calculate_result_code()

811

812 def calculate_result_code(self):

813 return str(self.value)

814

815 def generate_result_code(self, code):

816 pass

817

818

819 class BoolNode(ConstNode):

820 type = PyrexTypes.c_bint_type

821 # The constant value True or False

822

823 def calculate_constant_result(self):

824 self.constant_result = self.value

825

826 def compile_time_value(self, denv):

827 return self.value

828

829 def calculate_result_code(self):

830 return str(int(self.value))

831

832

833 class NullNode(ConstNode):

834 type = PyrexTypes.c_null_ptr_type

835 value = "NULL"

836 constant_result = 0

837

838 def get_constant_result_code(self):

839 return self.value

840

841

842 class CharNode(ConstNode):

843 type = PyrexTypes.c_char_type

844

845 def calculate_constant_result(self):

846 self.constant_result = ord(self.value)

847

848 def compile_time_value(self, denv):

849 return ord(self.value)

850

851 def calculate_result_code(self):

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

853

854

855 class IntNode(ConstNode):

856

857 # unsigned "" or "U"

858 # longness "" or "L" or "LL"

859

860 unsigned = ""

861 longness = ""

862 type = PyrexTypes.c_long_type

863

864 def coerce_to(self, dst_type, env):

865 if dst_type.is_numeric:

866 self.type = PyrexTypes.c_long_type

867 return self

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

869 # when coercing to a Python type.

870 if dst_type.is_pyobject:

871 self.type = PyrexTypes.py_object_type

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

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

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

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

876

877 def coerce_to_boolean(self, env):

878 self.type = PyrexTypes.c_bint_type

879 return self

880

881 def generate_evaluation_code(self, code):

882 if self.type.is_pyobject:

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

884 else:

885 self.result_code = self.get_constant_result_code()

886

887 def get_constant_result_code(self):

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

889

890 def calculate_result_code(self):

891 return self.result_code

892

893 def calculate_constant_result(self):

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

895

896 def compile_time_value(self, denv):

897 return int(self.value, 0)

898

899

900 class FloatNode(ConstNode):

901 type = PyrexTypes.c_double_type

902

903 def calculate_constant_result(self):

904 # calculating float values is usually not a good idea

905 #self.constant_result = float(self.value)

906 pass

907

908 def compile_time_value(self, denv):

909 return float(self.value)

910

911 def calculate_result_code(self):

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

913 if strval == 'nan':

914 return "(Py_HUGE_VAL * 0)"

915 elif strval == 'inf':

916 return "Py_HUGE_VAL"

917 elif strval == '-inf':

918 return "(-Py_HUGE_VAL)"

919 else:

920 return strval

921

922

923 class StringNode(ConstNode):

924 type = PyrexTypes.c_char_ptr_type

925

926 def compile_time_value(self, denv):

927 return self.value

928

929 def analyse_as_type(self, env):

930 type = PyrexTypes.parse_basic_type(self.value)

931 if type is not None:

932 return type

933 from TreeFragment import TreeFragment

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

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

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

937 sizeof_node.analyse_types(env)

938 if isinstance(sizeof_node, SizeofTypeNode):

939 return sizeof_node.arg_type

940

941 def coerce_to(self, dst_type, env):

942 if dst_type == PyrexTypes.c_char_ptr_type:

943 self.type = PyrexTypes.c_char_ptr_type

944 return self

945

946 if dst_type.is_int:

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

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

949 else:

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

951 return self

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

953 # when coercing to a Python type.

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

955 node = self.as_py_string_node(env)

956 else:

957 node = self

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

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

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

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

962

963 def as_py_string_node(self, env):

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

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

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

967

968 def generate_evaluation_code(self, code):

969 if self.type.is_pyobject:

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

971 else:

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

973

974 def get_constant_result_code(self):

975 return None # FIXME

976

977 def calculate_result_code(self):

978 return self.result_code

979

980

981 class UnicodeNode(PyConstNode):

982 type = unicode_type

983

984 def coerce_to(self, dst_type, env):

985 if dst_type.is_pyobject:

986 return self

987 else:

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

989 return self

990

991 def generate_evaluation_code(self, code):

992 if self.type.is_pyobject:

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

994 else:

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

996

997 def calculate_result_code(self):

998 return self.result_code

999

1000 def compile_time_value(self, env):

1001 return self.value

1002

1003

1004 class IdentifierStringNode(ConstNode):

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

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

1007 type = PyrexTypes.py_object_type

1008

1009 def generate_evaluation_code(self, code):

1010 if self.type.is_pyobject:

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

1012 else:

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

1014

1015 def get_constant_result_code(self):

1016 return None

1017

1018 def calculate_result_code(self):

1019 return self.result_code

1020

1021

1022 class LongNode(AtomicNewTempExprNode):

1023 # Python long integer literal

1024 #

1025 # value string

1026

1027 def calculate_constant_result(self):

1028 self.constant_result = long(self.value)

1029

1030 def compile_time_value(self, denv):

1031 return long(self.value)

1032

1033 def analyse_types(self, env):

1034 self.type = py_object_type

1035 self.is_temp = 1

1036

1037 gil_message = "Constructing Python long int"

1038

1039 def generate_result_code(self, code):

1040 code.putln(

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

1042 self.result(),

1043 self.value,

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

1045 code.put_gotref(self.py_result())

1046

1047

1048 class ImagNode(AtomicNewTempExprNode):

1049 # Imaginary number literal

1050 #

1051 # value float imaginary part

1052

1053 def calculate_constant_result(self):

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

1055

1056 def compile_time_value(self, denv):

1057 return complex(0.0, self.value)

1058

1059 def analyse_types(self, env):

1060 self.type = py_object_type

1061 self.is_temp = 1

1062

1063 gil_message = "Constructing complex number"

1064

1065 def generate_result_code(self, code):

1066 code.putln(

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

1068 self.result(),

1069 float(self.value),

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

1071 code.put_gotref(self.py_result())

1072

1073

1074

1075 class NameNode(AtomicNewTempExprNode):

1076 # Reference to a local or global variable name.

1077 #

1078 # name string Python name of the variable

1079 #

1080 # entry Entry Symbol table entry

1081

1082 is_name = True

1083 is_cython_module = False

1084 cython_attribute = None

1085 lhs_of_first_assignment = False

1086 is_used_as_rvalue = 0

1087 entry = None

1088

1089 def create_analysed_rvalue(pos, env, entry):

1090 node = NameNode(pos)

1091 node.analyse_types(env, entry=entry)

1092 return node

1093

1094 def as_cython_attribute(self):

1095 return self.cython_attribute

1096

1097 create_analysed_rvalue = staticmethod(create_analysed_rvalue)

1098

1099 def compile_time_value(self, denv):

1100 try:

1101 return denv.lookup(self.name)

1102 except KeyError:

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

1104

1105 def coerce_to(self, dst_type, env):

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

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

1108 # referring to the Python builtin.

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

1110 if dst_type is py_object_type:

1111 entry = self.entry

1112 if entry and entry.is_cfunction:

1113 var_entry = entry.as_variable

1114 if var_entry:

1115 if var_entry.is_builtin and Options.cache_builtins:

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

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

1118 node.entry = var_entry

1119 node.analyse_rvalue_entry(env)

1120 return node

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

1122

1123 def analyse_as_module(self, env):

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

1125 # Returns the module scope, or None.

1126 entry = self.entry

1127 if not entry:

1128 entry = env.lookup(self.name)

1129 if entry and entry.as_module:

1130 return entry.as_module

1131 return None

1132

1133 def analyse_as_type(self, env):

1134 if self.cython_attribute:

1135 type = PyrexTypes.parse_basic_type(self.cython_attribute)

1136 else:

1137 type = PyrexTypes.parse_basic_type(self.name)

1138 if type:

1139 return type

1140 entry = self.entry

1141 if not entry:

1142 entry = env.lookup(self.name)

1143 if entry and entry.is_type:

1144 return entry.type

1145 else:

1146 return None

1147

1148 def analyse_as_extension_type(self, env):

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

1150 # Returns the extension type, or None.

1151 entry = self.entry

1152 if not entry:

1153 entry = env.lookup(self.name)

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

1155 return entry.type

1156 else:

1157 return None

1158

1159 def analyse_target_declaration(self, env):

1160 if not self.entry:

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

1162 if not self.entry:

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

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

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

1166 if self.entry.is_declared_generic:

1167 self.result_ctype = py_object_type

1168

1169 def analyse_types(self, env):

1170 if self.entry is None:

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

1172 if not self.entry:

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

1174 if not self.entry:

1175 self.type = PyrexTypes.error_type

1176 return

1177 entry = self.entry

1178 if entry:

1179 entry.used = 1

1180 if entry.type.is_buffer:

1181 import Buffer

1182 Buffer.used_buffer_aux_vars(entry)

1183 if entry.utility_code:

1184 env.use_utility_code(entry.utility_code)

1185 self.analyse_rvalue_entry(env)

1186

1187 def analyse_target_types(self, env):

1188 self.analyse_entry(env)

1189 if not self.is_lvalue():

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

1191 % self.name)

1192 self.type = PyrexTypes.error_type

1193 self.entry.used = 1

1194 if self.entry.type.is_buffer:

1195 import Buffer

1196 Buffer.used_buffer_aux_vars(self.entry)

1197

1198 def analyse_rvalue_entry(self, env):

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

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

1201 self.analyse_entry(env)

1202 entry = self.entry

1203 if entry.is_declared_generic:

1204 self.result_ctype = py_object_type

1205 if entry.is_pyglobal or entry.is_builtin:

1206 if Options.cache_builtins and entry.is_builtin:

1207 self.is_temp = 0

1208 else:

1209 self.is_temp = 1

1210 self.is_used_as_rvalue = 1

1211 env.use_utility_code(get_name_interned_utility_code)

1212

1213 def gil_check(self, env):

1214 if self.is_used_as_rvalue:

1215 entry = self.entry

1216 if entry.is_builtin:

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

1218 self._gil_check(env)

1219 elif entry.is_pyglobal:

1220 self._gil_check(env)

1221

1222 gil_message = "Accessing Python global or builtin"

1223

1224 def analyse_entry(self, env):

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

1226 self.check_identifier_kind()

1227 entry = self.entry

1228 type = entry.type

1229 self.type = type

1230

1231 def check_identifier_kind(self):

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

1233 #print self.entry.__dict__ ###

1234 entry = self.entry

1235 #entry.used = 1

1236 if not (entry.is_const or entry.is_variable

1237 or entry.is_builtin or entry.is_cfunction):

1238 if self.entry.as_variable:

1239 self.entry = self.entry.as_variable

1240 else:

1241 error(self.pos,

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

1243

1244 def is_simple(self):

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

1246 return 1

1247

1248 def calculate_target_results(self, env):

1249 pass

1250

1251 def check_const(self):

1252 entry = self.entry

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

1254 self.not_const()

1255

1256 def check_const_addr(self):

1257 entry = self.entry

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

1259 self.addr_not_const()

1260

1261 def is_lvalue(self):

1262 return self.entry.is_variable and \

1263 not self.entry.type.is_array and \

1264 not self.entry.is_readonly

1265

1266 def is_ephemeral(self):

1267 # Name nodes are never ephemeral, even if the

1268 # result is in a temporary.

1269 return 0

1270

1271 def calculate_result_code(self):

1272 entry = self.entry

1273 if not entry:

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

1275 return entry.cname

1276

1277 def generate_result_code(self, code):

1278 assert hasattr(self, 'entry')

1279 entry = self.entry

1280 if entry is None:

1281 return # There was an error earlier

1282 if entry.is_builtin and Options.cache_builtins:

1283 return # Lookup already cached

1284 elif entry.is_pyglobal or entry.is_builtin:

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

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

1287 if entry.is_builtin:

1288 namespace = Naming.builtins_cname

1289 else: # entry.is_pyglobal

1290 namespace = entry.scope.namespace_cname

1291 code.putln(

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

1293 self.result(),

1294 namespace,

1295 interned_cname,

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

1297 code.put_gotref(self.py_result())

1298

1299 elif entry.is_local and False:

1300 # control flow not good enough yet

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

1302 if assigned is False:

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

1304 elif not Options.init_local_none and assigned is None:

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

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

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

1308

1309 def generate_assignment_code(self, rhs, code):

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

1311 entry = self.entry

1312 if entry is None:

1313 return # There was an error earlier

1314

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

1316 and not self.lhs_of_first_assignment):

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

1318

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

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

1321 if entry.is_pyglobal:

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

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

1324 namespace = self.entry.scope.namespace_cname

1325 if entry.is_member:

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

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

1328 code.put_error_if_neg(self.pos,

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

1330 namespace,

1331 interned_cname,

1332 rhs.py_result()))

1333 rhs.generate_disposal_code(code)

1334 rhs.free_temps(code)

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

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

1337 entry.scope.parent_type.typeptr_cname)

1338 else:

1339 code.put_error_if_neg(self.pos,

1340 'PyObject_SetAttr(%s, %s, %s)' % (

1341 namespace,

1342 interned_cname,

1343 rhs.py_result()))

1344 if debug_disposal_code:

1345 print("NameNode.generate_assignment_code:")

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

1347 rhs.generate_disposal_code(code)

1348 rhs.free_temps(code)

1349 else:

1350 if self.type.is_buffer:

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

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

1353 # below) will not happen.

1354 #

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

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

1357 # per entry and coupled with it.

1358 self.generate_acquire_buffer(rhs, code)

1359

1360 if self.type.is_pyobject:

1361 rhs.make_owned_reference(code)

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

1363 #print "...from", rhs ###

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

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

1366 if entry.is_cglobal:

1367 code.put_gotref(self.py_result())

1368 if not self.lhs_of_first_assignment:

1369 if entry.is_local and not Options.init_local_none:

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

1371 if initalized is True:

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

1373 elif initalized is None:

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

1375 else:

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

1377 if entry.is_cglobal:

1378 code.put_giveref(rhs.py_result())

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

1380 if debug_disposal_code:

1381 print("NameNode.generate_assignment_code:")

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

1383 rhs.generate_post_assignment_code(code)

1384 rhs.free_temps(code)

1385

1386 def generate_acquire_buffer(self, rhs, code):

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

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

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

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

1391 if pretty_rhs:

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

1393 else:

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

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

1396

1397 buffer_aux = self.entry.buffer_aux

1398 bufstruct = buffer_aux.buffer_info_var.cname

1399 import Buffer

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

1401 is_initialized=not self.lhs_of_first_assignment,

1402 pos=self.pos, code=code)

1403

1404 if not pretty_rhs:

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

1406 code.funcstate.release_temp(rhstmp)

1407

1408 def generate_deletion_code(self, code):

1409 if self.entry is None:

1410 return # There was an error earlier

1411 if not self.entry.is_pyglobal:

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

1413 return

1414 code.put_error_if_neg(self.pos,

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

1416 Naming.module_cname,

1417 self.entry.name))

1418

1419 def annotate(self, code):

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

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

1422 if self.type.is_pyobject:

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

1424 else:

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

1426

1427 class BackquoteNode(NewTempExprNode):

1428 # `expr`

1429 #

1430 # arg ExprNode

1431

1432 subexprs = ['arg']

1433

1434 def analyse_types(self, env):

1435 self.arg.analyse_types(env)

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

1437 self.type = py_object_type

1438 self.is_temp = 1

1439

1440 gil_message = "Backquote expression"

1441

1442 def calculate_constant_result(self):

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

1444

1445 def generate_result_code(self, code):

1446 code.putln(

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

1448 self.result(),

1449 self.arg.py_result(),

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

1451 code.put_gotref(self.py_result())

1452

1453

1454

1455 class ImportNode(NewTempExprNode):

1456 # Used as part of import statement implementation.

1457 # Implements result =

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

1459 #

1460 # module_name IdentifierStringNode dotted name of module

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

1462

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

1464

1465 def analyse_types(self, env):

1466 self.module_name.analyse_types(env)

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

1468 if self.name_list:

1469 self.name_list.analyse_types(env)

1470 self.name_list.coerce_to_pyobject(env)

1471 self.type = py_object_type

1472 self.is_temp = 1

1473 env.use_utility_code(import_utility_code)

1474

1475 gil_message = "Python import"

1476

1477 def generate_result_code(self, code):

1478 if self.name_list:

1479 name_list_code = self.name_list.py_result()

1480 else:

1481 name_list_code = "0"

1482 code.putln(

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

1484 self.result(),

1485 self.module_name.py_result(),

1486 name_list_code,

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

1488 code.put_gotref(self.py_result())

1489

1490

1491 class IteratorNode(NewTempExprNode):

1492 # Used as part of for statement implementation.

1493 #

1494 # allocate_counter_temp/release_counter_temp needs to be called

1495 # by parent (ForInStatNode)

1496 #

1497 # Implements result = iter(sequence)

1498 #

1499 # sequence ExprNode

1500

1501 subexprs = ['sequence']

1502

1503 def analyse_types(self, env):

1504 self.sequence.analyse_types(env)

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

1506 self.type = py_object_type

1507 self.is_temp = 1

1508

1509 gil_message = "Iterating over Python object"

1510

1511 def allocate_counter_temp(self, code):

1512 self.counter_cname = code.funcstate.allocate_temp(

1513 PyrexTypes.c_py_ssize_t_type, manage_ref=False)

1514

1515 def release_counter_temp(self, code):

1516 code.funcstate.release_temp(self.counter_cname)

1517

1518 def generate_result_code(self, code):

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

1520 self.sequence.type is tuple_type

1521 if is_builtin_sequence:

1522 code.putln(

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

1524 else:

1525 code.putln(

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

1527 self.sequence.py_result(),

1528 self.sequence.py_result()))

1529 code.putln(

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

1531 self.counter_cname,

1532 self.result(),

1533 self.sequence.py_result(),

1534 self.result()))

1535 code.putln("} else {")

1536 if is_builtin_sequence:

1537 code.putln(

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

1539 code.error_goto(self.pos))

1540 else:

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

1542 self.counter_cname,

1543 self.result(),

1544 self.sequence.py_result(),

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

1546 code.put_gotref(self.py_result())

1547 code.putln("}")

1548

1549

1550 class NextNode(AtomicNewTempExprNode):

1551 # Used as part of for statement implementation.

1552 # Implements result = iterator.next()

1553 # Created during analyse_types phase.

1554 # The iterator is not owned by this node.

1555 #

1556 # iterator ExprNode

1557

1558 def __init__(self, iterator, env):

1559 self.pos = iterator.pos

1560 self.iterator = iterator

1561 self.type = py_object_type

1562 self.is_temp = 1

1563

1564 def generate_result_code(self, code):

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

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

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

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

1569 else:

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

1571

1572 for py_type, prefix in type_checks:

1573 if len(type_checks) > 1:

1574 code.putln(

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

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

1577 code.putln(

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

1579 self.iterator.counter_cname,

1580 prefix,

1581 self.iterator.py_result()))

1582 code.putln(

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

1584 self.result(),

1585 prefix,

1586 self.iterator.py_result(),

1587 self.iterator.counter_cname,

1588 self.result(),

1589 self.iterator.counter_cname))

1590 if len(type_checks) > 1:

1591 code.put("} else ")

1592 if len(type_checks) == 1:

1593 return

1594 code.putln("{")

1595 code.putln(

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

1597 self.result(),

1598 self.iterator.py_result()))

1599 code.putln(

1600 "if (!%s) {" %

1601 self.result())

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

1603 code.putln("break;")

1604 code.putln("}")

1605 code.put_gotref(self.py_result())

1606 code.putln("}")

1607

1608

1609 class ExcValueNode(AtomicNewTempExprNode):

1610 # Node created during analyse_types phase

1611 # of an ExceptClauseNode to fetch the current

1612 # exception value.

1613

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

1615 ExprNode.__init__(self, pos)

1616 self.type = py_object_type

1617 self.var = var

1618

1619 def calculate_result_code(self):

1620 return self.var

1621

1622 def generate_result_code(self, code):

1623 pass

1624

1625 def analyse_types(self, env):

1626 pass

1627

1628

1629 class TempNode(ExprNode):

1630 # Node created during analyse_types phase

1631 # of some nodes to hold a temporary value.

1632

1633 subexprs = []

1634

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

1636 ExprNode.__init__(self, pos)

1637 self.type = type

1638 if type.is_pyobject:

1639 self.result_ctype = py_object_type

1640 self.is_temp = 1

1641

1642 def analyse_types(self, env):

1643 return self.type

1644

1645 def generate_result_code(self, code):

1646 pass

1647

1648

1649 class PyTempNode(TempNode):

1650 # TempNode holding a Python value.

1651

1652 def __init__(self, pos, env):

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

1654

1655

1656 #-------------------------------------------------------------------

1657 #

1658 # Trailer nodes

1659 #

1660 #-------------------------------------------------------------------

1661

1662 class IndexNode(ExprNode):

1663 # Sequence indexing.

1664 #

1665 # base ExprNode

1666 # index ExprNode

1667 # indices [ExprNode]

1668 # is_buffer_access boolean Whether this is a buffer access.

1669 #

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

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

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

1673

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

1675 indices = None

1676

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

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

1679 self._index = index

1680

1681 def calculate_constant_result(self):

1682 self.constant_result = \

1683 self.base.constant_result[self.index.constant_result]

1684

1685 def compile_time_value(self, denv):

1686 base = self.base.compile_time_value(denv)

1687 index = self.index.compile_time_value(denv)

1688 try:

1689 return base[index]

1690 except Exception, e:

1691 self.compile_time_value_error(e)

1692

1693 def is_ephemeral(self):

1694 return self.base.is_ephemeral()

1695

1696 def analyse_target_declaration(self, env):

1697 pass

1698

1699 def analyse_as_type(self, env):

1700 base_type = self.base.analyse_as_type(env)

1701 if base_type and not base_type.is_pyobject:

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

1703 return None

1704

1705 def analyse_types(self, env):

1706 self.analyse_base_and_index_types(env, getting = 1)

1707

1708 def analyse_target_types(self, env):

1709 self.analyse_base_and_index_types(env, setting = 1)

1710

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

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

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

1714 # needed.

1715

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

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

1718 # when cloning self.indices is copied.

1719 self.is_buffer_access = False

1720

1721 self.base.analyse_types(env)

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

1723 if isinstance(self.base, StringNode):

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

1725

1726 skip_child_analysis = False

1727 buffer_access = False

1728 if self.base.type.is_buffer:

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

1730 if self.indices:

1731 indices = self.indices

1732 else:

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

1734 assert not isinstance(self.index, CloneNode)

1735 if isinstance(self.index, TupleNode):

1736 indices = self.index.args

1737 else:

1738 indices = [self.index]

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

1740 buffer_access = True

1741 skip_child_analysis = True

1742 for x in indices:

1743 x.analyse_types(env)

1744 if not x.type.is_int:

1745 buffer_access = False

1746

1747 if buffer_access:

1748 self.indices = indices

1749 self.index = None

1750 self.type = self.base.type.dtype

1751 self.is_buffer_access = True

1752 self.buffer_type = self.base.entry.type

1753

1754 if getting and self.type.is_pyobject:

1755 self.is_temp = True

1756 if setting:

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

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

1759 else:

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

1761 else:

1762 if isinstance(self.index, TupleNode):

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

1764 elif not skip_child_analysis:

1765 self.index.analyse_types(env)

1766 self.original_index_type = self.index.type

1767 if self.base.type.is_pyobject:

1768 if self.index.type.is_int:

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

1770 else:

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

1772 self.type = py_object_type

1773 self.is_temp = 1

1774 else:

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

1776 self.type = self.base.type.base_type

1777 else:

1778 error(self.pos,

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

1780 self.base.type)

1781 self.type = PyrexTypes.error_type

1782 if self.index.type.is_pyobject:

1783 self.index = self.index.coerce_to(

1784 PyrexTypes.c_py_ssize_t_type, env)

1785 if not self.index.type.is_int:

1786 error(self.pos,

1787 "Invalid index type '%s'" %

1788 self.index.type)

1789

1790 def gil_check(self, env):

1791 if not self.is_buffer_access:

1792 if self.base.type.is_pyobject:

1793 self._gil_check(env)

1794

1795 gil_message = "Indexing Python object"

1796

1797 def check_const_addr(self):

1798 self.base.check_const_addr()

1799 self.index.check_const()

1800

1801 def is_lvalue(self):

1802 return 1

1803

1804 def calculate_result_code(self):

1805 if self.is_buffer_access:

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

1807 else:

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

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

1810

1811 def extra_index_params(self):

1812 if self.index.type.is_int:

1813 if self.original_index_type.signed:

1814 size_adjustment = ""

1815 else:

1816 size_adjustment = "+1"

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

1818 else:

1819 return ""

1820

1821 def generate_subexpr_evaluation_code(self, code):

1822 self.base.generate_evaluation_code(code)

1823 if not self.indices:

1824 self.index.generate_evaluation_code(code)

1825 else:

1826 for i in self.indices:

1827 i.generate_evaluation_code(code)

1828

1829 def generate_subexpr_disposal_code(self, code):

1830 self.base.generate_disposal_code(code)

1831 if not self.indices:

1832 self.index.generate_disposal_code(code)

1833 else:

1834 for i in self.indices:

1835 i.generate_disposal_code(code)

1836

1837 def free_subexpr_temps(self, code):

1838 self.base.free_temps(code)

1839 if not self.indices:

1840 self.index.free_temps(code)

1841 else:

1842 for i in self.indices:

1843 i.free_temps(code)

1844

1845 def generate_result_code(self, code):

1846 if self.is_buffer_access:

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

1848 self.put_nonecheck(code)

1849 self.buffer_ptr_code = self.buffer_lookup_code(code)

1850 if self.type.is_pyobject:

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

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

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

1854 elif self.type.is_pyobject:

1855 if self.index.type.is_int:

1856 index_code = self.index.result()

1857 if self.base.type is list_type:

1858 function = "__Pyx_GetItemInt_List"

1859 elif self.base.type is tuple_type:

1860 function = "__Pyx_GetItemInt_Tuple"

1861 else:

1862 function = "__Pyx_GetItemInt"

1863 code.globalstate.use_utility_code(getitem_int_utility_code)

1864 else:

1865 function = "PyObject_GetItem"

1866 index_code = self.index.py_result()

1867 sign_code = ""

1868 code.putln(

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

1870 self.result(),

1871 function,

1872 self.base.py_result(),

1873 index_code,

1874 self.extra_index_params(),

1875 self.result(),

1876 code.error_goto(self.pos)))

1877 code.put_gotref(self.py_result())

1878

1879 def generate_setitem_code(self, value_code, code):

1880 if self.index.type.is_int:

1881 function = "__Pyx_SetItemInt"

1882 index_code = self.index.result()

1883 code.globalstate.use_utility_code(setitem_int_utility_code)

1884 else:

1885 index_code = self.index.py_result()

1886 if self.base.type is dict_type:

1887 function = "PyDict_SetItem"

1888 elif self.base.type is list_type:

1889 function = "PyList_SetItem"

1890 # don't use PyTuple_SetItem(), as we'd normally get a

1891 # TypeError when changing a tuple, while PyTuple_SetItem()

1892 # would allow updates

1893 #

1894 #elif self.base.type is tuple_type:

1895 # function = "PyTuple_SetItem"

1896 else:

1897 function = "PyObject_SetItem"

1898 code.putln(

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

1900 function,

1901 self.base.py_result(),

1902 index_code,

1903 value_code,

1904 self.extra_index_params(),

1905 code.error_goto(self.pos)))

1906

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

1908 # Used from generate_assignment_code and InPlaceAssignmentNode

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

1910 self.put_nonecheck(code)

1911 ptrexpr = self.buffer_lookup_code(code)

1912 if self.buffer_type.dtype.is_pyobject:

1913 # Must manage refcounts. Decref what is already there

1914 # and incref what we put in.

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

1916 rhs_code = rhs.result()

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

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

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

1920 ptr, rhs_code

1921 ))

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

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

1924 code.funcstate.release_temp(ptr)

1925 else:

1926 # Simple case

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

1928

1929 def generate_assignment_code(self, rhs, code):

1930 self.generate_subexpr_evaluation_code(code)

1931 if self.is_buffer_access:

1932 self.generate_buffer_setitem_code(rhs, code)

1933 elif self.type.is_pyobject:

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

1935 else:

1936 code.putln(

1937 "%s = %s;" % (

1938 self.result(), rhs.result()))

1939 self.generate_subexpr_disposal_code(code)

1940 self.free_subexpr_temps(code)

1941 rhs.generate_disposal_code(code)

1942 rhs.free_temps(code)

1943

1944 def generate_deletion_code(self, code):

1945 self.generate_subexpr_evaluation_code(code)

1946 #if self.type.is_pyobject:

1947 if self.index.type.is_int:

1948 function = "__Pyx_DelItemInt"

1949 index_code = self.index.result()

1950 code.globalstate.use_utility_code(delitem_int_utility_code)

1951 else:

1952 index_code = self.index.py_result()

1953 if self.base.type is dict_type:

1954 function = "PyDict_DelItem"

1955 else:

1956 function = "PyObject_DelItem"

1957 code.putln(

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

1959 function,

1960 self.base.py_result(),

1961 index_code,

1962 self.extra_index_params(),

1963 code.error_goto(self.pos)))

1964 self.generate_subexpr_disposal_code(code)

1965 self.free_subexpr_temps(code)

1966

1967 def buffer_lookup_code(self, code):

1968 # Assign indices to temps

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

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

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

1972 # Generate buffer access code using these temps

1973 import Buffer

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

1975 # options are not propagated.

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

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

1978 index_cnames=index_temps,

1979 options=code.globalstate.directives,

1980 pos=self.pos, code=code)

1981

1982 def put_nonecheck(self, code):

1983 code.globalstate.use_utility_code(raise_noneindex_error_utility_code)

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

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

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

1987 code.putln("}")

1988

1989 class SliceIndexNode(NewTempExprNode):

1990 # 2-element slice indexing

1991 #

1992 # base ExprNode

1993 # start ExprNode or None

1994 # stop ExprNode or None

1995

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

1997

1998 def calculate_constant_result(self):

1999 self.constant_result = self.base.constant_result[

2000 self.start.constant_result : self.stop.constant_result]

2001

2002 def compile_time_value(self, denv):

2003 base = self.base.compile_time_value(denv)

2004 if self.start is None:

2005 start = 0

2006 else:

2007 start = self.start.compile_time_value(denv)

2008 if self.stop is None:

2009 stop = None

2010 else:

2011 stop = self.stop.compile_time_value(denv)

2012 try:

2013 return base[start:stop]

2014 except Exception, e:

2015 self.compile_time_value_error(e)

2016

2017 def analyse_target_declaration(self, env):

2018 pass

2019

2020 def analyse_types(self, env):

2021 self.base.analyse_types(env)

2022 if self.start:

2023 self.start.analyse_types(env)

2024 if self.stop:

2025 self.stop.analyse_types(env)

2026 if self.base.type.is_string:

2027 self.type = py_object_type

2028 elif self.base.type.is_array or self.base.type.is_ptr:

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

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

2031 # code

2032 self.type = PyrexTypes.CPtrType(self.base.type.base_type)

2033 else:

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

2035 self.type = py_object_type

2036 c_int = PyrexTypes.c_py_ssize_t_type

2037 if self.start:

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

2039 if self.stop:

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

2041 self.is_temp = 1

2042

2043 gil_check = ExprNode._gil_check

2044 gil_message = "Slicing Python object"

2045

2046 def generate_result_code(self, code):

2047 if not self.type.is_pyobject:

2048 error(self.pos,

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

2050 return

2051 if self.base.type.is_string:

2052 if self.stop is None:

2053 code.putln(

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

2055 self.result(),

2056 self.base.result(),

2057 self.start_code(),

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

2059 else:

2060 code.putln(

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

2062 self.result(),

2063 self.base.result(),

2064 self.start_code(),

2065 self.stop_code(),

2066 self.start_code(),

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

2068 else:

2069 code.putln(

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

2071 self.result(),

2072 self.base.py_result(),

2073 self.start_code(),

2074 self.stop_code(),

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

2076 code.put_gotref(self.py_result())

2077

2078 def generate_assignment_code(self, rhs, code):

2079 self.generate_subexpr_evaluation_code(code)

2080 if self.type.is_pyobject:

2081 code.put_error_if_neg(self.pos,

2082 "PySequence_SetSlice(%s, %s, %s, %s)" % (

2083 self.base.py_result(),

2084 self.start_code(),

2085 self.stop_code(),

2086 rhs.result()))

2087 else:

2088 start_offset = ''

2089 if self.start:

2090 start_offset = self.start_code()

2091 if start_offset == '0':

2092 start_offset = ''

2093 else:

2094 start_offset += '+'

2095 if rhs.type.is_array:

2096 array_length = rhs.type.size

2097 self.generate_slice_guard_code(code, array_length)

2098 else:

2099 error("Slice assignments from pointers are not yet supported.")

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

2101 array_length = self.base.type.size

2102 for i in range(array_length):

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

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

2105 rhs.result(), i))

2106 self.generate_subexpr_disposal_code(code)

2107 self.free_subexpr_temps(code)

2108 rhs.generate_disposal_code(code)

2109 rhs.free_temps(code)

2110

2111 def generate_deletion_code(self, code):

2112 if not self.base.type.is_pyobject:

2113 error(self.pos,

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

2115 return

2116 self.generate_subexpr_evaluation_code(code)

2117 code.put_error_if_neg(self.pos,

2118 "PySequence_DelSlice(%s, %s, %s)" % (

2119 self.base.py_result(),

2120 self.start_code(),

2121 self.stop_code()))

2122 self.generate_subexpr_disposal_code(code)

2123

2124 def generate_slice_guard_code(self, code, target_size):

2125 if not self.base.type.is_array:

2126 return

2127 slice_size = self.base.type.size

2128 start = stop = None

2129 if self.stop:

2130 stop = self.stop.result()

2131 try:

2132 stop = int(stop)

2133 if stop < 0:

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

2135 else:

2136 slice_size = stop

2137 stop = None

2138 except ValueError:

2139 pass

2140 if self.start:

2141 start = self.start.result()

2142 try:

2143 start = int(start)

2144 if start < 0:

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

2146 slice_size -= start

2147 start = None

2148 except ValueError:

2149 pass

2150 check = None

2151 if slice_size < 0:

2152 if target_size > 0:

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

2154 elif start is None and stop is None:

2155 # we know the exact slice length

2156 if target_size != slice_size:

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

2158 slice_size, target_size))

2159 elif start is not None:

2160 if stop is None:

2161 stop = slice_size

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

2163 else: # stop is not None:

2164 check = stop

2165 if check:

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

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

2168 target_size, check))

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

2170 code.putln("}")

2171

2172 def start_code(self):

2173 if self.start:

2174 return self.start.result()

2175 else:

2176 return "0"

2177

2178 def stop_code(self):

2179 if self.stop:

2180 return self.stop.result()

2181 elif self.base.type.is_array:

2182 return self.base.type.size

2183 else:

2184 return "PY_SSIZE_T_MAX"

2185

2186 def calculate_result_code(self):

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

2188 return "<unused>"

2189

2190

2191 class SliceNode(NewTempExprNode):

2192 # start:stop:step in subscript list

2193 #

2194 # start ExprNode

2195 # stop ExprNode

2196 # step ExprNode

2197

2198 def calculate_constant_result(self):

2199 self.constant_result = self.base.constant_result[

2200 self.start.constant_result : \

2201 self.stop.constant_result : \

2202 self.step.constant_result]

2203

2204 def compile_time_value(self, denv):

2205 start = self.start.compile_time_value(denv)

2206 if self.stop is None:

2207 stop = None

2208 else:

2209 stop = self.stop.compile_time_value(denv)

2210 if self.step is None:

2211 step = None

2212 else:

2213 step = self.step.compile_time_value(denv)

2214 try:

2215 return slice(start, stop, step)

2216 except Exception, e:

2217 self.compile_time_value_error(e)

2218

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

2220

2221 def analyse_types(self, env):

2222 self.start.analyse_types(env)

2223 self.stop.analyse_types(env)

2224 self.step.analyse_types(env)

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

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

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

2228 self.type = py_object_type

2229 self.is_temp = 1

2230

2231 gil_message = "Constructing Python slice object"

2232

2233 def generate_result_code(self, code):

2234 code.putln(

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

2236 self.result(),

2237 self.start.py_result(),

2238 self.stop.py_result(),

2239 self.step.py_result(),

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

2241 code.put_gotref(self.py_result())

2242

2243

2244 class CallNode(NewTempExprNode):

2245 def analyse_as_type_constructor(self, env):

2246 type = self.function.analyse_as_type(env)

2247 if type and type.is_struct_or_union:

2248 args, kwds = self.explicit_args_kwds()

2249 items = []

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

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

2252 if kwds:

2253 items += kwds.key_value_pairs

2254 self.key_value_pairs = items

2255 self.__class__ = DictNode

2256 self.analyse_types(env)

2257 self.coerce_to(type, env)

2258 return True

2259

2260 def gil_check(self, env):

2261 func_type = self.function_type()

2262 if func_type.is_pyobject:

2263 self._gil_check(env)

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

2265 self._gil_check(env)

2266

2267 gil_message = "Calling gil-requiring function"

2268

2269

2270 class SimpleCallNode(CallNode):

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

2272 #

2273 # function ExprNode

2274 # args [ExprNode]

2275 # arg_tuple ExprNode or None used internally

2276 # self ExprNode or None used internally

2277 # coerced_self ExprNode or None used internally

2278 # wrapper_call bool used internally

2279 # has_optional_args bool used internally

2280

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

2282

2283 self = None

2284 coerced_self = None

2285 arg_tuple = None

2286 wrapper_call = False

2287 has_optional_args = False

2288

2289 def compile_time_value(self, denv):

2290 function = self.function.compile_time_value(denv)

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

2292 try:

2293 return function(*args)

2294 except Exception, e:

2295 self.compile_time_value_error(e)

2296

2297 def analyse_as_type(self, env):

2298 attr = self.function.as_cython_attribute()

2299 if attr == 'pointer':

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

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

2302 else:

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

2304 if not type:

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

2306 else:

2307 return PyrexTypes.CPtrType(type)

2308

2309 def explicit_args_kwds(self):

2310 return self.args, None

2311

2312 def analyse_types(self, env):

2313 if self.analyse_as_type_constructor(env):

2314 return

2315 function = self.function

2316 function.is_called = 1

2317 self.function.analyse_types(env)

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

2319 # Take ownership of the object from which the attribute

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

2321 self.self = function.obj

2322 function.obj = CloneNode(self.self)

2323 func_type = self.function_type()

2324 if func_type.is_pyobject:

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

2326 self.arg_tuple.analyse_types(env)

2327 self.args = None

2328 self.type = py_object_type

2329 self.is_temp = 1

2330 else:

2331 for arg in self.args:

2332 arg.analyse_types(env)

2333 if self.self and func_type.args:

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

2335 expected_type = func_type.args[0].type

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

2337 expected_type, env)

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

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

2340 self.analyse_c_function_call(env)

2341

2342 def function_type(self):

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

2344 # pointer to a function if necessary.

2345 func_type = self.function.type

2346 if func_type.is_ptr:

2347 func_type = func_type.base_type

2348 return func_type

2349

2350 def analyse_c_function_call(self, env):

2351 func_type = self.function_type()

2352 # Check function type

2353 if not func_type.is_cfunction:

2354 if not func_type.is_error:

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

2356 func_type)

2357 self.type = PyrexTypes.error_type

2358 self.result_code = "<error>"

2359 return

2360 # Check no. of args

2361 max_nargs = len(func_type.args)

2362 expected_nargs = max_nargs - func_type.optional_arg_count

2363 actual_nargs = len(self.args)

2364 if actual_nargs < expected_nargs \

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

2366 expected_str = str(expected_nargs)

2367 if func_type.has_varargs:

2368 expected_str = "at least " + expected_str

2369 elif func_type.optional_arg_count:

2370 if actual_nargs < max_nargs:

2371 expected_str = "at least " + expected_str

2372 else:

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

2374 error(self.pos,

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

2376 % (expected_str, actual_nargs))

2377 self.args = None

2378 self.type = PyrexTypes.error_type

2379 self.result_code = "<error>"

2380 return

2381 if func_type.optional_arg_count and expected_nargs != actual_nargs:

2382 self.has_optional_args = 1

2383 self.is_temp = 1

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

2385 env.release_temp(self.opt_arg_struct)

2386 # Coerce arguments

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

2388 formal_type = func_type.args[i].type

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

2390 for i in range(max_nargs, actual_nargs):

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

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

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

2394 # Calc result type and code fragment

2395 self.type = func_type.return_type

2396 if self.type.is_pyobject:

2397 self.result_ctype = py_object_type

2398 self.is_temp = 1

2399 elif func_type.exception_value is not None \

2400 or func_type.exception_check:

2401 self.is_temp = 1

2402 # C++ exception handler

2403 if func_type.exception_check == '+':

2404 if func_type.exception_value is None:

2405 env.use_utility_code(cpp_exception_utility_code)

2406

2407 def calculate_result_code(self):

2408 return self.c_call_code()

2409

2410 def c_call_code(self):

2411 func_type = self.function_type()

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

2413 return "<error>"

2414 formal_args = func_type.args

2415 arg_list_code = []

2416 args = zip(formal_args, self.args)

2417 max_nargs = len(func_type.args)

2418 expected_nargs = max_nargs - func_type.optional_arg_count

2419 actual_nargs = len(self.args)

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

2421 arg_code = actual_arg.result_as(formal_arg.type)

2422 arg_list_code.append(arg_code)

2423

2424 if func_type.is_overridable:

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

2426

2427 if func_type.optional_arg_count:

2428 if expected_nargs == actual_nargs:

2429 optional_args = 'NULL'

2430 else:

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

2432 arg_list_code.append(optional_args)

2433

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

2435 arg_list_code.append(actual_arg.result())

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

2437 ', '.join(arg_list_code))

2438 # if self.wrapper_call or \

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

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

2441 return result

2442

2443 def generate_result_code(self, code):

2444 func_type = self.function_type()

2445 if func_type.is_pyobject:

2446 arg_code = self.arg_tuple.py_result()

2447 code.putln(

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

2449 self.result(),

2450 self.function.py_result(),

2451 arg_code,

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

2453 code.put_gotref(self.py_result())

2454 elif func_type.is_cfunction:

2455 if self.has_optional_args:

2456 actual_nargs = len(self.args)

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

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

2459 self.opt_arg_struct,

2460 Naming.pyrex_prefix + "n",

2461 len(self.args) - expected_nargs))

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

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

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

2465 self.opt_arg_struct,

2466 formal_arg.name,

2467 actual_arg.result_as(formal_arg.type)))

2468 exc_checks = []

2469 if self.type.is_pyobject:

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

2471 else:

2472 exc_val = func_type.exception_value

2473 exc_check = func_type.exception_check

2474 if exc_val is not None:

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

2476 if exc_check:

2477 exc_checks.append("PyErr_Occurred()")

2478 if self.is_temp or exc_checks:

2479 rhs = self.c_call_code()

2480 if self.result():

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

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

2483 #return_type = self.type # func_type.return_type

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

2485 # "from", return_type, "to pyobject" ###

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

2487 else:

2488 lhs = ""

2489 if func_type.exception_check == '+':

2490 if func_type.exception_value is None:

2491 raise_py_exception = "__Pyx_CppExn2PyErr()"

2492 elif func_type.exception_value.type.is_pyobject:

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

2494 else:

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

2496 code.putln(

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

2498 lhs,

2499 rhs,

2500 raise_py_exception,

2501 code.error_goto(self.pos)))

2502 else:

2503 if exc_checks:

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

2505 else:

2506 goto_error = ""

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