1

2 #

3 # Pyrex - Parse tree nodes

4 #

5

6 import sys, os, time, copy

7

8 try:

9 set

10 except NameError:

11 # Python 2.3

12 from sets import Set as set

13

14 import Code

15 import Builtin

16 from Errors import error, warning, InternalError

17 import Naming

18 import PyrexTypes

19 import TypeSlots

20 from PyrexTypes import py_object_type, error_type, CFuncType

21 from Symtab import ModuleScope, LocalScope, ClosureScope, \

22 StructOrUnionScope, PyClassScope, CClassScope, CppClassScope

23 from Cython.Utils import open_new_file, replace_suffix

24 from Code import UtilityCode

25 from StringEncoding import EncodedString, escape_byte_string, split_string_literal

26 import Options

27 import ControlFlow

28 import DebugFlags

29

30 absolute_path_length = 0

31

32 def relative_position(pos):

33 """

34 We embed the relative filename in the generated C file, since we

35 don't want to have to regnerate and compile all the source code

36 whenever the Python install directory moves (which could happen,

37 e.g,. when distributing binaries.)

38

39 INPUT:

40 a position tuple -- (absolute filename, line number column position)

41

42 OUTPUT:

43 relative filename

44 line number

45

46 AUTHOR: William Stein

47 """

48 global absolute_path_length

49 if absolute_path_length==0:

50 absolute_path_length = len(os.path.abspath(os.getcwd()))

51 return (pos[0].get_filenametable_entry()[absolute_path_length+1:], pos[1])

52

53 def embed_position(pos, docstring):

54 if not Options.embed_pos_in_docstring:

55 return docstring

56 pos_line = u'File: %s (starting at line %s)' % relative_position(pos)

57 if docstring is None:

58 # unicode string

59 return EncodedString(pos_line)

60

61 # make sure we can encode the filename in the docstring encoding

62 # otherwise make the docstring a unicode string

63 encoding = docstring.encoding

64 if encoding is not None:

65 try:

66 encoded_bytes = pos_line.encode(encoding)

67 except UnicodeEncodeError:

68 encoding = None

69

70 if not docstring:

71 # reuse the string encoding of the original docstring

72 doc = EncodedString(pos_line)

73 else:

74 doc = EncodedString(pos_line + u'\n' + docstring)

75 doc.encoding = encoding

76 return doc

77

78

79 from Code import CCodeWriter

80 from types import FunctionType

81

82 def write_func_call(func):

83 def f(*args, **kwds):

84 if len(args) > 1 and isinstance(args[1], CCodeWriter):

85 # here we annotate the code with this function call

86 # but only if new code is generated

87 node, code = args[:2]

88 marker = ' /* %s -> %s.%s %s */' % (

89 ' ' * code.call_level,

90 node.__class__.__name__,

91 func.__name__,

92 node.pos[1:])

93 pristine = code.buffer.stream.tell()

94 code.putln(marker)

95 start = code.buffer.stream.tell()

96 code.call_level += 4

97 res = func(*args, **kwds)

98 code.call_level -= 4

99 if start == code.buffer.stream.tell():

100 code.buffer.stream.seek(pristine)

101 else:

102 marker = marker.replace('->', '<-')

103 code.putln(marker)

104 return res

105 else:

106 return func(*args, **kwds)

107 return f

108

109 class VerboseCodeWriter(type):

110 # Set this as a metaclass to trace function calls in code.

111 # This slows down code generation and makes much larger files.

112 def __new__(cls, name, bases, attrs):

113 attrs = dict(attrs)

114 for mname, m in attrs.items():

115 if isinstance(m, FunctionType):

116 attrs[mname] = write_func_call(m)

117 return super(VerboseCodeWriter, cls).__new__(cls, name, bases, attrs)

118

119

120 class Node(object):

121 # pos (string, int, int) Source file position

122 # is_name boolean Is a NameNode

123 # is_literal boolean Is a ConstNode

124

125 if DebugFlags.debug_trace_code_generation:

126 __metaclass__ = VerboseCodeWriter

127

128 is_name = 0

129 is_literal = 0

130 temps = None

131

132 # All descandants should set child_attrs to a list of the attributes

133 # containing nodes considered "children" in the tree. Each such attribute

134 # can either contain a single node or a list of nodes. See Visitor.py.

135 child_attrs = None

136

137 def __init__(self, pos, **kw):

138 self.pos = pos

139 self.__dict__.update(kw)

140

141 gil_message = "Operation"

142

143 nogil_check = None

144

145 def gil_error(self, env=None):

146 error(self.pos, "%s not allowed without gil" % self.gil_message)

147

148 cpp_message = "Operation"

149

150 def cpp_check(self, env):

151 if not env.is_cpp():

152 self.cpp_error()

153

154 def cpp_error(self):

155 error(self.pos, "%s only allowed in c++" % self.cpp_message)

156

157 def clone_node(self):

158 """Clone the node. This is defined as a shallow copy, except for member lists

159 amongst the child attributes (from get_child_accessors) which are also

160 copied. Lists containing child nodes are thus seen as a way for the node

161 to hold multiple children directly; the list is not treated as a seperate

162 level in the tree."""

163 result = copy.copy(self)

164 for attrname in result.child_attrs:

165 value = getattr(result, attrname)

166 if isinstance(value, list):

167 setattr(result, attrname, [x for x in value])

168 return result

169

170

171 #

172 # There are 4 phases of parse tree processing, applied in order to

173 # all the statements in a given scope-block:

174 #

175 # (0) analyse_control_flow

176 # Create the control flow tree into which state can be asserted and

177 # queried.

178 #

179 # (1) analyse_declarations

180 # Make symbol table entries for all declarations at the current

181 # level, both explicit (def, cdef, etc.) and implicit (assignment

182 # to an otherwise undeclared name).

183 #

184 # (2) analyse_expressions

185 # Determine the result types of expressions and fill in the

186 # 'type' attribute of each ExprNode. Insert coercion nodes into the

187 # tree where needed to convert to and from Python objects.

188 # Allocate temporary locals for intermediate results. Fill

189 # in the 'result_code' attribute of each ExprNode with a C code

190 # fragment.

191 #

192 # (3) generate_code

193 # Emit C code for all declarations, statements and expressions.

194 # Recursively applies the 3 processing phases to the bodies of

195 # functions.

196 #

197

198 def analyse_control_flow(self, env):

199 pass

200

201 def analyse_declarations(self, env):

202 pass

203

204 def analyse_expressions(self, env):

205 raise InternalError("analyse_expressions not implemented for %s" % \

206 self.__class__.__name__)

207

208 def generate_code(self, code):

209 raise InternalError("generate_code not implemented for %s" % \

210 self.__class__.__name__)

211

212 def annotate(self, code):

213 # mro does the wrong thing

214 if isinstance(self, BlockNode):

215 self.body.annotate(code)

216

217 def end_pos(self):

218 try:

219 return self._end_pos

220 except AttributeError:

221 pos = self.pos

222 if not self.child_attrs:

223 self._end_pos = pos

224 return pos

225 for attr in self.child_attrs:

226 child = getattr(self, attr)

227 # Sometimes lists, sometimes nodes

228 if child is None:

229 pass

230 elif isinstance(child, list):

231 for c in child:

232 pos = max(pos, c.end_pos())

233 else:

234 pos = max(pos, child.end_pos())

235 self._end_pos = pos

236 return pos

237

238 def dump(self, level=0, filter_out=("pos",), cutoff=100, encountered=None):

239 if cutoff == 0:

240 return "<...nesting level cutoff...>"

241 if encountered is None:

242 encountered = set()

243 if id(self) in encountered:

244 return "<%s (%d) -- already output>" % (self.__class__.__name__, id(self))

245 encountered.add(id(self))

246

247 def dump_child(x, level):

248 if isinstance(x, Node):

249 return x.dump(level, filter_out, cutoff-1, encountered)

250 elif isinstance(x, list):

251 return "[%s]" % ", ".join([dump_child(item, level) for item in x])

252 else:

253 return repr(x)

254

255

256 attrs = [(key, value) for key, value in self.__dict__.iteritems() if key not in filter_out]

257 if len(attrs) == 0:

258 return "<%s (%d)>" % (self.__class__.__name__, id(self))

259 else:

260 indent = " " * level

261 res = "<%s (%d)\n" % (self.__class__.__name__, id(self))

262 for key, value in attrs:

263 res += "%s %s: %s\n" % (indent, key, dump_child(value, level + 1))

264 res += "%s>" % indent

265 return res

266

267 class CompilerDirectivesNode(Node):

268 """

269 Sets compiler directives for the children nodes

270 """

271 # directives {string:value} A dictionary holding the right value for

272 # *all* possible directives.

273 # body Node

274 child_attrs = ["body"]

275

276 def analyse_control_flow(self, env):

277 old = env.directives

278 env.directives = self.directives

279 self.body.analyse_control_flow(env)

280 env.directives = old

281

282 def analyse_declarations(self, env):

283 old = env.directives

284 env.directives = self.directives

285 self.body.analyse_declarations(env)

286 env.directives = old

287

288 def analyse_expressions(self, env):

289 old = env.directives

290 env.directives = self.directives

291 self.body.analyse_expressions(env)

292 env.directives = old

293

294 def generate_function_definitions(self, env, code):

295 env_old = env.directives

296 code_old = code.globalstate.directives

297 code.globalstate.directives = self.directives

298 self.body.generate_function_definitions(env, code)

299 env.directives = env_old

300 code.globalstate.directives = code_old

301

302 def generate_execution_code(self, code):

303 old = code.globalstate.directives

304 code.globalstate.directives = self.directives

305 self.body.generate_execution_code(code)

306 code.globalstate.directives = old

307

308 def annotate(self, code):

309 old = code.globalstate.directives

310 code.globalstate.directives = self.directives

311 self.body.annotate(code)

312 code.globalstate.directives = old

313

314 class BlockNode(object):

315 # Mixin class for nodes representing a declaration block.

316

317 def generate_cached_builtins_decls(self, env, code):

318 entries = env.global_scope().undeclared_cached_builtins

319 for entry in entries:

320 code.globalstate.add_cached_builtin_decl(entry)

321 del entries[:]

322

323

324 class StatListNode(Node):

325 # stats a list of StatNode

326

327 child_attrs = ["stats"]

328

329 def create_analysed(pos, env, *args, **kw):

330 node = StatListNode(pos, *args, **kw)

331 return node # No node-specific analysis necesarry

332 create_analysed = staticmethod(create_analysed)

333

334 def analyse_control_flow(self, env):

335 for stat in self.stats:

336 stat.analyse_control_flow(env)

337

338 def analyse_declarations(self, env):

339 #print "StatListNode.analyse_declarations" ###

340 for stat in self.stats:

341 stat.analyse_declarations(env)

342

343 def analyse_expressions(self, env):

344 #print "StatListNode.analyse_expressions" ###

345 for stat in self.stats:

346 stat.analyse_expressions(env)

347

348 def generate_function_definitions(self, env, code):

349 #print "StatListNode.generate_function_definitions" ###

350 for stat in self.stats:

351 stat.generate_function_definitions(env, code)

352

353 def generate_execution_code(self, code):

354 #print "StatListNode.generate_execution_code" ###

355 for stat in self.stats:

356 code.mark_pos(stat.pos)

357 stat.generate_execution_code(code)

358

359 def annotate(self, code):

360 for stat in self.stats:

361 stat.annotate(code)

362

363

364 class StatNode(Node):

365 #

366 # Code generation for statements is split into the following subphases:

367 #

368 # (1) generate_function_definitions

369 # Emit C code for the definitions of any structs,

370 # unions, enums and functions defined in the current

371 # scope-block.

372 #

373 # (2) generate_execution_code

374 # Emit C code for executable statements.

375 #

376

377 def generate_function_definitions(self, env, code):

378 pass

379

380 def generate_execution_code(self, code):

381 raise InternalError("generate_execution_code not implemented for %s" % \

382 self.__class__.__name__)

383

384

385 class CDefExternNode(StatNode):

386 # include_file string or None

387 # body StatNode

388

389 child_attrs = ["body"]

390

391 def analyse_declarations(self, env):

392 if self.include_file:

393 env.add_include_file(self.include_file)

394 old_cinclude_flag = env.in_cinclude

395 env.in_cinclude = 1

396 self.body.analyse_declarations(env)

397 env.in_cinclude = old_cinclude_flag

398

399 def analyse_expressions(self, env):

400 pass

401

402 def generate_execution_code(self, code):

403 pass

404

405 def annotate(self, code):

406 self.body.annotate(code)

407

408

409 class CDeclaratorNode(Node):

410 # Part of a C declaration.

411 #

412 # Processing during analyse_declarations phase:

413 #

414 # analyse

415 # Returns (name, type) pair where name is the

416 # CNameDeclaratorNode of the name being declared

417 # and type is the type it is being declared as.

418 #

419 # calling_convention string Calling convention of CFuncDeclaratorNode

420 # for which this is a base

421

422 child_attrs = []

423

424 calling_convention = ""

425

426

427 class CNameDeclaratorNode(CDeclaratorNode):

428 # name string The Pyrex name being declared

429 # cname string or None C name, if specified

430 # default ExprNode or None the value assigned on declaration

431

432 child_attrs = ['default']

433

434 default = None

435

436 def analyse(self, base_type, env, nonempty = 0):

437 if nonempty and self.name == '':

438 # May have mistaken the name for the type.

439 if base_type.is_ptr or base_type.is_array or base_type.is_buffer:

440 error(self.pos, "Missing argument name")

441 elif base_type.is_void:

442 error(self.pos, "Use spam() rather than spam(void) to declare a function with no arguments.")

443 else:

444 self.name = base_type.declaration_code("", for_display=1, pyrex=1)

445 base_type = py_object_type

446 self.type = base_type

447 return self, base_type

448

449 class CPtrDeclaratorNode(CDeclaratorNode):

450 # base CDeclaratorNode

451

452 child_attrs = ["base"]

453

454 def analyse(self, base_type, env, nonempty = 0):

455 if base_type.is_pyobject:

456 error(self.pos,

457 "Pointer base type cannot be a Python object")

458 ptr_type = PyrexTypes.c_ptr_type(base_type)

459 return self.base.analyse(ptr_type, env, nonempty = nonempty)

460

461 class CReferenceDeclaratorNode(CDeclaratorNode):

462 # base CDeclaratorNode

463

464 child_attrs = ["base"]

465

466 def analyse(self, base_type, env, nonempty = 0):

467 if base_type.is_pyobject:

468 error(self.pos,

469 "Reference base type cannot be a Python object")

470 ref_type = PyrexTypes.c_ref_type(base_type)

471 return self.base.analyse(ref_type, env, nonempty = nonempty)

472

473 class CArrayDeclaratorNode(CDeclaratorNode):

474 # base CDeclaratorNode

475 # dimension ExprNode

476

477 child_attrs = ["base", "dimension"]

478

479 def analyse(self, base_type, env, nonempty = 0):

480 if base_type.is_cpp_class:

481 from ExprNodes import TupleNode

482 if isinstance(self.dimension, TupleNode):

483 args = self.dimension.args

484 else:

485 args = self.dimension,

486 values = [v.analyse_as_type(env) for v in args]

487 if None in values:

488 ix = values.index(None)

489 error(args[ix].pos, "Template parameter not a type.")

490 return error_type

491 base_type = base_type.specialize_here(self.pos, values)

492 return self.base.analyse(base_type, env, nonempty = nonempty)

493 if self.dimension:

494 self.dimension.analyse_const_expression(env)

495 if not self.dimension.type.is_int:

496 error(self.dimension.pos, "Array dimension not integer")

497 size = self.dimension.get_constant_c_result_code()

498 if size is not None:

499 try:

500 size = int(size)

501 except ValueError:

502 # runtime constant?

503 pass

504 else:

505 size = None

506 if not base_type.is_complete():

507 error(self.pos,

508 "Array element type '%s' is incomplete" % base_type)

509 if base_type.is_pyobject:

510 error(self.pos,

511 "Array element cannot be a Python object")

512 if base_type.is_cfunction:

513 error(self.pos,

514 "Array element cannot be a function")

515 array_type = PyrexTypes.c_array_type(base_type, size)

516 return self.base.analyse(array_type, env, nonempty = nonempty)

517

518

519 class CFuncDeclaratorNode(CDeclaratorNode):

520 # base CDeclaratorNode

521 # args [CArgDeclNode]

522 # has_varargs boolean

523 # exception_value ConstNode

524 # exception_check boolean True if PyErr_Occurred check needed

525 # nogil boolean Can be called without gil

526 # with_gil boolean Acquire gil around function body

527

528 child_attrs = ["base", "args", "exception_value"]

529

530 overridable = 0

531 optional_arg_count = 0

532

533 def analyse(self, return_type, env, nonempty = 0):

534 if nonempty:

535 nonempty -= 1

536 func_type_args = []

537 for arg_node in self.args:

538 name_declarator, type = arg_node.analyse(env, nonempty = nonempty)

539 name = name_declarator.name

540 if name_declarator.cname:

541 error(self.pos,

542 "Function argument cannot have C name specification")

543 # Turn *[] argument into **

544 if type.is_array:

545 type = PyrexTypes.c_ptr_type(type.base_type)

546 # Catch attempted C-style func(void) decl

547 if type.is_void:

548 error(arg_node.pos, "Use spam() rather than spam(void) to declare a function with no arguments.")

549 func_type_args.append(

550 PyrexTypes.CFuncTypeArg(name, type, arg_node.pos))

551 if arg_node.default:

552 self.optional_arg_count += 1

553 elif self.optional_arg_count:

554 error(self.pos, "Non-default argument follows default argument")

555

556 if self.optional_arg_count:

557 scope = StructOrUnionScope()

558 arg_count_member = '%sn' % Naming.pyrex_prefix

559 scope.declare_var(arg_count_member, PyrexTypes.c_int_type, self.pos)

560 for arg in func_type_args[len(func_type_args)-self.optional_arg_count:]:

561 scope.declare_var(arg.name, arg.type, arg.pos, allow_pyobject = 1)

562 struct_cname = env.mangle(Naming.opt_arg_prefix, self.base.name)

563 self.op_args_struct = env.global_scope().declare_struct_or_union(name = struct_cname,

564 kind = 'struct',

565 scope = scope,

566 typedef_flag = 0,

567 pos = self.pos,

568 cname = struct_cname)

569 self.op_args_struct.defined_in_pxd = 1

570 self.op_args_struct.used = 1

571

572 exc_val = None

573 exc_check = 0

574 if self.exception_check == '+':

575 env.add_include_file('stdexcept')

576 if return_type.is_pyobject \

577 and (self.exception_value or self.exception_check) \

578 and self.exception_check != '+':

579 error(self.pos,

580 "Exception clause not allowed for function returning Python object")

581 else:

582 if self.exception_value:

583 self.exception_value.analyse_const_expression(env)

584 if self.exception_check == '+':

585 self.exception_value.analyse_types(env)

586 exc_val_type = self.exception_value.type

587 if not exc_val_type.is_error and \

588 not exc_val_type.is_pyobject and \

589 not (exc_val_type.is_cfunction and not exc_val_type.return_type.is_pyobject and len(exc_val_type.args)==0):

590 error(self.exception_value.pos,

591 "Exception value must be a Python exception or cdef function with no arguments.")

592 exc_val = self.exception_value

593 else:

594 if self.exception_value.analyse_const_expression(env):

595 exc_val = self.exception_value.get_constant_c_result_code()

596 if exc_val is None:

597 raise InternalError("get_constant_c_result_code not implemented for %s" %

598 self.exception_value.__class__.__name__)

599 if not return_type.assignable_from(self.exception_value.type):

600 error(self.exception_value.pos,

601 "Exception value incompatible with function return type")

602 exc_check = self.exception_check

603 if return_type.is_array:

604 error(self.pos,

605 "Function cannot return an array")

606 if return_type.is_cfunction:

607 error(self.pos,

608 "Function cannot return a function")

609 func_type = PyrexTypes.CFuncType(

610 return_type, func_type_args, self.has_varargs,

611 optional_arg_count = self.optional_arg_count,

612 exception_value = exc_val, exception_check = exc_check,

613 calling_convention = self.base.calling_convention,

614 nogil = self.nogil, with_gil = self.with_gil, is_overridable = self.overridable)

615 if self.optional_arg_count:

616 func_type.op_arg_struct = PyrexTypes.c_ptr_type(self.op_args_struct.type)

617 callspec = env.directives['callspec']

618 if callspec:

619 current = func_type.calling_convention

620 if current and current != callspec:

621 error(self.pos, "cannot have both '%s' and '%s' "

622 "calling conventions" % (current, callspec))

623 func_type.calling_convention = callspec

624 return self.base.analyse(func_type, env)

625

626

627 class CArgDeclNode(Node):

628 # Item in a function declaration argument list.

629 #

630 # base_type CBaseTypeNode

631 # declarator CDeclaratorNode

632 # not_none boolean Tagged with 'not None'

633 # or_none boolean Tagged with 'or None'

634 # accept_none boolean Resolved boolean for not_none/or_none

635 # default ExprNode or None

636 # default_value PyObjectConst constant for default value

637 # annotation ExprNode or None Py3 function arg annotation

638 # is_self_arg boolean Is the "self" arg of an extension type method

639 # is_type_arg boolean Is the "class" arg of an extension type classmethod

640 # is_kw_only boolean Is a keyword-only argument

641

642 child_attrs = ["base_type", "declarator", "default"]

643

644 is_self_arg = 0

645 is_type_arg = 0

646 is_generic = 1

647 type = None

648 name_declarator = None

649 default_value = None

650 annotation = None

651

652 def analyse(self, env, nonempty = 0):

653 #print "CArgDeclNode.analyse: is_self_arg =", self.is_self_arg ###

654 if self.type is None:

655 # The parser may missinterpret names as types...

656 # We fix that here.

657 if isinstance(self.declarator, CNameDeclaratorNode) and self.declarator.name == '':

658 if nonempty:

659 self.declarator.name = self.base_type.name

660 self.base_type.name = None

661 self.base_type.is_basic_c_type = False

662 could_be_name = True

663 else:

664 could_be_name = False

665 base_type = self.base_type.analyse(env, could_be_name = could_be_name)

666 if hasattr(self.base_type, 'arg_name') and self.base_type.arg_name:

667 self.declarator.name = self.base_type.arg_name

668 # The parser is unable to resolve the ambiguity of [] as part of the

669 # type (e.g. in buffers) or empty declarator (as with arrays).

670 # This is only arises for empty multi-dimensional arrays.

671 if (base_type.is_array

672 and isinstance(self.base_type, TemplatedTypeNode)

673 and isinstance(self.declarator, CArrayDeclaratorNode)):

674 declarator = self.declarator

675 while isinstance(declarator.base, CArrayDeclaratorNode):

676 declarator = declarator.base

677 declarator.base = self.base_type.array_declarator

678 base_type = base_type.base_type

679 return self.declarator.analyse(base_type, env, nonempty = nonempty)

680 else:

681 return self.name_declarator, self.type

682

683 def calculate_default_value_code(self, code):

684 if self.default_value is None:

685 if self.default:

686 if self.default.is_literal:

687 # will not output any code, just assign the result_code

688 self.default.generate_evaluation_code(code)

689 return self.type.cast_code(self.default.result())

690 self.default_value = code.get_argument_default_const(self.type)

691 return self.default_value

692

693 def annotate(self, code):

694 if self.default:

695 self.default.annotate(code)

696

697

698 class CBaseTypeNode(Node):

699 # Abstract base class for C base type nodes.

700 #

701 # Processing during analyse_declarations phase:

702 #

703 # analyse

704 # Returns the type.

705

706 pass

707

708 def analyse_as_type(self, env):

709 return self.analyse(env)

710

711 class CAnalysedBaseTypeNode(Node):

712 # type type

713

714 child_attrs = []

715

716 def analyse(self, env, could_be_name = False):

717 return self.type

718

719 class CSimpleBaseTypeNode(CBaseTypeNode):

720 # name string

721 # module_path [string] Qualifying name components

722 # is_basic_c_type boolean

723 # signed boolean

724 # longness integer

725 # complex boolean

726 # is_self_arg boolean Is self argument of C method

727 # ##is_type_arg boolean Is type argument of class method

728

729 child_attrs = []

730 arg_name = None # in case the argument name was interpreted as a type

731

732 def analyse(self, env, could_be_name = False):

733 # Return type descriptor.

734 #print "CSimpleBaseTypeNode.analyse: is_self_arg =", self.is_self_arg ###

735 type = None

736 if self.is_basic_c_type:

737 type = PyrexTypes.simple_c_type(self.signed, self.longness, self.name)

738 if not type:

739 error(self.pos, "Unrecognised type modifier combination")

740 elif self.name == "object" and not self.module_path:

741 type = py_object_type

742 elif self.name is None:

743 if self.is_self_arg and env.is_c_class_scope:

744 #print "CSimpleBaseTypeNode.analyse: defaulting to parent type" ###

745 type = env.parent_type

746 ## elif self.is_type_arg and env.is_c_class_scope:

747 ## type = Builtin.type_type

748 else:

749 type = py_object_type

750 else:

751 if self.module_path:

752 scope = env.find_imported_module(self.module_path, self.pos)

753 else:

754 scope = env

755 if scope:

756 if scope.is_c_class_scope:

757 scope = scope.global_scope()

758 entry = scope.lookup(self.name)

759 if entry and entry.is_type:

760 type = entry.type

761 elif could_be_name:

762 if self.is_self_arg and env.is_c_class_scope:

763 type = env.parent_type

764 ## elif self.is_type_arg and env.is_c_class_scope:

765 ## type = Builtin.type_type

766 else:

767 type = py_object_type

768 self.arg_name = self.name

769 else:

770 if self.templates:

771 if not self.name in self.templates:

772 error(self.pos, "'%s' is not a type identifier" % self.name)

773 type = PyrexTypes.TemplatePlaceholderType(self.name)

774 else:

775 error(self.pos, "'%s' is not a type identifier" % self.name)

776 if self.complex:

777 if not type.is_numeric or type.is_complex:

778 error(self.pos, "can only complexify c numeric types")

779 type = PyrexTypes.CComplexType(type)

780 type.create_declaration_utility_code(env)

781 if type:

782 return type

783 else:

784 return PyrexTypes.error_type

785

786 class CNestedBaseTypeNode(CBaseTypeNode):

787 # For C++ classes that live inside other C++ classes.

788

789 # name string

790 # base_type CBaseTypeNode

791

792 child_attrs = ['base_type']

793

794 def analyse(self, env, could_be_name = None):

795 base_type = self.base_type.analyse(env)

796 if base_type is PyrexTypes.error_type:

797 return PyrexTypes.error_type

798 if not base_type.is_cpp_class:

799 error(self.pos, "'%s' is not a valid type scope" % base_type)

800 return PyrexTypes.error_type

801 type_entry = base_type.scope.lookup_here(self.name)

802 if not type_entry or not type_entry.is_type:

803 error(self.pos, "'%s.%s' is not a type identifier" % (base_type, self.name))

804 return PyrexTypes.error_type

805 return type_entry.type

806

807 class TemplatedTypeNode(CBaseTypeNode):

808 # After parsing:

809 # positional_args [ExprNode] List of positional arguments

810 # keyword_args DictNode Keyword arguments

811 # base_type_node CBaseTypeNode

812

813 # After analysis:

814 # type PyrexTypes.BufferType or PyrexTypes.CppClassType ...containing the right options

815

816

817 child_attrs = ["base_type_node", "positional_args",

818 "keyword_args", "dtype_node"]

819

820 dtype_node = None

821

822 name = None

823

824 def analyse(self, env, could_be_name = False, base_type = None):

825 if base_type is None:

826 base_type = self.base_type_node.analyse(env)

827 if base_type.is_error: return base_type

828

829 if base_type.is_cpp_class:

830 # Templated class

831 if self.keyword_args and self.keyword_args.key_value_pairs:

832 error(self.pos, "c++ templates cannot take keyword arguments");

833 self.type = PyrexTypes.error_type

834 else:

835 template_types = []

836 for template_node in self.positional_args:

837 type = template_node.analyse_as_type(env)

838 if type is None:

839 error(template_node.pos, "unknown type in template argument")

840 return error_type

841 template_types.append(type)

842 self.type = base_type.specialize_here(self.pos, template_types)

843

844 elif base_type.is_pyobject:

845 # Buffer

846 import Buffer

847

848 options = Buffer.analyse_buffer_options(

849 self.pos,

850 env,

851 self.positional_args,

852 self.keyword_args,

853 base_type.buffer_defaults)

854

855 if sys.version_info[0] < 3:

856 # Py 2.x enforces byte strings as keyword arguments ...

857 options = dict([ (name.encode('ASCII'), value)

858 for name, value in options.iteritems() ])

859

860 self.type = PyrexTypes.BufferType(base_type, **options)

861

862 else:

863 # Array

864 empty_declarator = CNameDeclaratorNode(self.pos, name="", cname=None)

865 if len(self.positional_args) > 1 or self.keyword_args.key_value_pairs:

866 error(self.pos, "invalid array declaration")

867 self.type = PyrexTypes.error_type

868 else:

869 # It would be nice to merge this class with CArrayDeclaratorNode,

870 # but arrays are part of the declaration, not the type...

871 if not self.positional_args:

872 dimension = None

873 else:

874 dimension = self.positional_args[0]

875 self.array_declarator = CArrayDeclaratorNode(self.pos,

876 base = empty_declarator,

877 dimension = dimension)

878 self.type = self.array_declarator.analyse(base_type, env)[1]

879

880 return self.type

881

882 class CComplexBaseTypeNode(CBaseTypeNode):

883 # base_type CBaseTypeNode

884 # declarator CDeclaratorNode

885

886 child_attrs = ["base_type", "declarator"]

887

888 def analyse(self, env, could_be_name = False):

889 base = self.base_type.analyse(env, could_be_name)

890 _, type = self.declarator.analyse(base, env)

891 return type

892

893

894 class CVarDefNode(StatNode):

895 # C variable definition or forward/extern function declaration.

896 #

897 # visibility 'private' or 'public' or 'extern'

898 # base_type CBaseTypeNode

899 # declarators [CDeclaratorNode]

900 # in_pxd boolean

901 # api boolean

902 # properties [entry]

903

904 # decorators [cython.locals(...)] or None

905 # directive_locals { string : NameNode } locals defined by cython.locals(...)

906

907 child_attrs = ["base_type", "declarators"]

908 properties = ()

909

910 decorators = None

911 directive_locals = {}

912

913 def analyse_declarations(self, env, dest_scope = None):

914 if not dest_scope:

915 dest_scope = env

916 self.dest_scope = dest_scope

917 base_type = self.base_type.analyse(env)

918

919 # If the field is an external typedef, we cannot be sure about the type,

920 # so do conversion ourself rather than rely on the CPython mechanism (through

921 # a property; made in AnalyseDeclarationsTransform).

922 if (dest_scope.is_c_class_scope

923 and self.visibility in ('public', 'readonly')):

924 self.properties = []

925 need_property = True

926 else:

927 need_property = False

928 visibility = self.visibility

929

930 for declarator in self.declarators:

931 name_declarator, type = declarator.analyse(base_type, env)

932 if not type.is_complete():

933 if not (self.visibility == 'extern' and type.is_array):

934 error(declarator.pos,

935 "Variable type '%s' is incomplete" % type)

936 if self.visibility == 'extern' and type.is_pyobject:

937 error(declarator.pos,

938 "Python object cannot be declared extern")

939 name = name_declarator.name

940 cname = name_declarator.cname

941 if name == '':

942 error(declarator.pos, "Missing name in declaration.")

943 return

944 if type.is_cfunction:

945 entry = dest_scope.declare_cfunction(name, type, declarator.pos,

946 cname = cname, visibility = self.visibility, in_pxd = self.in_pxd,

947 api = self.api)

948 if entry is not None:

949 entry.directive_locals = self.directive_locals

950 else:

951 if self.directive_locals:

952 s.error("Decorators can only be followed by functions")

953 if self.in_pxd and self.visibility != 'extern':

954 error(self.pos,

955 "Only 'extern' C variable declaration allowed in .pxd file")

956 entry = dest_scope.declare_var(name, type, declarator.pos,

957 cname = cname, visibility = visibility, is_cdef = 1)

958 if need_property:

959 self.properties.append(entry)

960

961

962 class CStructOrUnionDefNode(StatNode):

963 # name string

964 # cname string or None

965 # kind "struct" or "union"

966 # typedef_flag boolean

967 # visibility "public" or "private"

968 # in_pxd boolean

969 # attributes [CVarDefNode] or None

970 # entry Entry

971 # packed boolean

972

973 child_attrs = ["attributes"]

974

975 def analyse_declarations(self, env):

976 scope = None

977 if self.visibility == 'extern' and self.packed:

978 error(self.pos, "Cannot declare extern struct as 'packed'")

979 if self.attributes is not None:

980 scope = StructOrUnionScope(self.name)

981 self.entry = env.declare_struct_or_union(

982 self.name, self.kind, scope, self.typedef_flag, self.pos,

983 self.cname, visibility = self.visibility, packed = self.packed)

984 if self.attributes is not None:

985 if self.in_pxd and not env.in_cinclude:

986 self.entry.defined_in_pxd = 1

987 for attr in self.attributes:

988 attr.analyse_declarations(env, scope)

989 if self.visibility != 'extern':

990 need_typedef_indirection = False

991 for attr in scope.var_entries:

992 type = attr.type

993 while type.is_array:

994 type = type.base_type

995 if type == self.entry.type:

996 error(attr.pos, "Struct cannot contain itself as a member.")

997 if self.typedef_flag:

998 while type.is_ptr:

999 type = type.base_type

1000 if type == self.entry.type:

1001 need_typedef_indirection = True

1002 if need_typedef_indirection:

1003 # C can't handle typedef structs that refer to themselves.

1004 struct_entry = self.entry

1005 self.entry = env.declare_typedef(

1006 self.name, struct_entry.type, self.pos,

1007 cname = self.cname, visibility='ignore')

1008 struct_entry.type.typedef_flag = False

1009 # FIXME: this might be considered a hack ;-)

1010 struct_entry.cname = struct_entry.type.cname = \

1011 '_' + self.entry.type.typedef_cname

1012

1013 def analyse_expressions(self, env):

1014 pass

1015

1016 def generate_execution_code(self, code):

1017 pass

1018

1019

1020 class CppClassNode(CStructOrUnionDefNode):

1021

1022 # name string

1023 # cname string or None

1024 # visibility "extern"

1025 # in_pxd boolean

1026 # attributes [CVarDefNode] or None

1027 # entry Entry

1028 # base_classes [string]

1029 # templates [string] or None

1030

1031 def analyse_declarations(self, env):

1032 scope = None

1033 if self.attributes is not None:

1034 scope = CppClassScope(self.name, env)

1035 base_class_types = []

1036 for base_class_name in self.base_classes:

1037 base_class_entry = env.lookup(base_class_name)

1038 if base_class_entry is None:

1039 error(self.pos, "'%s' not found" % base_class_name)

1040 elif not base_class_entry.is_type or not base_class_entry.type.is_cpp_class:

1041 error(self.pos, "'%s' is not a cpp class type" % base_class_name)

1042 else:

1043 base_class_types.append(base_class_entry.type)

1044 if self.templates is None:

1045 template_types = None

1046 else:

1047 template_types = [PyrexTypes.TemplatePlaceholderType(template_name) for template_name in self.templates]

1048 self.entry = env.declare_cpp_class(

1049 self.name, scope, self.pos,

1050 self.cname, base_class_types, visibility = self.visibility, templates = template_types)

1051 self.entry.is_cpp_class = 1

1052 if self.attributes is not None:

1053 if self.in_pxd and not env.in_cinclude:

1054 self.entry.defined_in_pxd = 1

1055 for attr in self.attributes:

1056 attr.analyse_declarations(scope)

1057

1058 class CEnumDefNode(StatNode):

1059 # name string or None

1060 # cname string or None

1061 # items [CEnumDefItemNode]

1062 # typedef_flag boolean

1063 # visibility "public" or "private"

1064 # in_pxd boolean

1065 # entry Entry

1066

1067 child_attrs = ["items"]

1068

1069 def analyse_declarations(self, env):

1070 self.entry = env.declare_enum(self.name, self.pos,

1071 cname = self.cname, typedef_flag = self.typedef_flag,

1072 visibility = self.visibility)

1073 if self.items is not None:

1074 if self.in_pxd and not env.in_cinclude:

1075 self.entry.defined_in_pxd = 1

1076 for item in self.items:

1077 item.analyse_declarations(env, self.entry)

1078

1079 def analyse_expressions(self, env):

1080 pass

1081

1082 def generate_execution_code(self, code):

1083 if self.visibility == 'public':

1084 temp = code.funcstate.allocate_temp(PyrexTypes.py_object_type, manage_ref=True)

1085 for item in self.entry.enum_values:

1086 code.putln("%s = PyInt_FromLong(%s); %s" % (

1087 temp,

1088 item.cname,

1089 code.error_goto_if_null(temp, item.pos)))

1090 code.put_gotref(temp)

1091 code.putln('if (__Pyx_SetAttrString(%s, "%s", %s) < 0) %s' % (

1092 Naming.module_cname,

1093 item.name,

1094 temp,

1095 code.error_goto(item.pos)))

1096 code.put_decref_clear(temp, PyrexTypes.py_object_type)

1097 code.funcstate.release_temp(temp)

1098

1099

1100 class CEnumDefItemNode(StatNode):

1101 # name string

1102 # cname string or None

1103 # value ExprNode or None

1104

1105 child_attrs = ["value"]

1106

1107 def analyse_declarations(self, env, enum_entry):

1108 if self.value:

1109 self.value.analyse_const_expression(env)

1110 if not self.value.type.is_int:

1111 self.value = self.value.coerce_to(PyrexTypes.c_int_type, env)

1112 self.value.analyse_const_expression(env)

1113 entry = env.declare_const(self.name, enum_entry.type,

1114 self.value, self.pos, cname = self.cname,

1115 visibility = enum_entry.visibility)

1116 enum_entry.enum_values.append(entry)

1117

1118

1119 class CTypeDefNode(StatNode):

1120 # base_type CBaseTypeNode

1121 # declarator CDeclaratorNode

1122 # visibility "public" or "private"

1123 # in_pxd boolean

1124

1125 child_attrs = ["base_type", "declarator"]

1126

1127 def analyse_declarations(self, env):

1128 base = self.base_type.analyse(env)

1129 name_declarator, type = self.declarator.analyse(base, env)

1130 name = name_declarator.name

1131 cname = name_declarator.cname

1132 entry = env.declare_typedef(name, type, self.pos,

1133 cname = cname, visibility = self.visibility)

1134 if self.in_pxd and not env.in_cinclude:

1135 entry.defined_in_pxd = 1

1136

1137 def analyse_expressions(self, env):

1138 pass

1139 def generate_execution_code(self, code):

1140 pass

1141

1142

1143 class FuncDefNode(StatNode, BlockNode):

1144 # Base class for function definition nodes.

1145 #

1146 # return_type PyrexType

1147 # #filename string C name of filename string const

1148 # entry Symtab.Entry

1149 # needs_closure boolean Whether or not this function has inner functions/classes/yield

1150 # directive_locals { string : NameNode } locals defined by cython.locals(...)

1151

1152 py_func = None

1153 assmt = None

1154 needs_closure = False

1155 modifiers = []

1156

1157 def analyse_default_values(self, env):

1158 genv = env.global_scope()

1159 default_seen = 0

1160 for arg in self.args:

1161 if arg.default:

1162 default_seen = 1

1163 if arg.is_generic:

1164 arg.default.analyse_types(env)

1165 arg.default = arg.default.coerce_to(arg.type, genv)

1166 else:

1167 error(arg.pos,

1168 "This argument cannot have a default value")

1169 arg.default = None

1170 elif arg.kw_only:

1171 default_seen = 1

1172 elif default_seen:

1173 error(arg.pos, "Non-default argument following default argument")

1174

1175 def need_gil_acquisition(self, lenv):

1176 return 0

1177

1178 def create_local_scope(self, env):

1179 genv = env

1180 while genv.is_py_class_scope or genv.is_c_class_scope:

1181 genv = env.outer_scope

1182 if self.needs_closure:

1183 lenv = ClosureScope(name=self.entry.name,

1184 outer_scope = genv,

1185 scope_name=self.entry.cname)

1186 else:

1187 lenv = LocalScope(name=self.entry.name,

1188 outer_scope=genv,

1189 parent_scope=env)

1190 lenv.return_type = self.return_type

1191 type = self.entry.type

1192 if type.is_cfunction:

1193 lenv.nogil = type.nogil and not type.with_gil

1194 self.local_scope = lenv

1195 lenv.directives = env.directives

1196 return lenv

1197

1198 def generate_function_definitions(self, env, code):

1199 import Buffer

1200

1201 lenv = self.local_scope

1202 if lenv.is_closure_scope:

1203 outer_scope_cname = "%s->%s" % (Naming.cur_scope_cname,

1204 Naming.outer_scope_cname)

1205 else:

1206 outer_scope_cname = Naming.outer_scope_cname

1207 lenv.mangle_closure_cnames(outer_scope_cname)

1208 # Generate closure function definitions

1209 self.body.generate_function_definitions(lenv, code)

1210 # generate lambda function definitions

1211 for node in lenv.lambda_defs:

1212 node.generate_function_definitions(lenv, code)

1213

1214 is_getbuffer_slot = (self.entry.name == "__getbuffer__" and

1215 self.entry.scope.is_c_class_scope)

1216 is_releasebuffer_slot = (self.entry.name == "__releasebuffer__" and

1217 self.entry.scope.is_c_class_scope)

1218 is_buffer_slot = is_getbuffer_slot or is_releasebuffer_slot

1219 if is_buffer_slot:

1220 if 'cython_unused' not in self.modifiers:

1221 self.modifiers = self.modifiers + ['cython_unused']

1222

1223 profile = code.globalstate.directives['profile']

1224 if profile:

1225 if lenv.nogil:

1226 error(self.pos, "Cannot profile nogil function.")

1227 code.globalstate.use_utility_code(profile_utility_code)

1228

1229 # Generate C code for header and body of function

1230 code.enter_cfunc_scope()

1231 code.return_from_error_cleanup_label = code.new_label()

1232

1233 # ----- Top-level constants used by this function

1234 code.mark_pos(self.pos)

1235 self.generate_cached_builtins_decls(lenv, code)

1236 # ----- Function header

1237 code.putln("")

1238 with_pymethdef = self.needs_assignment_synthesis(env, code)

1239 if self.py_func:

1240 self.py_func.generate_function_header(code,

1241 with_pymethdef = with_pymethdef,

1242 proto_only=True)

1243 self.generate_function_header(code,

1244 with_pymethdef = with_pymethdef)

1245 # ----- Local variable declarations

1246 if lenv.is_closure_scope:

1247 code.put(lenv.scope_class.type.declaration_code(Naming.cur_scope_cname))

1248 code.putln(";")

1249 elif env.is_closure_scope:

1250 code.put(env.scope_class.type.declaration_code(Naming.outer_scope_cname))

1251 code.putln(";")

1252 self.generate_argument_declarations(lenv, code)

1253 for entry in lenv.var_entries:

1254 if not entry.in_closure:

1255 code.put_var_declaration(entry)

1256 init = ""

1257 if not self.return_type.is_void:

1258 if self.return_type.is_pyobject:

1259 init = " = NULL"

1260 code.putln(

1261 "%s%s;" %

1262 (self.return_type.declaration_code(Naming.retval_cname),

1263 init))

1264 tempvardecl_code = code.insertion_point()

1265 self.generate_keyword_list(code)

1266 if profile:

1267 code.put_trace_declarations()

1268 # ----- Extern library function declarations

1269 lenv.generate_library_function_declarations(code)

1270 # ----- GIL acquisition

1271 acquire_gil = self.acquire_gil

1272 if acquire_gil:

1273 env.use_utility_code(force_init_threads_utility_code)

1274 code.putln("PyGILState_STATE _save = PyGILState_Ensure();")

1275 # ----- set up refnanny

1276 if not lenv.nogil:

1277 code.put_setup_refcount_context(self.entry.name)

1278 # ----- Automatic lead-ins for certain special functions

1279 if is_getbuffer_slot:

1280 self.getbuffer_init(code)

1281 # ----- Create closure scope object

1282 if self.needs_closure:

1283 code.putln("%s = (%s)%s->tp_new(%s, %s, NULL);" % (

1284 Naming.cur_scope_cname,

1285 lenv.scope_class.type.declaration_code(''),

1286 lenv.scope_class.type.typeptr_cname,

1287 lenv.scope_class.type.typeptr_cname,

1288 Naming.empty_tuple))

1289 code.putln("if (unlikely(!%s)) {" % Naming.cur_scope_cname)

1290 if is_getbuffer_slot:

1291 self.getbuffer_error_cleanup(code)

1292 if not lenv.nogil:

1293 code.put_finish_refcount_context()

1294 # FIXME: what if the error return value is a Python value?

1295 code.putln("return %s;" % self.error_value())

1296 code.putln("}")

1297 code.put_gotref(Naming.cur_scope_cname)

1298 # Note that it is unsafe to decref the scope at this point.

1299 if env.is_closure_scope:

1300 code.putln("%s = (%s)%s;" % (

1301 outer_scope_cname,

1302 env.scope_class.type.declaration_code(''),

1303 Naming.self_cname))

1304 if self.needs_closure:

1305 # inner closures own a reference to their outer parent

1306 code.put_incref(outer_scope_cname, env.scope_class.type)

1307 code.put_giveref(outer_scope_cname)

1308 # ----- Trace function call

1309 if profile:

1310 # this looks a bit late, but if we don't get here due to a

1311 # fatal error before hand, it's not really worth tracing

1312 code.put_trace_call(self.entry.name, self.pos)

1313 # ----- Fetch arguments

1314 self.generate_argument_parsing_code(env, code)

1315 # If an argument is assigned to in the body, we must

1316 # incref it to properly keep track of refcounts.

1317 for entry in lenv.arg_entries:

1318 if entry.type.is_pyobject:

1319 if entry.assignments and not entry.in_closure:

1320 code.put_var_incref(entry)

1321 # ----- Initialise local variables

1322 for entry in lenv.var_entries:

1323 if entry.type.is_pyobject and entry.init_to_none and entry.used:

1324 code.put_init_var_to_py_none(entry)

1325 # ----- Initialise local buffer auxiliary variables

1326 for entry in lenv.var_entries + lenv.arg_entries:

1327 if entry.type.is_buffer and entry.buffer_aux.buffer_info_var.used:

1328 code.putln("%s.buf = NULL;" %

1329 entry.buffer_aux.buffer_info_var.cname)

1330 # ----- Check and convert arguments

1331 self.generate_argument_type_tests(code)

1332 # ----- Acquire buffer arguments

1333 for entry in lenv.arg_entries:

1334 if entry.type.is_buffer:

1335 Buffer.put_acquire_arg_buffer(entry, code, self.pos)

1336

1337 # -------------------------

1338 # ----- Function body -----

1339 # -------------------------

1340 self.body.generate_execution_code(code)

1341

1342 # ----- Default return value

1343 code.putln("")

1344 if self.return_type.is_pyobject:

1345 #if self.return_type.is_extension_type:

1346 # lhs = "(PyObject *)%s" % Naming.retval_cname

1347 #else:

1348 lhs = Naming.retval_cname

1349 code.put_init_to_py_none(lhs, self.return_type)

1350 else:

1351 val = self.return_type.default_value

1352 if val:

1353 code.putln("%s = %s;" % (Naming.retval_cname, val))

1354 # ----- Error cleanup

1355 if code.error_label in code.labels_used:

1356 code.put_goto(code.return_label)

1357 code.put_label(code.error_label)

1358 for cname, type in code.funcstate.all_managed_temps():

1359 code.put_xdecref(cname, type)

1360

1361 # Clean up buffers -- this calls a Python function

1362 # so need to save and restore error state

1363 buffers_present = len(lenv.buffer_entries) > 0

1364 if buffers_present:

1365 code.globalstate.use_utility_code(restore_exception_utility_code)

1366 code.putln("{ PyObject *__pyx_type, *__pyx_value, *__pyx_tb;")

1367 code.putln("__Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);")

1368 for entry in lenv.buffer_entries:

1369 Buffer.put_release_buffer_code(code, entry)

1370 #code.putln("%s = 0;" % entry.cname)

1371 code.putln("__Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}")

1372

1373 err_val = self.error_value()

1374 exc_check = self.caller_will_check_exceptions()

1375 if err_val is not None or exc_check:

1376 # TODO: Fix exception tracing (though currently unused by cProfile).

1377 # code.globalstate.use_utility_code(get_exception_tuple_utility_code)

1378 # code.put_trace_exception()

1379 code.putln('__Pyx_AddTraceback("%s");' % self.entry.qualified_name)

1380 else:

1381 warning(self.entry.pos, "Unraisable exception in function '%s'." \

1382 % self.entry.qualified_name, 0)

1383 code.putln(

1384 '__Pyx_WriteUnraisable("%s");' %

1385 self.entry.qualified_name)

1386 env.use_utility_code(unraisable_exception_utility_code)

1387 env.use_utility_code(restore_exception_utility_code)

1388 default_retval = self.return_type.default_value

1389 if err_val is None and default_retval:

1390 err_val = default_retval

1391 if err_val is not None:

1392 code.putln("%s = %s;" % (Naming.retval_cname, err_val))

1393

1394 if is_getbuffer_slot:

1395 self.getbuffer_error_cleanup(code)

1396

1397 # If we are using the non-error cleanup section we should

1398 # jump past it if we have an error. The if-test below determine

1399 # whether this section is used.

1400 if buffers_present or is_getbuffer_slot:

1401 code.put_goto(code.return_from_error_cleanup_label)

1402

1403

1404 # ----- Non-error return cleanup

1405 code.put_label(code.return_label)

1406 for entry in lenv.buffer_entries:

1407 if entry.used:

1408 Buffer.put_release_buffer_code(code, entry)

1409 if is_getbuffer_slot:

1410 self.getbuffer_normal_cleanup(code)

1411 # ----- Return cleanup for both error and no-error return

1412 code.put_label(code.return_from_error_cleanup_label)

1413 if not Options.init_local_none:

1414 for entry in lenv.var_entries:

1415 if lenv.control_flow.get_state((entry.name, 'initialized')) is not True:

1416 entry.xdecref_cleanup = 1

1417

1418 for entry in lenv.var_entries:

1419 if entry.type.is_pyobject:

1420 if entry.used and not entry.in_closure:

1421 code.put_var_decref(entry)

1422 elif entry.in_closure and self.needs_closure:

1423 code.put_giveref(entry.cname)

1424 # Decref any increfed args

1425 for entry in lenv.arg_entries:

1426 if entry.type.is_pyobject:

1427 if entry.in_closure:

1428 code.put_var_giveref(entry)

1429 elif entry.assignments:

1430 code.put_var_decref(entry)

1431 if self.needs_closure:

1432 code.put_decref(Naming.cur_scope_cname, lenv.scope_class.type)

1433

1434 # ----- Return

1435 # This code is duplicated in ModuleNode.generate_module_init_func

1436 if not lenv.nogil:

1437 default_retval = self.return_type.default_value

1438 err_val = self.error_value()

1439 if err_val is None and default_retval:

1440 err_val = default_retval

1441 if self.return_type.is_pyobject:

1442 code.put_xgiveref(self.return_type.as_pyobject(Naming.retval_cname))

1443

1444 if self.entry.is_special and self.entry.name == "__hash__":

1445 # Returning -1 for __hash__ is supposed to signal an error

1446 # We do as Python instances and coerce -1 into -2.

1447 code.putln("if (unlikely(%s == -1) && !PyErr_Occurred()) %s = -2;" % (

1448 Naming.retval_cname, Naming.retval_cname))

1449

1450 if profile:

1451 if self.return_type.is_pyobject:

1452 code.put_trace_return(Naming.retval_cname)

1453 else:

1454 code.put_trace_return("Py_None")

1455 if not lenv.nogil:

1456 code.put_finish_refcount_context()

1457

1458 if acquire_gil:

1459 code.putln("PyGILState_Release(_save);")

1460

1461 if not self.return_type.is_void:

1462 code.putln("return %s;" % Naming.retval_cname)

1463

1464 code.putln("}")

1465 # ----- Go back and insert temp variable declarations

1466 tempvardecl_code.put_temp_declarations(code.funcstate)

1467 # ----- Python version

1468 code.exit_cfunc_scope()

1469 if self.py_func:

1470 self.py_func.generate_function_definitions(env, code)

1471 self.generate_wrapper_functions(code)

1472

1473 def declare_argument(self, env, arg):

1474 if arg.type.is_void:

1475 error(arg.pos, "Invalid use of 'void'")

1476 elif not arg.type.is_complete() and not arg.type.is_array:

1477 error(arg.pos,

1478 "Argument type '%s' is incomplete" % arg.type)

1479 return env.declare_arg(arg.name, arg.type, arg.pos)

1480

1481 def generate_arg_type_test(self, arg, code):

1482 # Generate type test for one argument.

1483 if arg.type.typeobj_is_available():

1484 code.globalstate.use_utility_code(arg_type_test_utility_code)

1485 typeptr_cname = arg.type.typeptr_cname

1486 arg_code = "((PyObject *)%s)" % arg.entry.cname

1487 code.putln(

1488 'if (unlikely(!__Pyx_ArgTypeTest(%s, %s, %d, "%s", %s))) %s' % (

1489 arg_code,

1490 typeptr_cname,

1491 arg.accept_none,

1492 arg.name,

1493 arg.type.is_builtin_type,

1494 code.error_goto(arg.pos)))

1495 else:

1496 error(arg.pos, "Cannot test type of extern C class "

1497 "without type object name specification")

1498

1499 def generate_arg_none_check(self, arg, code):

1500 # Generate None check for one argument.

1501 code.globalstate.use_utility_code(arg_type_test_utility_code)

1502 code.putln('if (unlikely(((PyObject *)%s) == Py_None)) {' % arg.entry.cname)

1503 code.putln('''PyErr_Format(PyExc_TypeError, "Argument '%s' must not be None"); %s''' % (

1504 arg.name,

1505 code.error_goto(arg.pos)))

1506 code.putln('}')

1507

1508 def generate_wrapper_functions(self, code):

1509 pass

1510

1511 def generate_execution_code(self, code):

1512 # Evaluate and store argument default values

1513 for arg in self.args:

1514 default = arg.default

1515 if default:

1516 if not default.is_literal:

1517 default.generate_evaluation_code(code)

1518 default.make_owned_reference(code)

1519 result = default.result_as(arg.type)

1520 code.putln(

1521 "%s = %s;" % (

1522 arg.calculate_default_value_code(code),

1523 result))

1524 if arg.type.is_pyobject:

1525 code.put_giveref(default.result())

1526 default.generate_post_assignment_code(code)

1527 default.free_temps(code)

1528 # For Python class methods, create and store function object

1529 if self.assmt:

1530 self.assmt.generate_execution_code(code)

1531

1532 #

1533 # Special code for the __getbuffer__ function

1534 #

1535 def getbuffer_init(self, code):

1536 info = self.local_scope.arg_entries[1].cname

1537 # Python 3.0 betas have a bug in memoryview which makes it call

1538 # getbuffer with a NULL parameter. For now we work around this;

1539 # the following line should be removed when this bug is fixed.

1540 code.putln("if (%s == NULL) return 0;" % info)

1541 code.putln("%s->obj = Py_None; __Pyx_INCREF(Py_None);" % info)

1542 code.put_giveref("%s->obj" % info) # Do not refnanny object within structs

1543

1544 def getbuffer_error_cleanup(self, code):

1545 info = self.local_scope.arg_entries[1].cname

1546 code.put_gotref("%s->obj" % info)

1547 code.putln("__Pyx_DECREF(%s->obj); %s->obj = NULL;" %

1548 (info, info))

1549

1550 def getbuffer_normal_cleanup(self, code):

1551 info = self.local_scope.arg_entries[1].cname

1552 code.putln("if (%s->obj == Py_None) {" % info)

1553 code.put_gotref("Py_None")

1554 code.putln("__Pyx_DECREF(Py_None); %s->obj = NULL;" % info)

1555 code.putln("}")

1556

1557 class CFuncDefNode(FuncDefNode):

1558 # C function definition.

1559 #

1560 # modifiers ['inline']

1561 # visibility 'private' or 'public' or 'extern'

1562 # base_type CBaseTypeNode

1563 # declarator CDeclaratorNode

1564 # body StatListNode

1565 # api boolean

1566 # decorators [DecoratorNode] list of decorators

1567 #

1568 # with_gil boolean Acquire GIL around body

1569 # type CFuncType

1570 # py_func wrapper for calling from Python

1571 # overridable whether or not this is a cpdef function

1572 # inline_in_pxd whether this is an inline function in a pxd file

1573

1574 child_attrs = ["base_type", "declarator", "body", "py_func"]

1575

1576 inline_in_pxd = False

1577 decorators = None

1578 directive_locals = {}

1579

1580 def unqualified_name(self):

1581 return self.entry.name

1582

1583 def analyse_declarations(self, env):

1584 self.directive_locals.update(env.directives['locals'])

1585 base_type = self.base_type.analyse(env)

1586 # The 2 here is because we need both function and argument names.

1587 name_declarator, type = self.declarator.analyse(base_type, env, nonempty = 2 * (self.body is not None))

1588 if not type.is_cfunction:

1589 error(self.pos,

1590 "Suite attached to non-function declaration")

1591 # Remember the actual type according to the function header

1592 # written here, because the type in the symbol table entry

1593 # may be different if we're overriding a C method inherited

1594 # from the base type of an extension type.

1595 self.type = type

1596 type.is_overridable = self.overridable

1597 declarator = self.declarator

1598 while not hasattr(declarator, 'args'):

1599 declarator = declarator.base

1600 self.args = declarator.args

1601 for formal_arg, type_arg in zip(self.args, type.args):

1602 formal_arg.type = type_arg.type

1603 formal_arg.name = type_arg.name

1604 formal_arg.cname = type_arg.cname

1605 name = name_declarator.name

1606 cname = name_declarator.cname

1607 self.entry = env.declare_cfunction(

1608 name, type, self.pos,

1609 cname = cname, visibility = self.visibility,

1610 defining = self.body is not None,

1611 api = self.api, modifiers = self.modifiers)

1612 self.entry.inline_func_in_pxd = self.inline_in_pxd

1613 self.return_type = type.return_type

1614

1615 if self.overridable and not env.is_module_scope:

1616 if len(self.args) < 1 or not self.args[0].type.is_pyobject:

1617 # An error will be produced in the cdef function

1618 self.overridable = False

1619

1620 if self.overridable:

1621 import ExprNodes

1622 py_func_body = self.call_self_node(is_module_scope = env.is_module_scope)

1623 self.py_func = DefNode(pos = self.pos,

1624 name = self.entry.name,

1625 args = self.args,

1626 star_arg = None,

1627 starstar_arg = None,

1628 doc = self.doc,

1629 body = py_func_body,

1630 is_wrapper = 1)

1631 self.py_func.is_module_scope = env.is_module_scope

1632 self.py_func.analyse_declarations(env)

1633 self.entry.as_variable = self.py_func.entry

1634 # Reset scope entry the above cfunction

1635 env.entries[name] = self.entry

1636 if not env.is_module_scope or Options.lookup_module_cpdef:

1637 self.override = OverrideCheckNode(self.pos, py_func = self.py_func)

1638 self.body = StatListNode(self.pos, stats=[self.override, self.body])

1639 self.create_local_scope(env)

1640

1641 def call_self_node(self, omit_optional_args=0, is_module_scope=0):

1642 import ExprNodes

1643 args = self.type.args

1644 if omit_optional_args:

1645 args = args[:len(args) - self.type.optional_arg_count]

1646 arg_names = [arg.name for arg in args]

1647 if is_module_scope:

1648 cfunc = ExprNodes.NameNode(self.pos, name=self.entry.name)

1649 else:

1650 self_arg = ExprNodes.NameNode(self.pos, name=arg_names[0])

1651 cfunc = ExprNodes.AttributeNode(self.pos, obj=self_arg, attribute=self.entry.name)

1652 skip_dispatch = not is_module_scope or Options.lookup_module_cpdef

1653 c_call = ExprNodes.SimpleCallNode(self.pos, function=cfunc, args=[ExprNodes.NameNode(self.pos, name=n) for n in arg_names[1-is_module_scope:]], wrapper_call=skip_dispatch)

1654 return ReturnStatNode(pos=self.pos, return_type=PyrexTypes.py_object_type, value=c_call)

1655

1656 def declare_arguments(self, env):

1657 for arg in self.type.args:

1658 if not arg.name:

1659 error(arg.pos, "Missing argument name")

1660 self.declare_argument(env, arg)

1661

1662 def need_gil_acquisition(self, lenv):

1663 return self.type.with_gil

1664

1665 def nogil_check(self, env):

1666 type = self.type

1667 with_gil = type.with_gil

1668 if type.nogil and not with_gil:

1669 if type.return_type.is_pyobject:

1670 error(self.pos,

1671 "Function with Python return type cannot be declared nogil")

1672 for entry in self.local_scope.var_entries:

1673 if entry.type.is_pyobject:

1674 error(self.pos, "Function declared nogil has Python locals or temporaries")

1675

1676 def analyse_expressions(self, env):

1677 self.local_scope.directives = env.directives

1678 if self.py_func is not None:

1679 # this will also analyse the default values

1680 self.py_func.analyse_expressions(env)

1681 else:

1682 self.analyse_default_values(env)

1683 self.acquire_gil = self.need_gil_acquisition(self.local_scope)

1684

1685 def needs_assignment_synthesis(self, env, code=None):

1686 return False

1687

1688 def generate_function_header(self, code, with_pymethdef, with_opt_args = 1, with_dispatch = 1, cname = None):

1689 arg_decls = []

1690 type = self.type

1691 visibility = self.entry.visibility

1692 for arg in type.args[:len(type.args)-type.optional_arg_count]:

1693 arg_decls.append(arg.declaration_code())

1694 if with_dispatch and self.overridable:

1695 arg_decls.append(PyrexTypes.c_int_type.declaration_code(Naming.skip_dispatch_cname))

1696 if type.optional_arg_count and with_opt_args:

1697 arg_decls.append(type.op_arg_struct.declaration_code(Naming.optional_args_cname))

1698 if type.has_varargs:

1699 arg_decls.append("...")

1700 if not arg_decls:

1701 arg_decls = ["void"]

1702 if cname is None:

1703 cname = self.entry.func_cname

1704 entity = type.function_header_code(cname, ', '.join(arg_decls))

1705 if visibility == 'public':

1706 dll_linkage = "DL_EXPORT"

1707 else:

1708 dll_linkage = None

1709 header = self.return_type.declaration_code(entity,

1710 dll_linkage = dll_linkage)

1711 if visibility == 'extern':

1712 storage_class = "%s " % Naming.extern_c_macro

1713 elif visibility == 'public':

1714 storage_class = ""

1715 else:

1716 storage_class = "static "

1717 if 'inline' in self.modifiers:

1718 self.modifiers[self.modifiers.index('inline')] = 'cython_inline'

1719 code.putln("%s%s %s {" % (

1720 storage_class,

1721 ' '.join(self.modifiers).upper(), # macro forms

1722 header))

1723

1724 def generate_argument_declarations(self, env, code):

1725 for arg in self.args:

1726 if arg.default:

1727 result = arg.calculate_default_value_code(code)

1728 code.putln('%s = %s;' % (

1729 arg.type.declaration_code(arg.cname), result))

1730

1731 def generate_keyword_list(self, code):

1732 pass

1733

1734 def generate_argument_parsing_code(self, env, code):

1735 i = 0

1736 if self.type.optional_arg_count:

1737 code.putln('if (%s) {' % Naming.optional_args_cname)

1738 for arg in self.args:

1739 if arg.default:

1740 code.putln('if (%s->%sn > %s) {' % (Naming.optional_args_cname, Naming.pyrex_prefix, i))

1741 declarator = arg.declarator

1742 while not hasattr(declarator, 'name'):

1743 declarator = declarator.base

1744 code.putln('%s = %s->%s;' % (arg.cname, Naming.optional_args_cname, self.type.opt_arg_cname(declarator.name)))

1745 i += 1

1746 for _ in range(self.type.optional_arg_count):

1747 code.putln('}')

1748 code.putln('}')

1749

1750 def generate_argument_conversion_code(self, code):

1751 pass

1752

1753 def generate_argument_type_tests(self, code):

1754 # Generate type tests for args whose type in a parent

1755 # class is a supertype of the declared type.

1756 for arg in self.type.args:

1757 if arg.needs_type_test:

1758 self.generate_arg_type_test(arg, code)

1759 elif arg.type.is_pyobject and not arg.accept_none:

1760 self.generate_arg_none_check(arg, code)

1761

1762 def error_value(self):

1763 if self.return_type.is_pyobject:

1764 return "0"

1765 else:

1766 #return None

1767 return self.entry.type.exception_value

1768

1769 def caller_will_check_exceptions(self):

1770 return self.entry.type.exception_check

1771

1772 def generate_wrapper_functions(self, code):

1773 # If the C signature of a function has changed, we need to generate

1774 # wrappers to put in the slots here.

1775 k = 0

1776 entry = self.entry

1777 func_type = entry.type

1778 while entry.prev_entry is not None:

1779 k += 1

1780 entry = entry.prev_entry

1781 entry.func_cname = "%s%swrap_%s" % (self.entry.func_cname, Naming.pyrex_prefix, k)

1782 code.putln()

1783 self.generate_function_header(code,

1784 0,

1785 with_dispatch = entry.type.is_overridable,

1786 with_opt_args = entry.type.optional_arg_count,

1787 cname = entry.func_cname)

1788 if not self.return_type.is_void:

1789 code.put('return ')

1790 args = self.type.args

1791 arglist = [arg.cname for arg in args[:len(args)-self.type.optional_arg_count]]

1792 if entry.type.is_overridable:

1793 arglist.append(Naming.skip_dispatch_cname)

1794 elif func_type.is_overridable:

1795 arglist.append('0')

1796 if entry.type.optional_arg_count:

1797 arglist.append(Naming.optional_args_cname)

1798 elif func_type.optional_arg_count:

1799 arglist.append('NULL')

1800 code.putln('%s(%s);' % (self.entry.func_cname, ', '.join(arglist)))

1801 code.putln('}')

1802

1803

1804 class PyArgDeclNode(Node):

1805 # Argument which must be a Python object (used

1806 # for * and ** arguments).

1807 #

1808 # name string

1809 # entry Symtab.Entry

1810 # annotation ExprNode or None Py3 argument annotation

1811 child_attrs = []

1812

1813 def generate_function_definitions(self, env, code):

1814 self.entry.generate_function_definitions(env, code)

1815

1816 class DecoratorNode(Node):

1817 # A decorator

1818 #

1819 # decorator NameNode or CallNode or AttributeNode

1820 child_attrs = ['decorator']

1821

1822

1823 class DefNode(FuncDefNode):

1824 # A Python function definition.

1825 #

1826 # name string the Python name of the function

1827 # lambda_name string the internal name of a lambda 'function'

1828 # decorators [DecoratorNode] list of decorators

1829 # args [CArgDeclNode] formal arguments

1830 # star_arg PyArgDeclNode or None * argument

1831 # starstar_arg PyArgDeclNode or None ** argument

1832 # doc EncodedString or None

1833 # body StatListNode

1834 # return_type_annotation

1835 # ExprNode or None the Py3 return type annotation

1836 #

1837 # The following subnode is constructed internally

1838 # when the def statement is inside a Python class definition.

1839 #

1840 # assmt AssignmentNode Function construction/assignment

1841

1842 child_attrs = ["args", "star_arg", "starstar_arg", "body", "decorators"]

1843

1844 lambda_name = None

1845 assmt = None

1846 num_kwonly_args = 0

1847 num_required_kw_args = 0

1848 reqd_kw_flags_cname = "0"

1849 is_wrapper = 0

1850 decorators = None

1851 return_type_annotation = None

1852 entry = None

1853 acquire_gil = 0

1854 self_in_stararg = 0

1855

1856 def __init__(self, pos, **kwds):

1857 FuncDefNode.__init__(self, pos, **kwds)

1858 k = rk = r = 0

1859 for arg in self.args:

1860 if arg.kw_only:

1861 k += 1

1862 if not arg.default:

1863 rk += 1

1864 if not arg.default:

1865 r += 1

1866 self.num_kwonly_args = k

1867 self.num_required_kw_args = rk

1868 self.num_required_args = r

1869

1870 def as_cfunction(self, cfunc=None, scope=None):

1871 if self.star_arg:

1872 error(self.star_arg.pos, "cdef function cannot have star argument")

1873 if self.starstar_arg:

1874 error(self.starstar_arg.pos, "cdef function cannot have starstar argument")

1875 if cfunc is None:

1876 cfunc_args = []

1877 for formal_arg in self.args:

1878 name_declarator, type = formal_arg.analyse(scope, nonempty=1)

1879 cfunc_args.append(PyrexTypes.CFuncTypeArg(name = name_declarator.name,

1880 cname = None,

1881 type = py_object_type,

1882 pos = formal_arg.pos))

1883 cfunc_type = PyrexTypes.CFuncType(return_type = py_object_type,

1884 args = cfunc_args,

1885 has_varargs = False,

1886 exception_value = None,

1887 exception_check = False,

1888 nogil = False,

1889 with_gil = False,

1890 is_overridable = True)

1891 cfunc = CVarDefNode(self.pos, type=cfunc_type)

1892 else:

1893 cfunc_type = cfunc.type

1894 if len(self.args) != len(cfunc_type.args) or cfunc_type.has_varargs:

1895 error(self.pos, "wrong number of arguments")

1896 error(cfunc.pos, "previous declaration here")

1897 for formal_arg, type_arg in zip(self.args, cfunc_type.args):

1898 name_declarator, type = formal_arg.analyse(cfunc.scope, nonempty=1)

1899 if type is None or type is PyrexTypes.py_object_type or formal_arg.is_self:

1900 formal_arg.type = type_arg.type

1901 formal_arg.name_declarator = name_declarator

1902 import ExprNodes

1903 if cfunc_type.exception_value is None:

1904 exception_value = None

1905 else:

1906 exception_value = ExprNodes.ConstNode(self.pos, value=cfunc_type.exception_value, type=cfunc_type.return_type)

1907 declarator = CFuncDeclaratorNode(self.pos,

1908 base = CNameDeclaratorNode(self.pos, name=self.name, cname=None),

1909 args = self.args,

1910 has_varargs = False,

1911 exception_check = cfunc_type.exception_check,

1912 exception_value = exception_value,

1913 with_gil = cfunc_type.with_gil,

1914 nogil = cfunc_type.nogil)

1915 return CFuncDefNode(self.pos,

1916 modifiers = [],

1917 base_type = CAnalysedBaseTypeNode(self.pos, type=cfunc_type.return_type),

1918 declarator = declarator,

1919 body = self.body,

1920 doc = self.doc,

1921 overridable = cfunc_type.is_overridable,

1922 type = cfunc_type,

1923 with_gil = cfunc_type.with_gil,

1924 nogil = cfunc_type.nogil,

1925 visibility = 'private',

1926 api = False,

1927 directive_locals = getattr(cfunc, 'directive_locals', {}))

1928

1929 def analyse_declarations(self, env):

1930 self.is_classmethod = self.is_staticmethod = False

1931 if self.decorators:

1932 for decorator in self.decorators:

1933 func = decorator.decorator

1934 if func.is_name:

1935 self.is_classmethod |= func.name == 'classmethod'

1936 self.is_staticmethod |= func.name == 'staticmethod'

1937

1938 if self.is_classmethod and env.lookup_here('classmethod'):

1939 # classmethod() was overridden - not much we can do here ...

1940 self.is_classmethod = False

1941 if self.is_staticmethod and env.lookup_here('staticmethod'):

1942 # staticmethod() was overridden - not much we can do here ...

1943 self.is_staticmethod = False

1944

1945 self.analyse_argument_types(env)

1946 if self.name == '<lambda>':

1947 self.declare_lambda_function(env)

1948 else:

1949 self.declare_pyfunction(env)

1950 self.analyse_signature(env)

1951 self.return_type = self.entry.signature.return_type()

1952 self.create_local_scope(env)

1953

1954 def analyse_argument_types(self, env):

1955 directive_locals = self.directive_locals = env.directives['locals']

1956 allow_none_for_extension_args = env.directives['allow_none_for_extension_args']

1957 for arg in self.args:

1958 if hasattr(arg, 'name'):

1959 type = arg.type

1960 name_declarator = None

1961 else:

1962 base_type = arg.base_type.analyse(env)

1963 name_declarator, type = \

1964 arg.declarator.analyse(base_type, env)

1965 arg.name = name_declarator.name

1966 if arg.name in directive_locals:

1967 type_node = directive_locals[arg.name]

1968 other_type = type_node.analyse_as_type(env)

1969 if other_type is None:

1970 error(type_node.pos, "Not a type")

1971 elif (type is not PyrexTypes.py_object_type

1972 and not type.same_as(other_type)):

1973 error(arg.base_type.pos, "Signature does not agree with previous declaration")

1974 error(type_node.pos, "Previous declaration here")

1975 else:

1976 type = other_type

1977 if name_declarator and name_declarator.cname:

1978 error(self.pos,

1979 "Python function argument cannot have C name specification")

1980 arg.type = type.as_argument_type()

1981 arg.hdr_type = None

1982 arg.needs_conversion = 0

1983 arg.needs_type_test = 0

1984 arg.is_generic = 1

1985 if arg.type.is_pyobject:

1986 if arg.or_none:

1987 arg.accept_none = True

1988 elif arg.not_none:

1989 arg.accept_none = False

1990 elif arg.type.is_extension_type or arg.type.is_builtin_type:

1991 if arg.default and arg.default.constant_result is None:

1992 # special case: def func(MyType obj = None)

1993 arg.accept_none = True

1994 else:

1995 # default depends on compiler directive

1996 arg.accept_none = allow_none_for_extension_args

1997 else:

1998 # probably just a plain 'object'

1999 arg.accept_none = True

2000 else:

2001 arg.accept_none = True # won't be used, but must be there

2002 if arg.not_none:

2003 error(arg.pos, "Only Python type arguments can have 'not None'")

2004 if arg.or_none:

2005 error(arg.pos, "Only Python type arguments can have 'or None'")

2006

2007 def analyse_signature(self, env):

2008 if self.entry.is_special:

2009 self.entry.trivial_signature = len(self.args) == 1 and not (self.star_arg or self.starstar_arg)

2010 elif not env.directives['always_allow_keywords'] and not (self.star_arg or self.starstar_arg):

2011 # Use the simpler calling signature for zero- and one-argument functions.

2012 if self.entry.signature is TypeSlots.pyfunction_signature:

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

2014 self.entry.signature = TypeSlots.pyfunction_noargs

2015 elif len(self.args) == 1:

2016 if self.args[0].default is None and not self.args[0].kw_only:

2017 self.entry.signature = TypeSlots.pyfunction_onearg

2018 elif self.entry.signature is TypeSlots.pymethod_signature:

2019 if len(self.args) == 1:

2020 self.entry.signature = TypeSlots.unaryfunc

2021 elif len(self.args) == 2:

2022 if self.args[1].default is None and not self.args[1].kw_only:

2023 self.entry.signature = TypeSlots.ibinaryfunc

2024

2025 sig = self.entry.signature

2026 nfixed = sig.num_fixed_args()

2027 if sig is TypeSlots.pymethod_signature and nfixed == 1 \

2028 and len(self.args) == 0 and self.star_arg:

2029 # this is the only case where a diverging number of

2030 # arguments is not an error - when we have no explicit

2031 # 'self' parameter as in method(*args)

2032 sig = self.entry.signature = TypeSlots.pyfunction_signature # self is not 'really' used

2033 self.self_in_stararg = 1

2034 nfixed = 0

2035

2036 for i in range(min(nfixed, len(self.args))):

2037 arg = self.args[i]

2038 arg.is_generic = 0

2039 if sig.is_self_arg(i) and not self.is_staticmethod:

2040 if self.is_classmethod:

2041 arg.is_type_arg = 1

2042 arg.hdr_type = arg.type = Builtin.type_type

2043 else:

2044 arg.is_self_arg = 1

2045 arg.hdr_type = arg.type = env.parent_type

2046 arg.needs_conversion = 0

2047 else:

2048 arg.hdr_type = sig.fixed_arg_type(i)

2049 if not arg.type.same_as(arg.hdr_type):

2050 if arg.hdr_type.is_pyobject and arg.type.is_pyobject:

2051 arg.needs_type_test = 1

2052 else:

2053 arg.needs_conversion = 1

2054 if arg.needs_conversion:

2055 arg.hdr_cname = Naming.arg_prefix + arg.name

2056 else:

2057 arg.hdr_cname = Naming.var_prefix + arg.name

2058

2059 if nfixed > len(self.args):

2060 self.bad_signature()

2061 return

2062 elif nfixed < len(self.args):

2063 if not sig.has_generic_args:

2064 self.bad_signature()

2065 for arg in self.args:

2066 if arg.is_generic and \

2067 (arg.type.is_extension_type or arg.type.is_builtin_type):

2068 arg.needs_type_test = 1

2069

2070 def bad_signature(self):

2071 sig = self.entry.signature

2072 expected_str = "%d" % sig.num_fixed_args()

2073 if sig.has_generic_args:

2074 expected_str = expected_str + " or more"

2075 name = self.name

2076 if name.startswith("__") and name.endswith("__"):

2077 desc = "Special method"

2078 else:

2079 desc = "Method"

2080 error(self.pos,

2081 "%s %s has wrong number of arguments "

2082 "(%d declared, %s expected)" % (

2083 desc, self.name, len(self.args), expected_str))

2084

2085 def signature_has_nongeneric_args(self):

2086 argcount = len(self.args)

2087 if argcount == 0 or (

2088 argcount == 1 and (self.args[0].is_self_arg or

2089 self.args[0].is_type_arg)):

2090 return 0

2091 return 1

2092

2093 def signature_has_generic_args(self):

2094 return self.entry.signature.has_generic_args

2095

2096 def declare_pyfunction(self, env):

2097 #print "DefNode.declare_pyfunction:", self.name, "in", env ###

2098 name = self.name

2099 entry = env.lookup_here(name)

2100 if entry and entry.type.is_cfunction and not self.is_wrapper:

2101 warning(self.pos, "Overriding cdef method with def method.", 5)

2102 entry = env.declare_pyfunction(name, self.pos)

2103 self.entry = entry

2104 prefix = env.scope_prefix

2105 entry.func_cname = \

2106 Naming.pyfunc_prefix + prefix + name

2107 entry.pymethdef_cname = \

2108 Naming.pymethdef_prefix + prefix + name

2109 if Options.docstrings:

2110 entry.doc = embed_position(self.pos, self.doc)

2111 entry.doc_cname = \

2112 Naming.funcdoc_prefix + prefix + name

2113 if entry.is_special:

2114 entry.wrapperbase_cname = Naming.wrapperbase_prefix + prefix + name

2115 else:

2116 entry.doc = None

2117

2118 def declare_lambda_function(self, env):

2119 name = self.name

2120 prefix = env.scope_prefix

2121 func_cname = \

2122 Naming.lambda_func_prefix + u'funcdef' + prefix + self.lambda_name

2123 entry = env.declare_lambda_function(func_cname, self.pos)

2124 entry.pymethdef_cname = \

2125 Naming.lambda_func_prefix + u'methdef' + prefix + self.lambda_name

2126 entry.qualified_name = env.qualify_name(self.lambda_name)

2127 entry.doc = None

2128 self.entry = entry

2129

2130 def declare_arguments(self, env):

2131 for arg in self.args:

2132 if not arg.name:

2133 error(arg.pos, "Missing argument name")

2134 else:

2135 env.control_flow.set_state((), (arg.name, 'source'), 'arg')

2136 env.control_flow.set_state((), (arg.name, 'initialized'), True)

2137 if arg.needs_conversion:

2138 arg.entry = env.declare_var(arg.name, arg.type, arg.pos)

2139 if arg.type.is_pyobject:

2140 arg.entry.init = "0"

2141 arg.entry.init_to_none = 0

2142 else:

2143 arg.entry = self.declare_argument(env, arg)

2144 arg.entry.used = 1

2145 arg.entry.is_self_arg = arg.is_self_arg

2146 if arg.hdr_type:

2147 if arg.is_self_arg or arg.is_type_arg or \

2148 (arg.type.is_extension_type and not arg.hdr_type.is_extension_type):

2149 arg.entry.is_declared_generic = 1

2150 self.declare_python_arg(env, self.star_arg)

2151 self.declare_python_arg(env, self.starstar_arg)

2152

2153 def declare_python_arg(self, env, arg):

2154 if arg:

2155 if env.directives['infer_types'] != False:

2156 type = PyrexTypes.unspecified_type

2157 else:

2158 type = py_object_type

2159 entry = env.declare_var(arg.name, type, arg.pos)

2160 entry.used = 1

2161 entry.init = "0"

2162 entry.init_to_none = 0

2163 entry.xdecref_cleanup = 1

2164 arg.entry = entry

2165 env.control_flow.set_state((), (arg.name, 'initialized'), True)

2166

2167 def analyse_expressions(self, env):

2168 self.local_scope.directives = env.directives

2169 self.analyse_default_values(env)

2170 if self.needs_assignment_synthesis(env):

2171 # Shouldn't we be doing this at the module level too?

2172 self.synthesize_assignment_node(env)

2173

2174 def needs_assignment_synthesis(self, env, code=None):

2175 # Should enable for module level as well, that will require more testing...

2176 if env.is_module_scope:

2177 if code is None:

2178 return env.directives['binding']

2179 else:

2180 return code.globalstate.directives['binding']

2181 return env.is_py_class_scope or env.is_closure_scope

2182

2183 def synthesize_assignment_node(self, env):

2184 import ExprNodes

2185 if env.is_py_class_scope:

2186 rhs = ExprNodes.UnboundMethodNode(self.pos,

2187 function = ExprNodes.PyCFunctionNode(self.pos,

2188 pymethdef_cname = self.entry.pymethdef_cname))

2189 elif env.is_closure_scope:

2190 rhs = ExprNodes.InnerFunctionNode(

2191 self.pos, pymethdef_cname = self.entry.pymethdef_cname)

2192 else:

2193 rhs = ExprNodes.PyCFunctionNode(

2194 self.pos, pymethdef_cname = self.entry.pymethdef_cname, binding = env.directives['binding'])

2195 self.assmt = SingleAssignmentNode(self.pos,

2196 lhs = ExprNodes.NameNode(self.pos, name = self.name),

2197 rhs = rhs)

2198 self.assmt.analyse_declarations(env)

2199 self.assmt.analyse_expressions(env)

2200

2201 def generate_function_header(self, code, with_pymethdef, proto_only=0):

2202 arg_code_list = []

2203 sig = self.entry.signature

2204 if sig.has_dummy_arg or self.self_in_stararg:

2205 arg_code_list.append(

2206 "PyObject *%s" % Naming.self_cname)

2207 for arg in self.args:

2208 if not arg.is_generic:

2209 if arg.is_self_arg or arg.is_type_arg:

2210 arg_code_list.append("PyObject *%s" % arg.hdr_cname)

2211 else:

2212 arg_code_list.append(

2213 arg.hdr_type.declaration_code(arg.hdr_cname))

2214 if not self.entry.is_special and sig.method_flags() == [TypeSlots.method_noargs]:

2215 arg_code_list.append("CYTHON_UNUSED PyObject *unused")

2216 if sig.has_generic_args:

2217 arg_code_list.append(

2218 "PyObject *%s, PyObject *%s"

2219 % (Naming.args_cname, Naming.kwds_cname))

2220 arg_code = ", ".join(arg_code_list)

2221 dc = self.return_type.declaration_code(self.entry.func_cname)

2222 mf = " ".join(self.modifiers).upper()

2223 if mf: mf += " "

2224 header = "static %s%s(%s)" % (mf, dc, arg_code)

2225 code.putln("%s; /*proto*/" % header)

2226 if proto_only:

2227 return

2228 if (Options.docstrings and self.entry.doc and

2229 not self.entry.scope.is_property_scope):

2230 docstr = self.entry.doc

2231 if docstr.is_unicode:

2232 docstr = docstr.utf8encode()

2233 code.putln(

2234 'static char %s[] = "%s";' % (

2235 self.entry.doc_cname,

2236 split_string_literal(escape_byte_string(docstr))))

2237 if self.entry.is_special:

2238 code.putln(

2239 "struct wrapperbase %s;" % self.entry.wrapperbase_cname)

2240 if with_pymethdef:

2241 code.put(

2242 "static PyMethodDef %s = " %

2243 self.entry.pymethdef_cname)

2244 code.put_pymethoddef(self.entry, ";", allow_skip=False)

2245 code.putln("%s {" % header)

2246

2247 def generate_argument_declarations(self, env, code):

2248 for arg in self.args:

2249 if arg.is_generic: # or arg.needs_conversion:

2250 if arg.needs_conversion:

2251 code.putln("PyObject *%s = 0;" % arg.hdr_cname)

2252 elif not arg.entry.in_closure:

2253 code.put_var_declaration(arg.entry)

2254

2255 def generate_keyword_list(self, code):

2256 if self.signature_has_generic_args() and \

2257 self.signature_has_nongeneric_args():

2258 code.put(

2259 "static PyObject **%s[] = {" %

2260 Naming.pykwdlist_cname)

2261 for arg in self.args:

2262 if arg.is_generic:

2263 pystring_cname = code.intern_identifier(arg.name)

2264 code.put('&%s,' % pystring_cname)

2265 code.putln("0};")

2266

2267 def generate_argument_parsing_code(self, env, code):

2268 # Generate PyArg_ParseTuple call for generic

2269 # arguments, if any.

2270 if self.entry.signature.has_dummy_arg and not self.self_in_stararg:

2271 # get rid of unused argument warning

2272 code.putln("%s = %s;" % (Naming.self_cname, Naming.self_cname))

2273

2274 old_error_label = code.new_error_label()

2275 our_error_label = code.error_label

2276 end_label = code.new_label("argument_unpacking_done")

2277

2278 has_kwonly_args = self.num_kwonly_args > 0

2279 has_star_or_kw_args = self.star_arg is not None \

2280 or self.starstar_arg is not None or has_kwonly_args

2281

2282 for arg in self.args:

2283 if not arg.type.is_pyobject:

2284 done = arg.type.create_from_py_utility_code(env)

2285 if not done: pass # will fail later

2286

2287 if not self.signature_has_generic_args():

2288 if has_star_or_kw_args:

2289 error(self.pos, "This method cannot have * or keyword arguments")

2290 self.generate_argument_conversion_code(code)

2291

2292 elif not self.signature_has_nongeneric_args():

2293 # func(*args) or func(**kw) or func(*args, **kw)

2294 self.generate_stararg_copy_code(code)

2295

2296 else:

2297 positional_args = []

2298 kw_only_args = []

2299 for arg in self.args:

2300 arg_entry = arg.entry

2301 if arg.is_generic:

2302 if arg.default:

2303 if not arg.is_self_arg and not arg.is_type_arg:

2304 if arg.kw_only:

2305 kw_only_args.append(arg)

2306 else:

2307 positional_args.append(arg)

2308 elif arg.kw_only:

2309 kw_only_args.append(arg)

2310 elif not arg.is_self_arg and not arg.is_type_arg:

2311 positional_args.append(arg)

2312

2313 self.generate_tuple_and_keyword_parsing_code(

2314 positional_args, kw_only_args, end_label, code)

2315

2316 code.error_label = old_error_label

2317 if code.label_used(our_error_label):

2318 if not code.label_used(end_label):

2319 code.put_goto(end_label)

2320 code.put_label(our_error_label)

2321 if has_star_or_kw_args:

2322 self.generate_arg_decref(self.star_arg, code)

2323 if self.starstar_arg:

2324 if self.starstar_arg.entry.xdecref_cleanup:

2325 code.put_var_xdecref(self.starstar_arg.entry)

2326 else:

2327 code.put_var_decref(self.starstar_arg.entry)

2328 code.putln('__Pyx_AddTraceback("%s");' % self.entry.qualified_name)

2329 # The arguments are put into the closure one after the

2330 # other, so when type errors are found, all references in

2331 # the closure instance must be properly ref-counted to

2332 # facilitate generic closure instance deallocation. In

2333 # the case of an argument type error, it's best to just

2334 # DECREF+clear the already handled references, as this

2335 # frees their references as early as possible.

2336 for arg in self.args:

2337 if arg.type.is_pyobject and arg.entry.in_closure:

2338 code.put_var_xdecref_clear(arg.entry)

2339 if self.needs_closure:

2340 code.put_decref(Naming.cur_scope_cname, self.local_scope.scope_class.type)

2341 code.put_finish_refcount_context()

2342 code.putln("return %s;" % self.error_value())

2343 if code.label_used(end_label):

2344 code.put_label(end_label)

2345

2346 def generate_arg_assignment(self, arg, item, code):

2347 if arg.type.is_pyobject:

2348 if arg.is_generic:

2349 item = PyrexTypes.typecast(arg.type, PyrexTypes.py_object_type, item)

2350 entry = arg.entry

2351 code.putln("%s = %s;" % (entry.cname, item))

2352 if entry.in_closure:

2353 code.put_var_incref(entry)

2354 else:

2355 func = arg.type.from_py_function

2356 if func:

2357 code.putln("%s = %s(%s); %s" % (

2358 arg.entry.cname,

2359 func,

2360 item,

2361 code.error_goto_if(arg.type.error_condition(arg.entry.cname), arg.pos)))

2362 else:

2363 error(arg.pos, "Cannot convert Python object argument to type '%s'" % arg.type)

2364

2365 def generate_arg_xdecref(self, arg, code):

2366 if arg:

2367 code.put_var_xdecref(arg.entry)

2368

2369 def generate_arg_decref(self, arg, code):

2370 if arg:

2371 code.put_var_decref(arg.entry)

2372

2373 def generate_stararg_copy_code(self, code):

2374 if not self.star_arg:

2375 code.globalstate.use_utility_code(raise_argtuple_invalid_utility_code)

2376 code.putln("if (unlikely(PyTuple_GET_SIZE(%s) > 0)) {" %

2377 Naming.args_cname)

2378 code.put('__Pyx_RaiseArgtupleInvalid("%s", 1, 0, 0, PyTuple_GET_SIZE(%s)); return %s;' % (

2379 self.name, Naming.args_cname, self.error_value()))

2380 code.putln("}")

2381

2382 code.globalstate.use_utility_code(keyword_string_check_utility_code)

2383

2384 if self.starstar_arg:

2385 if self.star_arg:

2386 kwarg_check = "unlikely(%s)" % Naming.kwds_cname

2387 else:

2388 kwarg_check = "%s" % Naming.kwds_cname

2389 else:

2390 kwarg_check = "unlikely(%s) && unlikely(PyDict_Size(%s) > 0)" % (

2391 Naming.kwds_cname, Naming.kwds_cname)

2392 code.putln(

2393 "if (%s && unlikely(!__Pyx_CheckKeywordStrings(%s, \"%s\", %d))) return %s;" % (

2394 kwarg_check, Naming.kwds_cname, self.name,

2395 bool(self.starstar_arg), self.error_value()))

2396

2397 if self.starstar_arg:

2398 code.putln("%s = (%s) ? PyDict_Copy(%s) : PyDict_New();" % (

2399 self.starstar_arg.entry.cname,

2400 Naming.kwds_cname,

2401 Naming.kwds_cname))

2402 code.putln("if (unlikely(!%s)) return %s;" % (

2403 self.starstar_arg.entry.cname, self.error_value()))

2404 self.starstar_arg.entry.xdecref_cleanup = 0

2405 code.put_gotref(self.starstar_arg.entry.cname)

2406

2407 if self.self_in_stararg:

2408 # need to create a new tuple with 'self' inserted as first item

2409 code.put("%s = PyTuple_New(PyTuple_GET_SIZE(%s)+1); if (unlikely(!%s)) " % (

2410 self.star_arg.entry.cname,

2411 Naming.args_cname,

2412 self.star_arg.entry.cname))

2413 if self.starstar_arg:

2414 code.putln("{")

2415 code.put_decref_clear(self.starstar_arg.entry.cname, py_object_type)

2416 code.putln("return %s;" % self.error_value())

2417 code.putln("}")

2418 else:

2419 code.putln("return %s;" % self.error_value())

2420 code.put_gotref(self.star_arg.entry.cname)

2421 code.put_incref(Naming.self_cname, py_object_type)

2422 code.put_giveref(Naming.self_cname)

2423 code.putln("PyTuple_SET_ITEM(%s, 0, %s);" % (

2424 self.star_arg.entry.cname, Naming.self_cname))

2425 temp = code.funcstate.allocate_temp(PyrexTypes.c_py_ssize_t_type, manage_ref=False)

2426 code.putln("for (%s=0; %s < PyTuple_GET_SIZE(%s); %s++) {" % (

2427 temp, temp, Naming.args_cname, temp))

2428 code.putln("PyObject* item = PyTuple_GET_ITEM(%s, %s);" % (

2429 Naming.args_cname, temp))

2430 code.put_incref("item", py_object_type)

2431 code.put_giveref("item")

2432 code.putln("PyTuple_SET_ITEM(%s, %s+1, item);" % (

2433 self.star_arg.entry.cname, temp))

2434 code.putln("}")

2435 code.funcstate.release_temp(temp)

2436 self.star_arg.entry.xdecref_cleanup = 0

2437 elif self.star_arg:

2438 code.put_incref(Naming.args_cname, py_object_type)

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

2440 self.star_arg.entry.cname,

2441 Naming.args_cname))

2442 self.star_arg.entry.xdecref_cleanup = 0

2443

2444 def generate_tuple_and_keyword_parsing_code(self, positional_args,

2445 kw_only_args, success_label, code):

2446 argtuple_error_label = code.new_label("argtuple_error")

2447

2448 min_positional_args = self.num_required_args - self.num_required_kw_args

2449 if len(self.args) > 0 and (self.args[0].is_self_arg or self.args[0].is_type_arg):

2450 min_positional_args -= 1

2451 max_positional_args = len(positional_args)

2452 has_fixed_positional_count = not self.star_arg and \

2453 min_positional_args == max_positional_args

2454

2455 code.globalstate.use_utility_code(raise_double_keywords_utility_code)

2456 code.globalstate.use_utility_code(raise_argtuple_invalid_utility_code)

2457 if self.num_required_kw_args:

2458 code.globalstate.use_utility_code(raise_keyword_required_utility_code)

2459

2460 if self.starstar_arg or self.star_arg:

2461 self.generate_stararg_init_code(max_positional_args, code)

2462

2463 # --- optimised code when we receive keyword arguments

2464 if self.num_required_kw_args:

2465 likely_hint = "likely"

2466 else:

2467 likely_hint = "unlikely"

2468 code.putln("if (%s(%s)) {" % (likely_hint, Naming.kwds_cname))

2469 self.generate_keyword_unpacking_code(

2470 min_positional_args, max_positional_args,

2471 has_fixed_positional_count,

2472 positional_args, kw_only_args, argtuple_error_label, code)

2473

2474 # --- optimised code when we do not receive any keyword arguments

2475 if (self.num_required_kw_args and min_positional_args > 0) or min_positional_args == max_positional_args:

2476 # Python raises arg tuple related errors first, so we must

2477 # check the length here

2478 if min_positional_args == max_positional_args and not self.star_arg:

2479 compare = '!='

2480 else:

2481 compare = '<'

2482 code.putln('} else if (PyTuple_GET_SIZE(%s) %s %d) {' % (

2483 Naming.args_cname, compare, min_positional_args))

2484 code.put_goto(argtuple_error_label)

2485

2486 if self.num_required_kw_args:

2487 # pure error case: keywords required but not passed

2488 if max_positional_args > min_positional_args and not self.star_arg:

2489 code.putln('} else if (PyTuple_GET_SIZE(%s) > %d) {' % (

2490 Naming.args_cname, max_positional_args))

2491 code.put_goto(argtuple_error_label)

2492 code.putln('} else {')

2493 for i, arg in enumerate(kw_only_args):

2494 if not arg.default:

2495 pystring_cname = code.intern_identifier(arg.name)

2496 # required keyword-only argument missing

2497 code.put('__Pyx_RaiseKeywordRequired("%s", %s); ' % (

2498 self.name,

2499 pystring_cname))

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

2501 break

2502

2503 elif min_positional_args == max_positional_args:

2504 # parse the exact number of positional arguments from the

2505 # args tuple

2506 code.putln('} else {')

2507 for i, arg in enumerate(positional_args):

2508 item = "PyTuple_GET_ITEM(%s, %d)" % (Naming.args_cname, i)

2509 self.generate_arg_assignment(arg, item, code)

2510 self.generate_arg_default_assignments(code)

2511

2512 else:

2513 # parse the positional arguments from the variable length

2514 # args tuple

2515 code.putln('} else {')

2516 self.generate_arg_default_assignments(code)

2517 code.putln('switch (PyTuple_GET_SIZE(%s)) {' % Naming.args_cname)

2518 if self.star_arg:

2519 code.putln('default:')

2520 reversed_args = list(enumerate(positional_args))[::-1]

2521 for i, arg in reversed_args:

2522 if i >= min_positional_args-1:

2523 if min_positional_args > 1:

2524 code.putln('case %2d:' % (i+1)) # pure code beautification

2525 else:

2526 code.put('case %2d: ' % (i+1))

2527 item = "PyTuple_GET_ITEM(%s, %d)" % (Naming.args_cname, i)

2528 self.generate_arg_assignment(arg, item, code)

2529 if min_positional_args == 0:

2530 code.put('case 0: ')

2531 code.putln('break;')

2532 if self.star_arg:

2533 if min_positional_args:

2534 for i in range(min_positional_args-1, -1, -1):

2535 code.putln('case %2d:' % i)

2536 code.put_goto(argtuple_error_label)

2537 else:

2538 code.put('default: ')

2539 code.put_goto(argtuple_error_label)

2540 code.putln('}')

2541

2542 code.putln('}')

2543

2544 if code.label_used(argtuple_error_label):

2545 code.put_goto(success_label)

2546 code.put_label(argtuple_error_label)

2547 code.put('__Pyx_RaiseArgtupleInvalid("%s", %d, %d, %d, PyTuple_GET_SIZE(%s)); ' % (

2548 self.name, has_fixed_positional_count,

2549 min_positional_args, max_positional_args,

2550 Naming.args_cname))

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

2552

2553 def generate_arg_default_assignments(self, code):

2554 for arg in self.args:

2555 if arg.is_generic and arg.default:

2556 code.putln(

2557 "%s = %s;" % (

2558 arg.entry.cname,

2559 arg.calculate_default_value_code(code)))

2560

2561 def generate_stararg_init_code(self, max_positional_args, code):

2562 if self.starstar_arg:

2563 self.starstar_arg.entry.xdecref_cleanup = 0

2564 code.putln('%s = PyDict_New(); if (unlikely(!%s)) return %s;' % (

2565 self.starstar_arg.entry.cname,

2566 self.starstar_arg.entry.cname,

2567 self.error_value()))

2568 code.put_gotref(self.starstar_arg.entry.cname)

2569 if self.star_arg:

2570 self.star_arg.entry.xdecref_cleanup = 0

2571 code.putln('if (PyTuple_GET_SIZE(%s) > %d) {' % (

2572 Naming.args_cname,

2573 max_positional_args))

2574 code.put('%s = PyTuple_GetSlice(%s, %d, PyTuple_GET_SIZE(%s)); ' % (

2575 self.star_arg.entry.cname, Naming.args_cname,

2576 max_positional_args, Naming.args_cname))

2577 code.put_gotref(self.star_arg.entry.cname)

2578 if self.starstar_arg:

2579 code.putln("")

2580 code.putln("if (unlikely(!%s)) {" % self.star_arg.entry.cname)

2581 code.put_decref(self.starstar_arg.entry.cname, py_object_type)

2582 code.putln('return %s;' % self.error_value())

2583 code.putln('}')

2584 else:

2585 code.putln("if (unlikely(!%s)) return %s;" % (

2586 self.star_arg.entry.cname, self.error_value()))

2587 code.putln('} else {')

2588 code.put("%s = %s; " % (self.star_arg.entry.cname, Naming.empty_tuple))

2589 code.put_incref(Naming.empty_tuple, py_object_type)

2590 code.putln('}')

2591

2592 def generate_keyword_unpacking_code(self, min_positional_args, max_positional_args,

2593 has_fixed_positional_count, positional_args,

2594 kw_only_args, argtuple_error_label, code):

2595 all_args = tuple(positional_args) + tuple(kw_only_args)

2596 max_args = len(all_args)

2597

2598 code.putln("Py_ssize_t kw_args = PyDict_Size(%s);" %

2599 Naming.kwds_cname)

2600 # the 'values' array collects borrowed references to arguments

2601 # before doing any type coercion etc.

2602 code.putln("PyObject* values[%d] = {%s};" % (

2603 max_args, ','.join('0'*max_args)))

2604

2605 # assign borrowed Python default values to the values array,

2606 # so that they can be overwritten by received arguments below

2607 for i, arg in enumerate(all_args):

2608 if arg.default and arg.type.is_pyobject:

2609 default_value = arg.calculate_default_value_code(code)

2610 code.putln('values[%d] = %s;' % (i, arg.type.as_pyobject(default_value)))

2611

2612 # parse the args tuple and check that it's not too long

2613 code.putln('switch (PyTuple_GET_SIZE(%s)) {' % Naming.args_cname)

2614 if self.star_arg:

2615 code.putln('default:')

2616 for i in range(max_positional_args-1, -1, -1):

2617 code.put('case %2d: ' % (i+1))

2618 code.putln("values[%d] = PyTuple_GET_ITEM(%s, %d);" % (

2619 i, Naming.args_cname, i))

2620 code.putln('case 0: break;')

2621 if not self.star_arg:

2622 code.put('default: ') # more arguments than allowed

2623 code.put_goto(argtuple_error_label)

2624 code.putln('}')

2625

2626 # now fill up the positional/required arguments with values

2627 # from the kw dict

2628 if self.num_required_args or max_positional_args > 0:

2629 last_required_arg = -1

2630 for i, arg in enumerate(all_args):

2631 if not arg.default:

2632 last_required_arg = i

2633 if last_required_arg < max_positional_args:

2634 last_required_arg = max_positional_args-1

2635 num_required_args = self.num_required_args

2636 if max_positional_args > 0:

2637 code.putln('switch (PyTuple_GET_SIZE(%s)) {' % Naming.args_cname)

2638 for i, arg in enumerate(all_args[:last_required_arg+1]):

2639 if max_positional_args > 0 and i <= max_positional_args:

2640 if self.star_arg and i == max_positional_args:

2641 code.putln('default:')

2642 else:

2643 code.putln('case %2d:' % i)

2644 pystring_cname = code.intern_identifier(arg.name)

2645 if arg.default:

2646 if arg.kw_only:

2647 # handled separately below

2648 continue

2649 code.putln('if (kw_args > 0) {')

2650 code.putln('PyObject* value = PyDict_GetItem(%s, %s);' % (

2651 Naming.kwds_cname, pystring_cname))

2652 code.putln('if (value) { values[%d] = value; kw_args--; }' % i)

2653 code.putln('}')

2654 else:

2655 num_required_args -= 1

2656 code.putln('values[%d] = PyDict_GetItem(%s, %s);' % (

2657 i, Naming.kwds_cname, pystring_cname))

2658 code.putln('if (likely(values[%d])) kw_args--;' % i);

2659 if i < min_positional_args:

2660 if i == 0:

2661 # special case: we know arg 0 is missing

2662 code.put('else ')

2663 code.put_goto(argtuple_error_label)

2664 else:

2665 # print the correct number of values (args or

2666 # kwargs) that were passed into positional

2667 # arguments up to this point

2668 code.putln('else {')

2669 code.put('__Pyx_RaiseArgtupleInvalid("%s", %d, %d, %d, %d); ' % (

2670 self.name, has_fixed_positional_count,

2671 min_positional_args, max_positional_args, i))

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

2673 code.putln('}')

2674 elif arg.kw_only:

2675 code.putln('else {')

2676 code.put('__Pyx_RaiseKeywordRequired("%s", %s); ' %(

2677 self.name, pystring_cname))

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

2679 code.putln('}')

2680 if max_positional_args > 0:

2681 code.putln('}')

2682

2683 if kw_only_args and not self.starstar_arg:

2684 # unpack optional keyword-only arguments

2685 # checking for interned strings in a dict is faster than iterating

2686 # but it's too likely that we must iterate if we expect **kwargs

2687 optional_args = []

2688 for i, arg in enumerate(all_args[max_positional_args:]):

2689 if not arg.kw_only or not arg.default:

2690 continue

2691 optional_args.append((i+max_positional_args, arg))

2692 if optional_args:

2693 # this mimics an unrolled loop so that we can "break" out of it

2694 code.putln('while (kw_args > 0) {')

2695 code.putln('PyObject* value;')

2696 for i, arg in optional_args:

2697 pystring_cname = code.intern_identifier(arg.name)

2698 code.putln(

2699 'value = PyDict_GetItem(%s, %s);' % (

2700 Naming.kwds_cname, pystring_cname))

2701 code.putln(

2702 'if (value) { values[%d] = value; if (!(--kw_args)) break; }' % i)

2703 code.putln('break;')

2704 code.putln('}')

2705

2706 code.putln('if (unlikely(kw_args > 0)) {')

2707 # non-positional/-required kw args left in dict: default args,

2708 # kw-only args, **kwargs or error

2709 #

2710 # This is sort of a catch-all: except for checking required

2711 # arguments, this will always do the right thing for unpacking

2712 # keyword arguments, so that we can concentrate on optimising

2713 # common cases above.

2714 if max_positional_args == 0:

2715 pos_arg_count = "0"

2716 elif self.star_arg:

2717 code.putln("const Py_ssize_t used_pos_args = (PyTuple_GET_SIZE(%s) < %d) ? PyTuple_GET_SIZE(%s) : %d;" % (

2718 Naming.args_cname, max_positional_args,

2719 Naming.args_cname, max_positional_args))

2720 pos_arg_count = "used_pos_args"

2721 else:

2722 pos_arg_count = "PyTuple_GET_SIZE(%s)" % Naming.args_cname

2723 code.globalstate.use_utility_code(parse_keywords_utility_code)

2724 code.put(

2725 'if (unlikely(__Pyx_ParseOptionalKeywords(%s, %s, %s, values, %s, "%s") < 0)) ' % (

2726 Naming.kwds_cname,

2727 Naming.pykwdlist_cname,

2728 self.starstar_arg and self.starstar_arg.entry.cname or '0',

2729 pos_arg_count,

2730 self.name))

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

2732 code.putln('}')

2733

2734 # convert arg values to their final type and assign them

2735 for i, arg in enumerate(all_args):

2736 if arg.default and not arg.type.is_pyobject:

2737 code.putln("if (values[%d]) {" % i)

2738 self.generate_arg_assignment(arg, "values[%d]" % i, code)

2739 if arg.default and not arg.type.is_pyobject:

2740 code.putln('} else {')

2741 code.putln(

2742 "%s = %s;" % (

2743 arg.entry.cname,

2744 arg.calculate_default_value_code(code)))

2745 code.putln('}')

2746

2747 def generate_argument_conversion_code(self, code):

2748 # Generate code to convert arguments from signature type to

2749 # declared type, if needed. Also copies signature arguments

2750 # into closure fields.

2751 for arg in self.args:

2752 if arg.needs_conversion:

2753 self.generate_arg_conversion(arg, code)

2754 elif arg.entry.in_closure:

2755 code.putln('%s = %s;' % (arg.entry.cname, arg.hdr_cname))

2756 if arg.type.is_pyobject:

2757 code.put_var_incref(arg.entry)

2758

2759 def generate_arg_conversion(self, arg, code):

2760 # Generate conversion code for one argument.

2761 old_type = arg.hdr_type

2762 new_type = arg.type

2763 if old_type.is_pyobject:

2764 if arg.default:

2765 code.putln("if (%s) {" % arg.hdr_cname)

2766 else:

2767 code.putln("assert(%s); {" % arg.hdr_cname)

2768 self.generate_arg_conversion_from_pyobject(arg, code)

2769 code.putln("}")

2770 elif new_type.is_pyobject:

2771 self.generate_arg_conversion_to_pyobject(arg, code)

2772 else:

2773 if new_type.assignable_from(old_type):

2774 code.putln(

2775 "%s = %s;" % (arg.entry.cname, arg.hdr_cname))

2776 else:

2777 error(arg.pos,

2778 "Cannot convert 1 argument from '%s' to '%s'" %

2779 (old_type, new_type))

2780

2781 def generate_arg_conversion_from_pyobject(self, arg, code):

2782 new_type = arg.type

2783 func = new_type.from_py_function

2784 # copied from CoerceFromPyTypeNode

2785 if func:

2786 lhs = arg.entry.cname

2787 rhs = "%s(%s)" % (func, arg.hdr_cname)

2788 if new_type.is_enum:

2789 rhs = PyrexTypes.typecast(new_type, PyrexTypes.c_long_type, rhs)

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

2791 lhs,

2792 rhs,

2793 code.error_goto_if(new_type.error_condition(arg.entry.cname), arg.pos)))

2794 else:

2795 error(arg.pos,

2796 "Cannot convert Python object argument to type '%s'"

2797 % new_type)

2798

2799 def generate_arg_conversion_to_pyobject(self, arg, code):

2800 old_type = arg.hdr_type

2801 func = old_type.to_py_function

2802 if func:

2803 code.putln("%s = %s(%s); %s" % (

2804 arg.entry.cname,

2805 func,

2806 arg.hdr_cname,

2807 code.error_goto_if_null(arg.entry.cname, arg.pos)))

2808 code.put_var_gotref(arg.entry)

2809 else:

2810 error(arg.pos,

2811 "Cannot convert argument of type '%s' to Python object"

2812 % old_type)

2813

2814 def generate_argument_type_tests(self, code):

2815 # Generate type tests for args whose signature

2816 # type is PyObject * and whose declared type is

2817 # a subtype thereof.

2818 for arg in self.args:

2819 if arg.needs_type_test:

2820 self.generate_arg_type_test(arg, code)

2821 elif not arg.accept_none and arg.type.is_pyobject:

2822 self.generate_arg_none_check(arg, code)

2823

2824 def error_value(self):

2825 return self.entry.signature.error_value

2826

2827 def caller_will_check_exceptions(self):

2828 return 1

2829

2830 class OverrideCheckNode(StatNode):

2831 # A Node for dispatching to the def method if it

2832 # is overriden.

2833 #

2834 # py_func

2835 #

2836 # args

2837 # func_temp

2838 # body

2839

2840 child_attrs = ['body']

2841

2842 body = None

2843

2844 def analyse_expressions(self, env):

2845 self.args = env.arg_entries

2846 if self.py_func.is_module_scope:

2847 first_arg = 0

2848 else:

2849 first_arg = 1

2850 import ExprNodes

2851 self.func_node = ExprNodes.RawCNameExprNode(self.pos, py_object_type)

2852 call_tuple = ExprNodes.TupleNode(self.pos, args=[ExprNodes.NameNode(self.pos, name=arg.name) for arg in self.args[first_arg:]])

2853 call_node = ExprNodes.SimpleCallNode(self.pos,

2854 function=self.func_node,

2855 args=[ExprNodes.NameNode(self.pos, name=arg.name) for arg in self.args[first_arg:]])

2856 self.body = ReturnStatNode(self.pos, value=call_node)

2857 self.body.analyse_expressions(env)

2858

2859 def generate_execution_code(self, code):

2860 interned_attr_cname = code.intern_identifier(self.py_func.entry.name)

2861 # Check to see if we are an extension type

2862 if self.py_func.is_module_scope:

2863 self_arg = "((PyObject *)%s)" % Naming.module_cname

2864 else:

2865 self_arg = "((PyObject *)%s)" % self.args[0].cname

2866 code.putln("/* Check if called by wrapper */")

2867 code.putln("if (unlikely(%s)) ;" % Naming.skip_dispatch_cname)

2868 code.putln("/* Check if overriden in Python */")

2869 if self.py_func.is_module_scope:

2870 code.putln("else {")

2871 else:

2872 code.putln("else if (unlikely(Py_TYPE(%s)->tp_dictoffset != 0)) {" % self_arg)

2873 func_node_temp = code.funcstate.allocate_temp(py_object_type, manage_ref=True)

2874 self.func_node.set_cname(func_node_temp)

2875 # need to get attribute manually--scope would return cdef method

2876 err = code.error_goto_if_null(func_node_temp, self.pos)

2877 code.putln("%s = PyObject_GetAttr(%s, %s); %s" % (

2878 func_node_temp, self_arg, interned_attr_cname, err))

2879 code.put_gotref(func_node_temp)

2880 is_builtin_function_or_method = "PyCFunction_Check(%s)" % func_node_temp

2881 is_overridden = "(PyCFunction_GET_FUNCTION(%s) != (void *)&%s)" % (

2882 func_node_temp, self.py_func.entry.func_cname)

2883 code.putln("if (!%s || %s) {" % (is_builtin_function_or_method, is_overridden))

2884 self.body.generate_execution_code(code)

2885 code.putln("}")

2886 code.put_decref_clear(func_node_temp, PyrexTypes.py_object_type)

2887 code.funcstate.release_temp(func_node_temp)

2888 code.putln("}")

2889

2890 class ClassDefNode(StatNode, BlockNode):

2891 pass

2892

2893 class PyClassDefNode(ClassDefNode):

2894 # A Python class definition.

2895 #

2896 # name EncodedString Name of the class

2897 # doc string or None

2898 # body StatNode Attribute definition code

2899 # entry Symtab.Entry

2900 # scope PyClassScope

2901 # decorators [DecoratorNode] list of decorators or None

2902 #

2903 # The following subnodes are constructed internally:

2904 #

2905 # dict DictNode Class dictionary

2906 # classobj ClassNode Class object

2907 # target NameNode Variable to assign class object to

2908

2909 child_attrs = ["body", "dict", "classobj", "target"]

2910 decorators = None

2911

2912 def __init__(self, pos, name, bases, doc, body, decorators = None):

2913 StatNode.__init__(self, pos)

2914 self.name = name

2915 self.doc = doc

2916 self.body = body

2917 self.decorators = decorators

2918 import ExprNodes

2919 self.dict = ExprNodes.DictNode(pos, key_value_pairs = [])

2920 if self.doc and Options.docstrings:

2921 doc = embed_position(self.pos, self.doc)

2922 # FIXME: correct string node?

2923 doc_node = ExprNodes.StringNode(pos, value = doc)

2924 else:

2925 doc_node = None

2926 self.classobj = ExprNodes.ClassNode(pos, name = name,

2927 bases = bases, dict = self.dict, doc = doc_node)

2928 self.target = ExprNodes.NameNode(pos, name = name)

2929

2930 def as_cclass(self):

2931 """

2932 Return this node as if it were declared as an extension class

2933 """

2934 bases = self.classobj.bases.args

2935 if len(bases) == 0:

2936 base_class_name = None

2937 base_class_module = None

2938 elif len(bases) == 1:

2939 base = bases[0]

2940 path = []

2941 from ExprNodes import AttributeNode, NameNode

2942 while isinstance(base, AttributeNode):

2943 path.insert(0, base.attribute)

2944 base = base.obj

2945 if isinstance(base, NameNode):

2946 path.insert(0, base.name)

2947 base_class_name = path[-1]

2948 if len(path) > 1:

2949 base_class_module = u'.'.join(path[:-1])

2950 else:

2951 base_class_module = None

2952 else:

2953 error(self.classobj.bases.args.pos, "Invalid base class")

2954 else:

2955 error(self.classobj.bases.args.pos, "C class may only have one base class")

2956 return None

2957

2958 return CClassDefNode(self.pos,

2959 visibility = 'private',

2960 module_name = None,

2961 class_name = self.name,

2962 base_class_module = base_class_module,

2963 base_class_name = base_class_name,

2964 decorators = self.decorators,

2965 body = self.body,

2966 in_pxd = False,

2967 doc = self.doc)

2968

2969 def create_scope(self, env):

2970 genv = env

2971 while env.is_py_class_scope or env.is_c_class_scope:

2972 env = env.outer_scope

2973 cenv = self.scope = PyClassScope(name = self.name, outer_scope = genv)

2974 return cenv

2975

2976 def analyse_declarations(self, env):

2977 self.target.analyse_target_declaration(env)

2978 cenv = self.create_scope(env)

2979 cenv.directives = env.directives

2980 cenv.class_obj_cname = self.target.entry.cname

2981 self.body.analyse_declarations(cenv)

2982

2983 def analyse_expressions(self, env):

2984 self.dict.analyse_expressions(env)

2985 self.classobj.analyse_expressions(env)

2986 genv = env.global_scope()

2987 cenv = self.scope

2988 self.body.analyse_expressions(cenv)

2989 self.target.analyse_target_expression(env, self.classobj)

2990

2991 def generate_function_definitions(self, env, code):

2992 self.body.generate_function_definitions(self.scope, code)

2993

2994 def generate_execution_code(self, code):

2995 code.pyclass_stack.append(self)

2996 cenv = self.scope

2997 self.dict.generate_evaluation_code(code)

2998 self.classobj.generate_evaluation_code(code)

2999 cenv.namespace_cname = cenv.class_obj_cname = self.classobj.result()

3000 self.body.generate_execution_code(code)

3001 self.target.generate_assignment_code(self.classobj, code)

3002 self.dict.generate_disposal_code(code)

3003 self.dict.free_temps(code)

3004 code.pyclass_stack.pop()

3005

3006

3007 class CClassDefNode(ClassDefNode):

3008 # An extension type definition.

3009 #

3010 # visibility 'private' or 'public' or 'extern'

3011 # typedef_flag boolean

3012 # api boolean

3013 # module_name string or None For import of extern type objects

3014 # class_name string Unqualified name of class

3015 # as_name string or None Name to declare as in this scope

3016 # base_class_module string or None Module containing the base class

3017 # base_class_name string or None Name of the base class

3018 # objstruct_name string or None Specified C name of object struct

3019 # typeobj_name string or None Specified C name of type object

3020 # in_pxd boolean Is in a .pxd file

3021 # decorators [DecoratorNode] list of decorators or None

3022 # doc string or None

3023 # body StatNode or None

3024 # entry Symtab.Entry

3025 # base_type PyExtensionType or None

3026 # buffer_defaults_node DictNode or None Declares defaults for a buffer

3027 # buffer_defaults_pos

3028

3029 child_attrs = ["body"]

3030 buffer_defaults_node = None

3031 buffer_defaults_pos = None

3032 typedef_flag = False

3033 api = False

3034 objstruct_name = None

3035 typeobj_name = None

3036 decorators = None

3037

3038 def analyse_declarations(self, env):

3039 #print "CClassDefNode.analyse_declarations:", self.class_name

3040 #print "...visibility =", self.visibility

3041 #print "...module_name =", self.module_name

3042

3043 import Buffer

3044 if self.buffer_defaults_node:

3045 buffer_defaults = Buffer.analyse_buffer_options(self.buffer_defaults_pos,

3046 env, [], self.buffer_defaults_node,

3047 need_complete=False)

3048 else:

3049 buffer_defaults = None

3050

3051 if env.in_cinclude and not self.objstruct_name:

3052 error(self.pos, "Object struct name specification required for "

3053 "C class defined in 'extern from' block")

3054 self.base_type = None

3055 # Now that module imports are cached, we need to

3056 # import the modules for extern classes.

3057 if self.module_name:

3058 self.module = None

3059 for module in env.cimported_modules:

3060 if module.name == self.module_name:

3061 self.module = module

3062 if self.module is None:

3063 self.module = ModuleScope(self.module_name, None, env.context)

3064 self.module.has_extern_class = 1

3065 env.add_imported_module(self.module)

3066

3067 if self.base_class_name:

3068 if self.base_class_module:

3069 base_class_scope = env.find_module(self.base_class_module, self.pos)

3070 else:

3071 base_class_scope = env

3072 if self.base_class_name == 'object':

3073 # extension classes are special and don't need to inherit from object

3074 if base_class_scope is None or base_class_scope.lookup('object') is None:

3075 self.base_class_name = None

3076 self.base_class_module = None

3077 base_class_scope = None

3078 if base_class_scope:

3079 base_class_entry = base_class_scope.find(self.base_class_name, self.pos)

3080 if base_class_entry:

3081 if not base_class_entry.is_type:

3082 error(self.pos, "'%s' is not a type name" % self.base_class_name)

3083 elif not base_class_entry.type.is_extension_type:

3084 error(self.pos, "'%s' is not an extension type" % self.base_class_name)

3085 elif not base_class_entry.type.is_complete():

3086 error(self.pos, "Base class '%s' is incomplete" % self.base_class_name)

3087 else:

3088 self.base_type = base_class_entry.type

3089 has_body = self.body is not None

3090 if self.module_name and self.visibility != 'extern':

3091 module_path = self.module_name.split(".")

3092 home_scope = env.find_imported_module(module_path, self.pos)

3093 if not home_scope:

3094 return

3095 else:

3096 home_scope = env

3097

3098 if self.visibility == 'extern':

3099 if self.module_name == '__builtin__' and self.class_name in Builtin.builtin_types:

3100 warning(self.pos, "%s already a builtin Cython type" % self.class_name, 1)

3101

3102 self.entry = home_scope.declare_c_class(

3103 name = self.class_name,

3104 pos = self.pos,

3105 defining = has_body and self.in_pxd,

3106 implementing = has_body and not self.in_pxd,

3107 module_name = self.module_name,

3108 base_type = self.base_type,

3109 objstruct_cname = self.objstruct_name,

3110 typeobj_cname = self.typeobj_name,

3111 visibility = self.visibility,

3112 typedef_flag = self.typedef_flag,

3113 api = self.api,

3114 buffer_defaults = buffer_defaults)

3115 if home_scope is not env and self.visibility == 'extern':

3116 env.add_imported_entry(self.class_name, self.entry, pos)

3117 self.scope = scope = self.entry.type.scope

3118 if scope is not None:

3119 scope.directives = env.directives

3120

3121 if self.doc and Options.docstrings:

3122 scope.doc = embed_position(self.pos, self.doc)

3123

3124 if has_body:

3125 self.body.analyse_declarations(scope)

3126 if self.in_pxd:

3127 scope.defined = 1

3128 else:

3129 scope.implemented = 1

3130 env.allocate_vtable_names(self.entry)

3131

3132 def analyse_expressions(self, env):

3133 if self.body:

3134 scope = self.entry.type.scope

3135 self.body.analyse_expressions(scope)

3136

3137 def generate_function_definitions(self, env, code):

3138 if self.body:

3139 self.body.generate_function_definitions(

3140 self.entry.type.scope, code)

3141

3142 def generate_execution_code(self, code):

3143 # This is needed to generate evaluation code for

3144 # default values of method arguments.

3145 if self.body:

3146 self.body.generate_execution_code(code)

3147

3148 def annotate(self, code):

3149 if self.body:

3150 self.body.annotate(code)

3151

3152

3153 class PropertyNode(StatNode):

3154 # Definition of a property in an extension type.

3155 #

3156 # name string

3157 # doc EncodedString or None Doc string

3158 # body StatListNode

3159

3160 child_attrs = ["body"]

3161

3162 def analyse_declarations(self, env):

3163 entry = env.declare_property(self.name, self.doc, self.pos)

3164 if entry:

3165 entry.scope.directives = env.directives

3166 self.body.analyse_declarations(entry.scope)

3167

3168 def analyse_expressions(self, env):

3169 self.body.analyse_expressions(env)

3170

3171 def generate_function_definitions(self, env, code):

3172 self.body.generate_function_definitions(env, code)

3173

3174 def generate_execution_code(self, code):

3175 pass

3176

3177 def annotate(self, code):

3178 self.body.annotate(code)

3179

3180

3181 class GlobalNode(StatNode):

3182 # Global variable declaration.

3183 #

3184 # names [string]

3185

3186 child_attrs = []

3187

3188 def analyse_declarations(self, env):

3189 for name in self.names:

3190 env.declare_global(name, self.pos)

3191

3192 def analyse_expressions(self, env):

3193 pass

3194

3195 def generate_execution_code(self, code):

3196 pass

3197

3198

3199 class ExprStatNode(StatNode):

3200 # Expression used as a statement.

3201 #

3202 # expr ExprNode

3203

3204 child_attrs = ["expr"]

3205

3206 def analyse_declarations(self, env):

3207 import ExprNodes

3208 if isinstance(self.expr, ExprNodes.GeneralCallNode):

3209 func = self.expr.function.as_cython_attribute()

3210 if func == u'declare':

3211 args, kwds = self.expr.explicit_args_kwds()

3212 if len(args):

3213 error(self.expr.pos, "Variable names must be specified.")

3214 for var, type_node in kwds.key_value_pairs:

3215 type = type_node.analyse_as_type(env)

3216 if type is None:

3217 error(type_node.pos, "Unknown type")

3218 else:

3219 env.declare_var(var.value, type, var.pos, is_cdef = True)

3220 self.__class__ = PassStatNode

3221

3222 def analyse_expressions(self, env):

3223 self.expr.analyse_expressions(env)

3224

3225 def generate_execution_code(self, code):

3226 self.expr.generate_evaluation_code(code)

3227 if not self.expr.is_temp and self.expr.result():

3228 code.putln("%s;" % self.expr.result())

3229 self.expr.generate_disposal_code(code)

3230 self.expr.free_temps(code)

3231

3232 def generate_function_definitions(self, env, code):

3233 self.expr.generate_function_definitions(env, code)

3234

3235 def annotate(self, code):

3236 self.expr.annotate(code)

3237

3238

3239 class AssignmentNode(StatNode):

3240 # Abstract base class for assignment nodes.

3241 #

3242 # The analyse_expressions and generate_execution_code

3243 # phases of assignments are split into two sub-phases

3244 # each, to enable all the right hand sides of a

3245 # parallel assignment to be evaluated before assigning

3246 # to any of the left hand sides.

3247

3248 def analyse_expressions(self, env):

3249 self.analyse_types(env)

3250

3251 # def analyse_expressions(self, env):

3252 # self.analyse_expressions_1(env)

3253 # self.analyse_expressions_2(env)

3254

3255 def generate_execution_code(self, code):

3256 self.generate_rhs_evaluation_code(code)

3257 self.generate_assignment_code(code)

3258

3259

3260 class SingleAssignmentNode(AssignmentNode):

3261 # The simplest case:

3262 #

3263 # a = b

3264 #

3265 # lhs ExprNode Left hand side

3266 # rhs ExprNode Right hand side

3267 # first bool Is this guaranteed the first assignment to lhs?

3268

3269 child_attrs = ["lhs", "rhs"]

3270 first = False

3271 declaration_only = False

3272

3273 def analyse_declarations(self, env):

3274 import ExprNodes

3275

3276 # handle declarations of the form x = cython.foo()

3277 if isinstance(self.rhs, ExprNodes.CallNode):

3278 func_name = self.rhs.function.as_cython_attribute()

3279 if func_name:

3280 args, kwds = self.rhs.explicit_args_kwds()

3281

3282 if func_name in ['declare', 'typedef']:

3283 if len(args) > 2 or kwds is not None:

3284 error(rhs.pos, "Can only declare one type at a time.")

3285 return

3286 type = args[0].analyse_as_type(env)

3287 if type is None:

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

3289 return

3290 lhs = self.lhs

3291 if func_name == 'declare':

3292 if isinstance(lhs, ExprNodes.NameNode):

3293 vars = [(lhs.name, lhs.pos)]

3294 elif isinstance(lhs, ExprNodes.TupleNode):

3295 vars = [(var.name, var.pos) for var in lhs.args]

3296 else:

3297 error(lhs.pos, "Invalid declaration")

3298 return

3299 for var, pos in vars:

3300 env.declare_var(var, type, pos, is_cdef = True)

3301 if len(args) == 2:

3302 # we have a value

3303 self.rhs = args[1]

3304 else:

3305 self.declaration_only = True

3306 else:

3307 self.declaration_only = True

3308 if not isinstance(lhs, ExprNodes.NameNode):

3309 error(lhs.pos, "Invalid declaration.")

3310 env.declare_typedef(lhs.name, type, self.pos, visibility='private')

3311

3312 elif func_name in ['struct', 'union']:

3313 self.declaration_only = True

3314 if len(args) > 0 or kwds is None:

3315 error(rhs.pos, "Struct or union members must be given by name.")

3316 return

3317 members = []

3318 for member, type_node in kwds.key_value_pairs:

3319 type = type_node.analyse_as_type(env)

3320 if type is None:

3321 error(type_node.pos, "Unknown type")

3322 else:

3323 members.append((member.value, type, member.pos))

3324 if len(members) < len(kwds.key_value_pairs):

3325 return

3326 if not isinstance(self.lhs, ExprNodes.NameNode):

3327 error(self.lhs.pos, "Invalid declaration.")

3328 name = self.lhs.name

3329 scope = StructOrUnionScope(name)

3330 env.declare_struct_or_union(name, func_name, scope, False, self.rhs.pos)

3331 for member, type, pos in members:

3332 scope.declare_var(member, type, pos)

3333

3334 if self.declaration_only:

3335 return

3336 else:

3337 self.lhs.analyse_target_declaration(env)

3338

3339 def analyse_types(self, env, use_temp = 0):

3340 self.rhs.analyse_types(env)

3341 self.lhs.analyse_target_types(env)

3342 self.lhs.gil_assignment_check(env)

3343 self.rhs = self.rhs.coerce_to(self.lhs.type, env)

3344 if use_temp:

3345 self.rhs = self.rhs.coerce_to_temp(env)

3346

3347 def generate_rhs_evaluation_code(self, code):

3348 self.rhs.generate_evaluation_code(code)

3349

3350 def generate_assignment_code(self, code):

3351 self.lhs.generate_assignment_code(self.rhs, code)

3352

3353 def generate_function_definitions(self, env, code):

3354 self.rhs.generate_function_definitions(env, code)

3355

3356 def annotate(self, code):

3357 self.lhs.annotate(code)

3358 self.rhs.annotate(code)

3359

3360

3361 class CascadedAssignmentNode(AssignmentNode):

3362 # An assignment with multiple left hand sides:

3363 #

3364 # a = b = c

3365 #

3366 # lhs_list [ExprNode] Left hand sides

3367 # rhs ExprNode Right hand sides

3368 #

3369 # Used internally:

3370 #

3371 # coerced_rhs_list [ExprNode] RHS coerced to type of each LHS

3372

3373 child_attrs = ["lhs_list", "rhs", "coerced_rhs_list"]

3374 coerced_rhs_list = None

3375

3376 def analyse_declarations(self, env):

3377 for lhs in self.lhs_list:

3378 lhs.analyse_target_declaration(env)

3379

3380 def analyse_types(self, env, use_temp = 0):

3381 self.rhs.analyse_types(env)

3382 if not self.rhs.is_simple():

3383 if use_temp:

3384 self.rhs = self.rhs.coerce_to_temp(env)

3385 else:

3386 self.rhs = self.rhs.coerce_to_simple(env)

3387 from ExprNodes import CloneNode

3388 self.coerced_rhs_list = []

3389 for lhs in self.lhs_list:

3390 lhs.analyse_target_types(env)

3391 lhs.gil_assignment_check(env)

3392 rhs = CloneNode(self.rhs)

3393 rhs = rhs.coerce_to(lhs.type, env)

3394 self.coerced_rhs_list.append(rhs)

3395

3396 def generate_rhs_evaluation_code(self, code):

3397 self.rhs.generate_evaluation_code(code)

3398

3399 def generate_assignment_code(self, code):

3400 for i in range(len(self.lhs_list)):

3401 lhs = self.lhs_list[i]

3402 rhs = self.coerced_rhs_list[i]

3403 rhs.generate_evaluation_code(code)

3404 lhs.generate_assignment_code(rhs, code)

3405 # Assignment has disposed of the cloned RHS

3406 self.rhs.generate_disposal_code(code)

3407 self.rhs.free_temps(code)

3408

3409 def generate_function_definitions(self, env, code):

3410 self.rhs.generate_function_definitions(env, code)

3411

3412 def annotate(self, code):

3413 for i in range(len(self.lhs_list)):

3414 lhs = self.lhs_list[i].annotate(code)

3415 rhs = self.coerced_rhs_list[i].annotate(code)

3416 self.rhs.annotate(code)

3417

3418

3419 class ParallelAssignmentNode(AssignmentNode):

3420 # A combined packing/unpacking assignment:

3421 #

3422 # a, b, c = d, e, f

3423 #

3424 # This has been rearranged by the parser into

3425 #

3426 # a = d ; b = e ; c = f

3427 #

3428 # but we must evaluate all the right hand sides

3429 # before assigning to any of the left hand sides.

3430 #

3431 # stats [AssignmentNode] The constituent assignments

3432

3433 child_attrs = ["stats"]

3434

3435 def analyse_declarations(self, env):

3436 for stat in self.stats:

3437 stat.analyse_declarations(env)

3438

3439 def analyse_expressions(self, env):

3440 for stat in self.stats:

3441 stat.analyse_types(env, use_temp = 1)

3442

3443 # def analyse_expressions(self, env):

3444 # for stat in self.stats:

3445 # stat.analyse_expressions_1(env, use_temp = 1)

3446 # for stat in self.stats:

3447 # stat.analyse_expressions_2(env)

3448

3449 def generate_execution_code(self, code):

3450 for stat in self.stats:

3451 stat.generate_rhs_evaluation_code(code)

3452 for stat in self.stats:

3453 stat.generate_assignment_code(code)

3454

3455 def generate_function_definitions(self, env, code):

3456 for stat in self.stats:

3457 stat.generate_function_definitions(env, code)

3458

3459 def annotate(self, code):

3460 for stat in self.stats:

3461 stat.annotate(code)

3462

3463

3464 class InPlaceAssignmentNode(AssignmentNode):

3465 # An in place arithmetic operand:

3466 #

3467 # a += b

3468 # a -= b

3469 # ...

3470 #

3471 # lhs ExprNode Left hand side

3472 # rhs ExprNode Right hand side

3473 # op char one of "+-*/%^&|"

3474 # dup (ExprNode) copy of lhs used for operation (auto-generated)

3475 #

3476 # This code is a bit tricky because in order to obey Python

3477 # semantics the sub-expressions (e.g. indices) of the lhs must

3478 # not be evaluated twice. So we must re-use the values calculated

3479 # in evaluation phase for the assignment phase as well.

3480 # Fortunately, the type of the lhs node is fairly constrained

3481 # (it must be a NameNode, AttributeNode, or IndexNode).

3482

3483 child_attrs = ["lhs", "rhs"]

3484 dup = None

3485

3486 def analyse_declarations(self, env):

3487 self.lhs.analyse_target_declaration(env)

3488

3489 def analyse_types(self, env):

3490 self.dup = self.create_dup_node(env) # re-assigns lhs to a shallow copy

3491 self.rhs.analyse_types(env)

3492 self.lhs.analyse_target_types(env)

3493 import ExprNodes

3494 if self.lhs.type.is_pyobject:

3495 self.rhs = self.rhs.coerce_to_pyobject(env)

3496 elif self.rhs.type.is_pyobject or (self.lhs.type.is_numeric and self.rhs.type.is_numeric):

3497 self.rhs = self.rhs.coerce_to(self.lhs.type, env)

3498 if self.lhs.type.is_pyobject:

3499 self.result_value_temp = ExprNodes.PyTempNode(self.pos, env)

3500 self.result_value = self.result_value_temp.coerce_to(self.lhs.type, env)

3501

3502 def generate_execution_code(self, code):

3503 import ExprNodes

3504 self.rhs.generate_evaluation_code(code)

3505 self.dup.generate_subexpr_evaluation_code(code)

3506 if self.dup.is_temp:

3507 self.dup.allocate_temp_result(code)

3508 # self.dup.generate_result_code is run only if it is not buffer access

3509 if self.operator == "**":

3510 extra = ", Py_None"

3511 else:

3512 extra = ""

3513 if self.lhs.type.is_pyobject:

3514 if isinstance(self.lhs, ExprNodes.IndexNode) and self.lhs.is_buffer_access:

3515 error(self.pos, "In-place operators not allowed on object buffers in this release.")

3516 self.dup.generate_result_code(code)

3517 self.result_value_temp.allocate(code)

3518 code.putln(

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

3520 self.result_value.result(),

3521 self.py_operation_function(),

3522 self.dup.py_result(),

3523 self.rhs.py_result(),

3524 extra,

3525 code.error_goto_if_null(self.result_value.py_result(), self.pos)))

3526 code.put_gotref(self.result_value.py_result())

3527 self.result_value.generate_evaluation_code(code) # May be a type check...

3528 self.rhs.generate_disposal_code(code)

3529 self.rhs.free_temps(code)

3530 self.dup.generate_disposal_code(code)

3531 self.dup.free_temps(code)

3532 self.lhs.generate_assignment_code(self.result_value, code)

3533 self.result_value_temp.release(code)

3534 else:

3535 c_op = self.operator

3536 if c_op == "//":

3537 c_op = "/"

3538 elif c_op == "**":

3539 error(self.pos, "No C inplace power operator")

3540 elif self.lhs.type.is_complex:

3541 error(self.pos, "Inplace operators not implemented for complex types.")

3542

3543 # have to do assignment directly to avoid side-effects

3544 if isinstance(self.lhs, ExprNodes.IndexNode) and self.lhs.is_buffer_access:

3545 self.lhs.generate_buffer_setitem_code(self.rhs, code, c_op)

3546 else:

3547 self.dup.generate_result_code(code)

3548 code.putln("%s %s= %s;" % (self.lhs.result(), c_op, self.rhs.result()) )

3549 self.rhs.generate_disposal_code(code)

3550 self.rhs.free_temps(code)

3551 if self.dup.is_temp:

3552 self.dup.generate_subexpr_disposal_code(code)

3553 self.dup.free_subexpr_temps(code)

3554

3555 def create_dup_node(self, env):

3556 import ExprNodes

3557 self.dup = self.lhs

3558 self.dup.analyse_types(env)

3559 if isinstance(self.lhs, ExprNodes.NameNode):

3560 target_lhs = ExprNodes.NameNode(self.dup.pos,

3561 name = self.dup.name,

3562 is_temp = self.dup.is_temp,

3563 entry = self.dup.entry)

3564 elif isinstance(self.lhs, ExprNodes.AttributeNode):

3565 target_lhs = ExprNodes.AttributeNode(self.dup.pos,

3566 obj = ExprNodes.CloneNode(self.lhs.obj),

3567 attribute = self.dup.attribute,

3568 is_temp = self.dup.is_temp)

3569 elif isinstance(self.lhs, ExprNodes.IndexNode):

3570 if self.lhs.index:

3571 index = ExprNodes.CloneNode(self.lhs.index)

3572 else:

3573 index = None

3574 if self.lhs.indices:

3575 indices = [ExprNodes.CloneNode(x) for x in self.lhs.indices]

3576 else:

3577 indices = []

3578 target_lhs = ExprNodes.IndexNode(self.dup.pos,

3579 base = ExprNodes.CloneNode(self.dup.base),

3580 index = index,

3581 indices = indices,

3582 is_temp = self.dup.is_temp)

3583 else:

3584 assert False, "Unsupported node: %s" % type(self.lhs)

3585 self.lhs = target_lhs

3586 return self.dup

3587

3588 def py_operation_function(self):

3589 return self.py_functions[self.operator]

3590

3591 py_functions = {

3592 "|": "PyNumber_InPlaceOr",

3593 "^": "PyNumber_InPlaceXor",

3594 "&": "PyNumber_InPlaceAnd",

3595 "+": "PyNumber_InPlaceAdd",

3596 "-": "PyNumber_InPlaceSubtract",

3597 "*": "PyNumber_InPlaceMultiply",

3598 "/": "__Pyx_PyNumber_InPlaceDivide",

3599 "%": "PyNumber_InPlaceRemainder",

3600 "<<": "PyNumber_InPlaceLshift",

3601 ">>": "PyNumber_InPlaceRshift",

3602 "**": "PyNumber_InPlacePower",

3603 "//": "PyNumber_InPlaceFloorDivide",

3604 }

3605

3606 def annotate(self, code):

3607 self.lhs.annotate(code)

3608 self.rhs.annotate(code)

3609 self.dup.annotate(code)

3610

3611 def create_binop_node(self):

3612 import ExprNodes

3613 return ExprNodes.binop_node(self.pos, self.operator, self.lhs, self.rhs)

3614

3615

3616 class PrintStatNode(StatNode):

3617 # print statement

3618 #

3619 # arg_tuple TupleNode

3620 # stream ExprNode or None (stdout)

3621 # append_newline boolean

3622

3623 child_attrs = ["arg_tuple", "stream"]

3624

3625 def analyse_expressions(self, env):

3626 if self.stream:

3627 self.stream.analyse_expressions(env)

3628 self.stream = self.stream.coerce_to_pyobject(env)

3629 self.arg_tuple.analyse_expressions(env)

3630 self.arg_tuple = self.arg_tuple.coerce_to_pyobject(env)

3631 env.use_utility_code(printing_utility_code)

3632 if len(self.arg_tuple.args) == 1 and self.append_newline:

3633 env.use_utility_code(printing_one_utility_code)

3634

3635 nogil_check = Node.gil_error

3636 gil_message = "Python print statement"

3637

3638 def generate_execution_code(self, code):

3639 if self.stream:

3640 self.stream.generate_evaluation_code(code)

3641 stream_result = self.stream.py_result()

3642 else:

3643 stream_result = '0'

3644 if len(self.arg_tuple.args) == 1 and self.append_newline:

3645 arg = self.arg_tuple.args[0]

3646 arg.generate_evaluation_code(code)

3647

3648 code.putln(

3649 "if (__Pyx_PrintOne(%s, %s) < 0) %s" % (

3650 stream_result,

3651 arg.py_result(),

3652 code.error_goto(self.pos)))

3653 arg.generate_disposal_code(code)

3654 arg.free_temps(code)

3655 else:

3656 self.arg_tuple.generate_evaluation_code(code)

3657 code.putln(

3658 "if (__Pyx_Print(%s, %s, %d) < 0) %s" % (

3659 stream_result,

3660 self.arg_tuple.py_result(),

3661 self.append_newline,

3662 code.error_goto(self.pos)))

3663 self.arg_tuple.generate_disposal_code(code)

3664 self.arg_tuple.free_temps(code)

3665

3666 if self.stream:

3667 self.stream.generate_disposal_code(code)

3668 self.stream.free_temps(code)

3669

3670 def generate_function_definitions(self, env, code):

3671 if self.stream:

3672 self.stream.generate_function_definitions(env, code)

3673 self.arg_tuple.generate_function_definitions(env, code)

3674

3675 def annotate(self, code):

3676 if self.stream:

3677 self.stream.annotate(code)

3678 self.arg_tuple.annotate(code)

3679

3680

3681 class ExecStatNode(StatNode):

3682 # exec statement

3683 #

3684 # args [ExprNode]

3685

3686 child_attrs = ["args"]

3687

3688 def analyse_expressions(self, env):

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

3690 arg.analyse_expressions(env)

3691 arg = arg.coerce_to_pyobject(env)

3692 self.args[i] = arg

3693 env.use_utility_code(Builtin.pyexec_utility_code)

3694

3695 nogil_check = Node.gil_error

3696 gil_message = "Python exec statement"

3697

3698 def generate_execution_code(self, code):

3699 args = []

3700 for arg in self.args:

3701 arg.generate_evaluation_code(code)

3702 args.append( arg.py_result() )

3703 args = tuple(args + ['0', '0'][:3-len(args)])

3704 temp_result = code.funcstate.allocate_temp(PyrexTypes.py_object_type, manage_ref=True)

3705 code.putln("%s = __Pyx_PyRun(%s, %s, %s);" % (

3706 (temp_result,) + args))

3707 for arg in self.args:

3708 arg.generate_disposal_code(code)

3709 arg.free_temps(code)

3710 code.putln(

3711 code.error_goto_if_null(temp_result, self.pos))

3712 code.put_gotref(temp_result)

3713 code.put_decref_clear(temp_result, py_object_type)

3714 code.funcstate.release_temp(temp_result)

3715

3716 def annotate(self, code):

3717 for arg in self.args:

3718 arg.annotate(code)

3719

3720

3721 class DelStatNode(StatNode):

3722 # del statement

3723 #

3724 # args [ExprNode]

3725

3726 child_attrs = ["args"]

3727

3728 def analyse_declarations(self, env):

3729 for arg in self.args:

3730 arg.analyse_target_declaration(env)

3731

3732 def analyse_expressions(self, env):

3733 for arg in self.args:

3734 arg.analyse_target_expression(env, None)

3735 if arg.type.is_pyobject:

3736 pass

3737 elif arg.type.is_ptr and arg.type.base_type.is_cpp_class:

3738 self.cpp_check(env)

3739 elif arg.type.is_cpp_class:

3740 error(arg.pos, "Deletion of non-heap C++ object")

3741 else:

3742 error(arg.pos, "Deletion of non-Python, non-C++ object")

3743 #arg.release_target_temp(env)

3744

3745 def nogil_check(self, env):

3746 for arg in self.args:

3747 if arg.type.is_pyobject:

3748 self.gil_error()

3749

3750 gil_message = "Deleting Python object"

3751

3752 def generate_execution_code(self, code):

3753 for arg in self.args:

3754 if arg.type.is_pyobject:

3755 arg.generate_deletion_code(code)

3756 elif arg.type.is_ptr and arg.type.base_type.is_cpp_class:

3757 arg.generate_result_code(code)

3758 code.putln("delete %s;" % arg.result())

3759 # else error reported earlier

3760

3761 def annotate(self, code):

3762 for arg in self.args:

3763 arg.annotate(code)

3764

3765

3766 class PassStatNode(StatNode):

3767 # pass statement

3768

3769 child_attrs = []

3770

3771 def analyse_expressions(self, env):

3772 pass

3773

3774 def generate_execution_code(self, code):

3775 pass

3776

3777

3778 class BreakStatNode(StatNode):

3779

3780 child_attrs = []

3781

3782 def analyse_expressions(self, env):

3783 pass

3784

3785 def generate_execution_code(self, code):

3786 if not code.break_label:

3787 error(self.pos, "break statement not inside loop")

3788 else:

3789 code.put_goto(code.break_label)

3790

3791

3792 class ContinueStatNode(StatNode):

3793

3794 child_attrs = []

3795

3796 def analyse_expressions(self, env):

3797 pass

3798

3799 def generate_execution_code(self, code):

3800 if code.funcstate.in_try_finally:

3801 error(self.pos, "continue statement inside try of try...finally")

3802 elif not code.continue_label:

3803 error(self.pos, "continue statement not inside loop")

3804 else:

3805 code.put_goto(code.continue_label)

3806

3807

3808 class ReturnStatNode(StatNode):

3809 # return statement

3810 #

3811 # value ExprNode or None

3812 # return_type PyrexType

3813

3814 child_attrs = ["value"]

3815

3816 def analyse_expressions(self, env):

3817 return_type = env.return_type

3818 self.return_type = return_type

3819 if not return_type:

3820 error(self.pos, "Return not inside a function body")

3821 return

3822 if self.value:

3823 self.value.analyse_types(env)

3824 if return_type.is_void or return_type.is_returncode:

3825 error(self.value.pos,

3826 "Return with value in void function")

3827 else:

3828 self.value = self.value.coerce_to(env.return_type, env)

3829 else:

3830 if (not return_type.is_void

3831 and not return_type.is_pyobject

3832 and not return_type.is_returncode):

3833 error(self.pos, "Return value required")

3834

3835 def nogil_check(self, env):

3836 if self.return_type.is_pyobject:

3837 self.gil_error()

3838

3839 gil_message = "Returning Python object"

3840

3841 def generate_execution_code(self, code):

3842 code.mark_pos(self.pos)

3843 if not self.return_type:

3844 # error reported earlier

3845 return

3846 if self.return_type.is_pyobject:

3847 code.put_xdecref(Naming.retval_cname,

3848 self.return_type)

3849 if self.value:

3850 self.value.generate_evaluation_code(code)

3851 self.value.make_owned_reference(code)

3852 code.putln(

3853 "%s = %s;" % (

3854 Naming.retval_cname,

3855 self.value.result_as(self.return_type)))

3856 self.value.generate_post_assignment_code(code)

3857 self.value.free_temps(code)

3858 else:

3859 if self.return_type.is_pyobject:

3860 code.put_init_to_py_none(Naming.retval_cname, self.return_type)

3861 elif self.return_type.is_returncode:

3862 code.putln(

3863 "%s = %s;" % (

3864 Naming.retval_cname,

3865 self.return_type.default_value))

3866 for cname, type in code.funcstate.temps_holding_reference():

3867 code.put_decref_clear(cname, type)

3868 code.put_goto(code.return_label)

3869

3870 def generate_function_definitions(self, env, code):

3871 if self.value is not None:

3872 self.value.generate_function_definitions(env, code)

3873

3874 def annotate(self, code):

3875 if self.value:

3876 self.value.annotate(code)

3877

3878

3879 class RaiseStatNode(StatNode):

3880 # raise statement

3881 #

3882 # exc_type ExprNode or None

3883 # exc_value ExprNode or None

3884 # exc_tb ExprNode or None

3885

3886 child_attrs = ["exc_type", "exc_value", "exc_tb"]

3887

3888 def analyse_expressions(self, env):

3889 if self.exc_type:

3890 self.exc_type.analyse_types(env)

3891 self.exc_type = self.exc_type.coerce_to_pyobject(env)

3892 if self.exc_value:

3893 self.exc_value.analyse_types(env)

3894 self.exc_value = self.exc_value.coerce_to_pyobject(env)

3895 if self.exc_tb:

3896 self.exc_tb.analyse_types(env)

3897 self.exc_tb = self.exc_tb.coerce_to_pyobject(env)

3898 env.use_utility_code(raise_utility_code)

3899

3900 nogil_check = Node.gil_error

3901 gil_message = "Raising exception"

3902

3903 def generate_execution_code(self, code):

3904 if self.exc_type:

3905 self.exc_type.generate_evaluation_code(code)

3906 type_code = self.exc_type.py_result()

3907 else:

3908 type_code = "0"

3909 if self.exc_value:

3910 self.exc_value.generate_evaluation_code(code)

3911 value_code = self.exc_value.py_result()

3912 else:

3913 value_code = "0"

3914 if self.exc_tb:

3915 self.exc_tb.generate_evaluation_code(code)

3916 tb_code = self.exc_tb.py_result()

3917 else:

3918 tb_code = "0"

3919 code.putln(

3920 "__Pyx_Raise(%s, %s, %s);" % (

3921 type_code,

3922 value_code,

3923 tb_code))

3924 for obj in (self.exc_type, self.exc_value, self.exc_tb):

3925 if obj:

3926 obj.generate_disposal_code(code)

3927 obj.free_temps(code)

3928 code.putln(

3929 code.error_goto(self.pos))

3930

3931 def generate_function_definitions(self, env, code):

3932 if self.exc_type is not None:

3933 self.exc_type.generate_function_definitions(env, code)

3934 if self.exc_value is not None:

3935 self.exc_value.generate_function_definitions(env, code)

3936 if self.exc_tb is not None:

3937 self.exc_tb.generate_function_definitions(env, code)

3938

3939 def annotate(self, code):

3940 if self.exc_type:

3941 self.exc_type.annotate(code)

3942 if self.exc_value:

3943 self.exc_value.annotate(code)

3944 if self.exc_tb:

3945 self.exc_tb.annotate(code)

3946

3947

3948 class ReraiseStatNode(StatNode):

3949

3950 child_attrs = []

3951

3952 def analyse_expressions(self, env):

3953 env.use_utility_code(restore_exception_utility_code)

3954

3955 nogil_check = Node.gil_error

3956 gil_message = "Raising exception"

3957

3958 def generate_execution_code(self, code):

3959 vars = code.funcstate.exc_vars

3960 if vars:

3961 for varname in vars:

3962 code.put_giveref(varname)

3963 code.putln("__Pyx_ErrRestore(%s, %s, %s);" % tuple(vars))

3964 for varname in vars:

3965 code.put("%s = 0; " % varname)

3966 code.putln()

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

3968 else:

3969 error(self.pos, "Reraise not inside except clause")

3970

3971

3972 class AssertStatNode(StatNode):