1

2 #

3 # Pyrex - Parse tree nodes

4 #

5

6 import cython

7 from cython import set

8 cython.declare(sys=object, os=object, time=object, copy=object,

9 Builtin=object, error=object, warning=object, Naming=object, PyrexTypes=object,

10 py_object_type=object, ModuleScope=object, LocalScope=object, ClosureScope=object, \

11 StructOrUnionScope=object, PyClassScope=object, CClassScope=object,

12 CppClassScope=object, UtilityCode=object, EncodedString=object,

13 absolute_path_length=cython.Py_ssize_t)

14

15 import sys, os, time, copy

16

17 import Builtin

18 from Errors import error, warning, InternalError

19 import Naming

20 import PyrexTypes

21 import TypeSlots

22 from PyrexTypes import py_object_type, error_type, CFuncType

23 from Symtab import ModuleScope, LocalScope, ClosureScope, \

24 StructOrUnionScope, PyClassScope, CClassScope, CppClassScope

25 from Cython.Utils import open_new_file, replace_suffix

26 from Code import UtilityCode

27 from StringEncoding import EncodedString, escape_byte_string, split_string_literal

28 import Options

29 import ControlFlow

30 import DebugFlags

31

32 absolute_path_length = 0

33

34 def relative_position(pos):

35 """

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

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

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

39 e.g,. when distributing binaries.)

40

41 INPUT:

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

43

44 OUTPUT:

45 relative filename

46 line number

47

48 AUTHOR: William Stein

49 """

50 global absolute_path_length

51 if absolute_path_length==0:

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

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

54

55 def embed_position(pos, docstring):

56 if not Options.embed_pos_in_docstring:

57 return docstring

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

59 if docstring is None:

60 # unicode string

61 return EncodedString(pos_line)

62

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

64 # otherwise make the docstring a unicode string

65 encoding = docstring.encoding

66 if encoding is not None:

67 try:

68 encoded_bytes = pos_line.encode(encoding)

69 except UnicodeEncodeError:

70 encoding = None

71

72 if not docstring:

73 # reuse the string encoding of the original docstring

74 doc = EncodedString(pos_line)

75 else:

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

77 doc.encoding = encoding

78 return doc

79

80

81 from Code import CCodeWriter

82 from types import FunctionType

83

84 def write_func_call(func):

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

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

87 # here we annotate the code with this function call

88 # but only if new code is generated

89 node, code = args[:2]

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

91 ' ' * code.call_level,

92 node.__class__.__name__,

93 func.__name__,

94 node.pos[1:])

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

96 code.putln(marker)

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

98 code.call_level += 4

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

100 code.call_level -= 4

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

102 code.buffer.stream.seek(pristine)

103 else:

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

105 code.putln(marker)

106 return res

107 else:

108 return func(*args, **kwds)

109 return f

110

111 class VerboseCodeWriter(type):

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

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

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

115 attrs = dict(attrs)

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

117 if isinstance(m, FunctionType):

118 attrs[mname] = write_func_call(m)

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

120

121

122 class Node(object):

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

124 # is_name boolean Is a NameNode

125 # is_literal boolean Is a ConstNode

126

127 if DebugFlags.debug_trace_code_generation:

128 __metaclass__ = VerboseCodeWriter

129

130 is_name = 0

131 is_literal = 0

132 temps = None

133

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

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

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

137 child_attrs = None

138

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

140 self.pos = pos

141 self.__dict__.update(kw)

142

143 gil_message = "Operation"

144

145 nogil_check = None

146

147 def gil_error(self, env=None):

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

149

150 cpp_message = "Operation"

151

152 def cpp_check(self, env):

153 if not env.is_cpp():

154 self.cpp_error()

155

156 def cpp_error(self):

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

158

159 def clone_node(self):

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

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

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

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

164 level in the tree."""

165 result = copy.copy(self)

166 for attrname in result.child_attrs:

167 value = getattr(result, attrname)

168 if isinstance(value, list):

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

170 return result

171

172

173 #

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

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

176 #

177 # (0) analyse_control_flow

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

179 # queried.

180 #

181 # (1) analyse_declarations

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

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

184 # to an otherwise undeclared name).

185 #

186 # (2) analyse_expressions

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

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

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

190 # Allocate temporary locals for intermediate results. Fill

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

192 # fragment.

193 #

194 # (3) generate_code

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

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

197 # functions.

198 #

199

200 def analyse_control_flow(self, env):

201 pass

202

203 def analyse_declarations(self, env):

204 pass

205

206 def analyse_expressions(self, env):

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

208 self.__class__.__name__)

209

210 def generate_code(self, code):

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

212 self.__class__.__name__)

213

214 def annotate(self, code):

215 # mro does the wrong thing

216 if isinstance(self, BlockNode):

217 self.body.annotate(code)

218

219 def end_pos(self):

220 try:

221 return self._end_pos

222 except AttributeError:

223 pos = self.pos

224 if not self.child_attrs:

225 self._end_pos = pos

226 return pos

227 for attr in self.child_attrs:

228 child = getattr(self, attr)

229 # Sometimes lists, sometimes nodes

230 if child is None:

231 pass

232 elif isinstance(child, list):

233 for c in child:

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

235 else:

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

237 self._end_pos = pos

238 return pos

239

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

241 if cutoff == 0:

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

243 if encountered is None:

244 encountered = set()

245 if id(self) in encountered:

246 return "<%s (0x%x) -- already output>" % (self.__class__.__name__, id(self))

247 encountered.add(id(self))

248

249 def dump_child(x, level):

250 if isinstance(x, Node):

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

252 elif isinstance(x, list):

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

254 else:

255 return repr(x)

256

257

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

259 if len(attrs) == 0:

260 return "<%s (0x%x)>" % (self.__class__.__name__, id(self))

261 else:

262 indent = " " * level

263 res = "<%s (0x%x)\n" % (self.__class__.__name__, id(self))

264 for key, value in attrs:

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

266 res += "%s>" % indent

267 return res

268

269 class CompilerDirectivesNode(Node):

270 """

271 Sets compiler directives for the children nodes

272 """

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

274 # *all* possible directives.

275 # body Node

276 child_attrs = ["body"]

277

278 def analyse_control_flow(self, env):

279 old = env.directives

280 env.directives = self.directives

281 self.body.analyse_control_flow(env)

282 env.directives = old

283

284 def analyse_declarations(self, env):

285 old = env.directives

286 env.directives = self.directives

287 self.body.analyse_declarations(env)

288 env.directives = old

289

290 def analyse_expressions(self, env):

291 old = env.directives

292 env.directives = self.directives

293 self.body.analyse_expressions(env)

294 env.directives = old

295

296 def generate_function_definitions(self, env, code):

297 env_old = env.directives

298 code_old = code.globalstate.directives

299 code.globalstate.directives = self.directives

300 self.body.generate_function_definitions(env, code)

301 env.directives = env_old

302 code.globalstate.directives = code_old

303

304 def generate_execution_code(self, code):

305 old = code.globalstate.directives

306 code.globalstate.directives = self.directives

307 self.body.generate_execution_code(code)

308 code.globalstate.directives = old

309

310 def annotate(self, code):

311 old = code.globalstate.directives

312 code.globalstate.directives = self.directives

313 self.body.annotate(code)

314 code.globalstate.directives = old

315

316 class BlockNode(object):

317 # Mixin class for nodes representing a declaration block.

318

319 def generate_cached_builtins_decls(self, env, code):

320 entries = env.global_scope().undeclared_cached_builtins

321 for entry in entries:

322 code.globalstate.add_cached_builtin_decl(entry)

323 del entries[:]

324

325 def generate_lambda_definitions(self, env, code):

326 for node in env.lambda_defs:

327 node.generate_function_definitions(env, code)

328

329 class StatListNode(Node):

330 # stats a list of StatNode

331

332 child_attrs = ["stats"]

333

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

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

336 return node # No node-specific analysis necesarry

337 create_analysed = staticmethod(create_analysed)

338

339 def analyse_control_flow(self, env):

340 for stat in self.stats:

341 stat.analyse_control_flow(env)

342

343 def analyse_declarations(self, env):

344 #print "StatListNode.analyse_declarations" ###

345 for stat in self.stats:

346 stat.analyse_declarations(env)

347

348 def analyse_expressions(self, env):

349 #print "StatListNode.analyse_expressions" ###

350 for stat in self.stats:

351 stat.analyse_expressions(env)

352

353 def generate_function_definitions(self, env, code):

354 #print "StatListNode.generate_function_definitions" ###

355 for stat in self.stats:

356 stat.generate_function_definitions(env, code)

357

358 def generate_execution_code(self, code):

359 #print "StatListNode.generate_execution_code" ###

360 for stat in self.stats:

361 code.mark_pos(stat.pos)

362 stat.generate_execution_code(code)

363

364 def annotate(self, code):

365 for stat in self.stats:

366 stat.annotate(code)

367

368

369 class StatNode(Node):

370 #

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

372 #

373 # (1) generate_function_definitions

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

375 # unions, enums and functions defined in the current

376 # scope-block.

377 #

378 # (2) generate_execution_code

379 # Emit C code for executable statements.

380 #

381

382 def generate_function_definitions(self, env, code):

383 pass

384

385 def generate_execution_code(self, code):

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

387 self.__class__.__name__)

388

389

390 class CDefExternNode(StatNode):

391 # include_file string or None

392 # body StatNode

393

394 child_attrs = ["body"]

395

396 def analyse_declarations(self, env):

397 if self.include_file:

398 env.add_include_file(self.include_file)

399 old_cinclude_flag = env.in_cinclude

400 env.in_cinclude = 1

401 self.body.analyse_declarations(env)

402 env.in_cinclude = old_cinclude_flag

403

404 def analyse_expressions(self, env):

405 pass

406

407 def generate_execution_code(self, code):

408 pass

409

410 def annotate(self, code):

411 self.body.annotate(code)

412

413

414 class CDeclaratorNode(Node):

415 # Part of a C declaration.

416 #

417 # Processing during analyse_declarations phase:

418 #

419 # analyse

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

421 # CNameDeclaratorNode of the name being declared

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

423 #

424 # calling_convention string Calling convention of CFuncDeclaratorNode

425 # for which this is a base

426

427 child_attrs = []

428

429 calling_convention = ""

430

431

432 class CNameDeclaratorNode(CDeclaratorNode):

433 # name string The Pyrex name being declared

434 # cname string or None C name, if specified

435 # default ExprNode or None the value assigned on declaration

436

437 child_attrs = ['default']

438

439 default = None

440

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

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

443 # May have mistaken the name for the type.

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

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

446 elif base_type.is_void:

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

448 else:

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

450 base_type = py_object_type

451 self.type = base_type

452 return self, base_type

453

454 class CPtrDeclaratorNode(CDeclaratorNode):

455 # base CDeclaratorNode

456

457 child_attrs = ["base"]

458

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

460 if base_type.is_pyobject:

461 error(self.pos,

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

463 ptr_type = PyrexTypes.c_ptr_type(base_type)

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

465

466 class CReferenceDeclaratorNode(CDeclaratorNode):

467 # base CDeclaratorNode

468

469 child_attrs = ["base"]

470

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

472 if base_type.is_pyobject:

473 error(self.pos,

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

475 ref_type = PyrexTypes.c_ref_type(base_type)

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

477

478 class CArrayDeclaratorNode(CDeclaratorNode):

479 # base CDeclaratorNode

480 # dimension ExprNode

481

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

483

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

485 if base_type.is_cpp_class:

486 from ExprNodes import TupleNode

487 if isinstance(self.dimension, TupleNode):

488 args = self.dimension.args

489 else:

490 args = self.dimension,

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

492 if None in values:

493 ix = values.index(None)

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

495 return error_type

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

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

498 if self.dimension:

499 self.dimension.analyse_const_expression(env)

500 if not self.dimension.type.is_int:

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

502 size = self.dimension.get_constant_c_result_code()

503 if size is not None:

504 try:

505 size = int(size)

506 except ValueError:

507 # runtime constant?

508 pass

509 else:

510 size = None

511 if not base_type.is_complete():

512 error(self.pos,

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

514 if base_type.is_pyobject:

515 error(self.pos,

516 "Array element cannot be a Python object")

517 if base_type.is_cfunction:

518 error(self.pos,

519 "Array element cannot be a function")

520 array_type = PyrexTypes.c_array_type(base_type, size)

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

522

523

524 class CFuncDeclaratorNode(CDeclaratorNode):

525 # base CDeclaratorNode

526 # args [CArgDeclNode]

527 # has_varargs boolean

528 # exception_value ConstNode

529 # exception_check boolean True if PyErr_Occurred check needed

530 # nogil boolean Can be called without gil

531 # with_gil boolean Acquire gil around function body

532

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

534

535 overridable = 0

536 optional_arg_count = 0

537

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

539 if nonempty:

540 nonempty -= 1

541 func_type_args = []

542 for i, arg_node in enumerate(self.args):

543 name_declarator, type = arg_node.analyse(env, nonempty = nonempty,

544 is_self_arg = (i == 0 and env.is_c_class_scope))

545 name = name_declarator.name

546 if name_declarator.cname:

547 error(self.pos,

548 "Function argument cannot have C name specification")

549 # Turn *[] argument into **

550 if type.is_array:

551 type = PyrexTypes.c_ptr_type(type.base_type)

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

553 if type.is_void:

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

555 func_type_args.append(

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

557 if arg_node.default:

558 self.optional_arg_count += 1

559 elif self.optional_arg_count:

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

561

562 if self.optional_arg_count:

563 scope = StructOrUnionScope()

564 arg_count_member = '%sn' % Naming.pyrex_prefix

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

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

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

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

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

570 kind = 'struct',

571 scope = scope,

572 typedef_flag = 0,

573 pos = self.pos,

574 cname = struct_cname)

575 self.op_args_struct.defined_in_pxd = 1

576 self.op_args_struct.used = 1

577

578 exc_val = None

579 exc_check = 0

580 if self.exception_check == '+':

581 env.add_include_file('stdexcept')

582 if return_type.is_pyobject \

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

584 and self.exception_check != '+':

585 error(self.pos,

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

587 else:

588 if self.exception_value:

589 self.exception_value.analyse_const_expression(env)

590 if self.exception_check == '+':

591 self.exception_value.analyse_types(env)

592 exc_val_type = self.exception_value.type

593 if not exc_val_type.is_error and \

594 not exc_val_type.is_pyobject and \

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

596 error(self.exception_value.pos,

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

598 exc_val = self.exception_value

599 else:

600 self.exception_value = self.exception_value.coerce_to(return_type, env)

601 if self.exception_value.analyse_const_expression(env):

602 exc_val = self.exception_value.get_constant_c_result_code()

603 if exc_val is None:

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

605 self.exception_value.__class__.__name__)

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

607 error(self.exception_value.pos,

608 "Exception value incompatible with function return type")

609 exc_check = self.exception_check

610 if return_type.is_array:

611 error(self.pos,

612 "Function cannot return an array")

613 if return_type.is_cfunction:

614 error(self.pos,

615 "Function cannot return a function")

616 func_type = PyrexTypes.CFuncType(

617 return_type, func_type_args, self.has_varargs,

618 optional_arg_count = self.optional_arg_count,

619 exception_value = exc_val, exception_check = exc_check,

620 calling_convention = self.base.calling_convention,

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

622 if self.optional_arg_count:

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

624 callspec = env.directives['callspec']

625 if callspec:

626 current = func_type.calling_convention

627 if current and current != callspec:

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

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

630 func_type.calling_convention = callspec

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

632

633

634 class CArgDeclNode(Node):

635 # Item in a function declaration argument list.

636 #

637 # base_type CBaseTypeNode

638 # declarator CDeclaratorNode

639 # not_none boolean Tagged with 'not None'

640 # or_none boolean Tagged with 'or None'

641 # accept_none boolean Resolved boolean for not_none/or_none

642 # default ExprNode or None

643 # default_value PyObjectConst constant for default value

644 # annotation ExprNode or None Py3 function arg annotation

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

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

647 # is_kw_only boolean Is a keyword-only argument

648

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

650

651 is_self_arg = 0

652 is_type_arg = 0

653 is_generic = 1

654 type = None

655 name_declarator = None

656 default_value = None

657 annotation = None

658

659 def analyse(self, env, nonempty = 0, is_self_arg = False):

660 if is_self_arg:

661 self.base_type.is_self_arg = self.is_self_arg = True

662 if self.type is None:

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

664 # We fix that here.

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

666 if nonempty:

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

668 self.base_type.name = None

669 self.base_type.is_basic_c_type = False

670 could_be_name = True

671 else:

672 could_be_name = False

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

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

675 self.declarator.name = self.base_type.arg_name

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

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

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

679 if (base_type.is_array

680 and isinstance(self.base_type, TemplatedTypeNode)

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

682 declarator = self.declarator

683 while isinstance(declarator.base, CArrayDeclaratorNode):

684 declarator = declarator.base

685 declarator.base = self.base_type.array_declarator

686 base_type = base_type.base_type

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

688 else:

689 return self.name_declarator, self.type

690

691 def calculate_default_value_code(self, code):

692 if self.default_value is None:

693 if self.default:

694 if self.default.is_literal:

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

696 self.default.generate_evaluation_code(code)

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

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

699 return self.default_value

700

701 def annotate(self, code):

702 if self.default:

703 self.default.annotate(code)

704

705

706 class CBaseTypeNode(Node):

707 # Abstract base class for C base type nodes.

708 #

709 # Processing during analyse_declarations phase:

710 #

711 # analyse

712 # Returns the type.

713

714 pass

715

716 def analyse_as_type(self, env):

717 return self.analyse(env)

718

719 class CAnalysedBaseTypeNode(Node):

720 # type type

721

722 child_attrs = []

723

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

725 return self.type

726

727 class CSimpleBaseTypeNode(CBaseTypeNode):

728 # name string

729 # module_path [string] Qualifying name components

730 # is_basic_c_type boolean

731 # signed boolean

732 # longness integer

733 # complex boolean

734 # is_self_arg boolean Is self argument of C method

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

736

737 child_attrs = []

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

739

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

741 # Return type descriptor.

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

743 type = None

744 if self.is_basic_c_type:

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

746 if not type:

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

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

749 type = py_object_type

750 elif self.name is None:

751 if self.is_self_arg and env.is_c_class_scope:

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

753 type = env.parent_type

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

755 ## type = Builtin.type_type

756 else:

757 type = py_object_type

758 else:

759 if self.module_path:

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

761 else:

762 scope = env

763 if scope:

764 if scope.is_c_class_scope:

765 scope = scope.global_scope()

766 entry = scope.lookup(self.name)

767 if entry and entry.is_type:

768 type = entry.type

769 elif could_be_name:

770 if self.is_self_arg and env.is_c_class_scope:

771 type = env.parent_type

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

773 ## type = Builtin.type_type

774 else:

775 type = py_object_type

776 self.arg_name = self.name

777 else:

778 if self.templates:

779 if not self.name in self.templates:

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

781 type = PyrexTypes.TemplatePlaceholderType(self.name)

782 else:

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

784 if self.complex:

785 if not type.is_numeric or type.is_complex:

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

787 type = PyrexTypes.CComplexType(type)

788 type.create_declaration_utility_code(env)

789 elif type is Builtin.complex_type:

790 # Special case: optimise builtin complex type into C's

791 # double complex. The parser cannot do this (as for the

792 # normal scalar types) as the user may have redeclared the

793 # 'complex' type. Testing for the exact type here works.

794 type = PyrexTypes.c_double_complex_type

795 type.create_declaration_utility_code(env)

796 self.complex = True

797 if type:

798 return type

799 else:

800 return PyrexTypes.error_type

801

802 class CNestedBaseTypeNode(CBaseTypeNode):

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

804

805 # name string

806 # base_type CBaseTypeNode

807

808 child_attrs = ['base_type']

809

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

811 base_type = self.base_type.analyse(env)

812 if base_type is PyrexTypes.error_type:

813 return PyrexTypes.error_type

814 if not base_type.is_cpp_class:

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

816 return PyrexTypes.error_type

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

818 if not type_entry or not type_entry.is_type:

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

820 return PyrexTypes.error_type

821 return type_entry.type

822

823 class TemplatedTypeNode(CBaseTypeNode):

824 # After parsing:

825 # positional_args [ExprNode] List of positional arguments

826 # keyword_args DictNode Keyword arguments

827 # base_type_node CBaseTypeNode

828

829 # After analysis:

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

831

832

833 child_attrs = ["base_type_node", "positional_args",

834 "keyword_args", "dtype_node"]

835

836 dtype_node = None

837

838 name = None

839

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

841 if base_type is None:

842 base_type = self.base_type_node.analyse(env)

843 if base_type.is_error: return base_type

844

845 if base_type.is_cpp_class:

846 # Templated class

847 if self.keyword_args and self.keyword_args.key_value_pairs:

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

849 self.type = PyrexTypes.error_type

850 else:

851 template_types = []

852 for template_node in self.positional_args:

853 type = template_node.analyse_as_type(env)

854 if type is None:

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

856 return error_type

857 template_types.append(type)

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

859

860 elif base_type.is_pyobject:

861 # Buffer

862 import Buffer

863

864 options = Buffer.analyse_buffer_options(

865 self.pos,

866 env,

867 self.positional_args,

868 self.keyword_args,

869 base_type.buffer_defaults)

870

871 if sys.version_info[0] < 3:

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

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

874 for name, value in options.items() ])

875

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

877

878 else:

879 # Array

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

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

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

883 self.type = PyrexTypes.error_type

884 else:

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

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

887 if not self.positional_args:

888 dimension = None

889 else:

890 dimension = self.positional_args[0]

891 self.array_declarator = CArrayDeclaratorNode(self.pos,

892 base = empty_declarator,

893 dimension = dimension)

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

895

896 return self.type

897

898 class CComplexBaseTypeNode(CBaseTypeNode):

899 # base_type CBaseTypeNode

900 # declarator CDeclaratorNode

901

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

903

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

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

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

907 return type

908

909

910 class CVarDefNode(StatNode):

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

912 #

913 # visibility 'private' or 'public' or 'extern'

914 # base_type CBaseTypeNode

915 # declarators [CDeclaratorNode]

916 # in_pxd boolean

917 # api boolean

918

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

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

921

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

923

924 decorators = None

925 directive_locals = {}

926

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

928 if not dest_scope:

929 dest_scope = env

930 self.dest_scope = dest_scope

931 base_type = self.base_type.analyse(env)

932

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

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

935 # a property; made in AnalyseDeclarationsTransform).

936 if (dest_scope.is_c_class_scope

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

938 need_property = True

939 else:

940 need_property = False

941 visibility = self.visibility

942

943 for declarator in self.declarators:

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

945 if not type.is_complete():

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

947 error(declarator.pos,

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

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

950 error(declarator.pos,

951 "Python object cannot be declared extern")

952 name = name_declarator.name

953 cname = name_declarator.cname

954 if name == '':

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

956 return

957 if type.is_cfunction:

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

959 cname = cname, visibility = self.visibility, in_pxd = self.in_pxd,

960 api = self.api)

961 if entry is not None:

962 entry.directive_locals = self.directive_locals

963 else:

964 if self.directive_locals:

965 error(self.pos, "Decorators can only be followed by functions")

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

967 error(self.pos,

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

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

970 cname = cname, visibility = visibility, is_cdef = 1)

971 entry.needs_property = need_property

972

973

974 class CStructOrUnionDefNode(StatNode):

975 # name string

976 # cname string or None

977 # kind "struct" or "union"

978 # typedef_flag boolean

979 # visibility "public" or "private"

980 # in_pxd boolean

981 # attributes [CVarDefNode] or None

982 # entry Entry

983 # packed boolean

984

985 child_attrs = ["attributes"]

986

987 def analyse_declarations(self, env):

988 scope = None

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

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

991 if self.attributes is not None:

992 scope = StructOrUnionScope(self.name)

993 self.entry = env.declare_struct_or_union(

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

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

996 if self.attributes is not None:

997 if self.in_pxd and not env.in_cinclude:

998 self.entry.defined_in_pxd = 1

999 for attr in self.attributes:

1000 attr.analyse_declarations(env, scope)

1001 if self.visibility != 'extern':

1002 need_typedef_indirection = False

1003 for attr in scope.var_entries:

1004 type = attr.type

1005 while type.is_array:

1006 type = type.base_type

1007 if type == self.entry.type:

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

1009 if self.typedef_flag:

1010 while type.is_ptr:

1011 type = type.base_type

1012 if type == self.entry.type:

1013 need_typedef_indirection = True

1014 if need_typedef_indirection:

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

1016 struct_entry = self.entry

1017 self.entry = env.declare_typedef(

1018 self.name, struct_entry.type, self.pos,

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

1020 struct_entry.type.typedef_flag = False

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

1022 struct_entry.cname = struct_entry.type.cname = \

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

1024

1025 def analyse_expressions(self, env):

1026 pass

1027

1028 def generate_execution_code(self, code):

1029 pass

1030

1031

1032 class CppClassNode(CStructOrUnionDefNode):

1033

1034 # name string

1035 # cname string or None

1036 # visibility "extern"

1037 # in_pxd boolean

1038 # attributes [CVarDefNode] or None

1039 # entry Entry

1040 # base_classes [string]

1041 # templates [string] or None

1042

1043 def analyse_declarations(self, env):

1044 scope = None

1045 if self.attributes is not None:

1046 scope = CppClassScope(self.name, env)

1047 base_class_types = []

1048 for base_class_name in self.base_classes:

1049 base_class_entry = env.lookup(base_class_name)

1050 if base_class_entry is None:

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

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

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

1054 else:

1055 base_class_types.append(base_class_entry.type)

1056 if self.templates is None:

1057 template_types = None

1058 else:

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

1060 self.entry = env.declare_cpp_class(

1061 self.name, scope, self.pos,

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

1063 self.entry.is_cpp_class = 1

1064 if self.attributes is not None:

1065 if self.in_pxd and not env.in_cinclude:

1066 self.entry.defined_in_pxd = 1

1067 for attr in self.attributes:

1068 attr.analyse_declarations(scope)

1069

1070 class CEnumDefNode(StatNode):

1071 # name string or None

1072 # cname string or None

1073 # items [CEnumDefItemNode]

1074 # typedef_flag boolean

1075 # visibility "public" or "private"

1076 # in_pxd boolean

1077 # entry Entry

1078

1079 child_attrs = ["items"]

1080

1081 def analyse_declarations(self, env):

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

1083 cname = self.cname, typedef_flag = self.typedef_flag,

1084 visibility = self.visibility)

1085 if self.items is not None:

1086 if self.in_pxd and not env.in_cinclude:

1087 self.entry.defined_in_pxd = 1

1088 for item in self.items:

1089 item.analyse_declarations(env, self.entry)

1090

1091 def analyse_expressions(self, env):

1092 pass

1093

1094 def generate_execution_code(self, code):

1095 if self.visibility == 'public':

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

1097 for item in self.entry.enum_values:

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

1099 temp,

1100 item.cname,

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

1102 code.put_gotref(temp)

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

1104 Naming.module_cname,

1105 item.name,

1106 temp,

1107 code.error_goto(item.pos)))

1108 code.put_decref_clear(temp, PyrexTypes.py_object_type)

1109 code.funcstate.release_temp(temp)

1110

1111

1112 class CEnumDefItemNode(StatNode):

1113 # name string

1114 # cname string or None

1115 # value ExprNode or None

1116

1117 child_attrs = ["value"]

1118

1119 def analyse_declarations(self, env, enum_entry):

1120 if self.value:

1121 self.value.analyse_const_expression(env)

1122 if not self.value.type.is_int:

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

1124 self.value.analyse_const_expression(env)

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

1126 self.value, self.pos, cname = self.cname,

1127 visibility = enum_entry.visibility)

1128 enum_entry.enum_values.append(entry)

1129

1130

1131 class CTypeDefNode(StatNode):

1132 # base_type CBaseTypeNode

1133 # declarator CDeclaratorNode

1134 # visibility "public" or "private"

1135 # in_pxd boolean

1136

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

1138

1139 def analyse_declarations(self, env):

1140 base = self.base_type.analyse(env)

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

1142 name = name_declarator.name

1143 cname = name_declarator.cname

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

1145 cname = cname, visibility = self.visibility)

1146 if self.in_pxd and not env.in_cinclude:

1147 entry.defined_in_pxd = 1

1148

1149 def analyse_expressions(self, env):

1150 pass

1151 def generate_execution_code(self, code):

1152 pass

1153

1154

1155 class FuncDefNode(StatNode, BlockNode):

1156 # Base class for function definition nodes.

1157 #

1158 # return_type PyrexType

1159 # #filename string C name of filename string const

1160 # entry Symtab.Entry

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

1162 # needs_outer_scope boolean Whether or not this function requires outer scope

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

1164

1165 py_func = None

1166 assmt = None

1167 needs_closure = False

1168 needs_outer_scope = False

1169 modifiers = []

1170

1171 def analyse_default_values(self, env):

1172 genv = env.global_scope()

1173 default_seen = 0

1174 for arg in self.args:

1175 if arg.default:

1176 default_seen = 1

1177 if arg.is_generic:

1178 arg.default.analyse_types(env)

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

1180 else:

1181 error(arg.pos,

1182 "This argument cannot have a default value")

1183 arg.default = None

1184 elif arg.kw_only:

1185 default_seen = 1

1186 elif default_seen:

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

1188

1189 def need_gil_acquisition(self, lenv):

1190 return 0

1191

1192 def create_local_scope(self, env):

1193 genv = env

1194 while genv.is_py_class_scope or genv.is_c_class_scope:

1195 genv = genv.outer_scope

1196 if self.needs_closure:

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

1198 outer_scope = genv,

1199 scope_name=self.entry.cname)

1200 else:

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

1202 outer_scope=genv,

1203 parent_scope=env)

1204 lenv.return_type = self.return_type

1205 type = self.entry.type

1206 if type.is_cfunction:

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

1208 self.local_scope = lenv

1209 lenv.directives = env.directives

1210 return lenv

1211

1212 def generate_function_definitions(self, env, code):

1213 import Buffer

1214

1215 lenv = self.local_scope

1216 if lenv.is_closure_scope and not lenv.is_passthrough:

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

1218 Naming.outer_scope_cname)

1219 else:

1220 outer_scope_cname = Naming.outer_scope_cname

1221 lenv.mangle_closure_cnames(outer_scope_cname)

1222 # Generate closure function definitions

1223 self.body.generate_function_definitions(lenv, code)

1224 # generate lambda function definitions

1225 self.generate_lambda_definitions(lenv, code)

1226

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

1228 self.entry.scope.is_c_class_scope)

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

1230 self.entry.scope.is_c_class_scope)

1231 is_buffer_slot = is_getbuffer_slot or is_releasebuffer_slot

1232 if is_buffer_slot:

1233 if 'cython_unused' not in self.modifiers:

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

1235

1236 preprocessor_guard = None

1237 if self.entry.is_special and not is_buffer_slot:

1238 slot = TypeSlots.method_name_to_slot.get(self.entry.name)

1239 if slot:

1240 preprocessor_guard = slot.preprocessor_guard_code()

1241 if (self.entry.name == '__long__' and

1242 not self.entry.scope.lookup_here('__int__')):

1243 preprocessor_guard = None

1244

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

1246 if profile:

1247 if lenv.nogil:

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

1249 code.globalstate.use_utility_code(profile_utility_code)

1250

1251 # Generate C code for header and body of function

1252 code.enter_cfunc_scope()

1253 code.return_from_error_cleanup_label = code.new_label()

1254

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

1256 code.mark_pos(self.pos)

1257 self.generate_cached_builtins_decls(lenv, code)

1258 # ----- Function header

1259 code.putln("")

1260

1261 if preprocessor_guard:

1262 code.putln(preprocessor_guard)

1263

1264 with_pymethdef = self.needs_assignment_synthesis(env, code)

1265 if self.py_func:

1266 self.py_func.generate_function_header(code,

1267 with_pymethdef = with_pymethdef,

1268 proto_only=True)

1269 self.generate_function_header(code,

1270 with_pymethdef = with_pymethdef)

1271 # ----- Local variable declarations

1272 # Find function scope

1273 cenv = env

1274 while cenv.is_py_class_scope or cenv.is_c_class_scope:

1275 cenv = cenv.outer_scope

1276 if self.needs_closure:

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

1278 code.putln(";")

1279 elif self.needs_outer_scope:

1280 if lenv.is_passthrough:

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

1282 code.putln(";")

1283 code.put(cenv.scope_class.type.declaration_code(Naming.outer_scope_cname))

1284 code.putln(";")

1285 self.generate_argument_declarations(lenv, code)

1286 for entry in lenv.var_entries:

1287 if not entry.in_closure:

1288 code.put_var_declaration(entry)

1289 init = ""

1290 if not self.return_type.is_void:

1291 if self.return_type.is_pyobject:

1292 init = " = NULL"

1293 code.putln(

1294 "%s%s;" %

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

1296 init))

1297 tempvardecl_code = code.insertion_point()

1298 self.generate_keyword_list(code)

1299 if profile:

1300 code.put_trace_declarations()

1301 # ----- Extern library function declarations

1302 lenv.generate_library_function_declarations(code)

1303 # ----- GIL acquisition

1304 acquire_gil = self.acquire_gil

1305 if acquire_gil:

1306 env.use_utility_code(force_init_threads_utility_code)

1307 code.putln("#ifdef WITH_THREAD")

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

1309 code.putln("#endif")

1310 # ----- set up refnanny

1311 if not lenv.nogil:

1312 code.put_setup_refcount_context(self.entry.name)

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

1314 if is_getbuffer_slot:

1315 self.getbuffer_init(code)

1316 # ----- Create closure scope object

1317 if self.needs_closure:

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

1319 Naming.cur_scope_cname,

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

1321 lenv.scope_class.type.typeptr_cname,

1322 lenv.scope_class.type.typeptr_cname,

1323 Naming.empty_tuple))

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

1325 if is_getbuffer_slot:

1326 self.getbuffer_error_cleanup(code)

1327 if not lenv.nogil:

1328 code.put_finish_refcount_context()

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

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

1331 code.putln("}")

1332 code.put_gotref(Naming.cur_scope_cname)

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

1334 if self.needs_outer_scope:

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

1336 outer_scope_cname,

1337 cenv.scope_class.type.declaration_code(''),

1338 Naming.self_cname))

1339 if lenv.is_passthrough:

1340 code.putln("%s = %s;" % (Naming.cur_scope_cname, outer_scope_cname));

1341 elif self.needs_closure:

1342 # inner closures own a reference to their outer parent

1343 code.put_incref(outer_scope_cname, cenv.scope_class.type)

1344 code.put_giveref(outer_scope_cname)

1345 # ----- Trace function call

1346 if profile:

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

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

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

1350 # ----- Fetch arguments

1351 self.generate_argument_parsing_code(env, code)

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

1353 # incref it to properly keep track of refcounts.

1354 for entry in lenv.arg_entries:

1355 if entry.type.is_pyobject:

1356 if entry.assignments and not entry.in_closure:

1357 code.put_var_incref(entry)

1358 # ----- Initialise local variables

1359 for entry in lenv.var_entries:

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

1361 code.put_init_var_to_py_none(entry)

1362 # ----- Initialise local buffer auxiliary variables

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

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

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

1366 entry.buffer_aux.buffer_info_var.cname)

1367 # ----- Check and convert arguments

1368 self.generate_argument_type_tests(code)

1369 # ----- Acquire buffer arguments

1370 for entry in lenv.arg_entries:

1371 if entry.type.is_buffer:

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

1373

1374 # -------------------------

1375 # ----- Function body -----

1376 # -------------------------

1377 self.body.generate_execution_code(code)

1378

1379 # ----- Default return value

1380 code.putln("")

1381 if self.return_type.is_pyobject:

1382 #if self.return_type.is_extension_type:

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

1384 #else:

1385 lhs = Naming.retval_cname

1386 code.put_init_to_py_none(lhs, self.return_type)

1387 else:

1388 val = self.return_type.default_value

1389 if val:

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

1391 # ----- Error cleanup

1392 if code.error_label in code.labels_used:

1393 code.put_goto(code.return_label)

1394 code.put_label(code.error_label)

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

1396 code.put_xdecref(cname, type)

1397

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

1399 # so need to save and restore error state

1400 buffers_present = len(lenv.buffer_entries) > 0

1401 if buffers_present:

1402 code.globalstate.use_utility_code(restore_exception_utility_code)

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

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

1405 for entry in lenv.buffer_entries:

1406 Buffer.put_release_buffer_code(code, entry)

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

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

1409

1410 err_val = self.error_value()

1411 exc_check = self.caller_will_check_exceptions()

1412 if err_val is not None or exc_check:

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

1414 # code.globalstate.use_utility_code(get_exception_tuple_utility_code)

1415 # code.put_trace_exception()

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

1417 else:

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

1419 % self.entry.qualified_name, 0)

1420 code.putln(

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

1422 self.entry.qualified_name)

1423 env.use_utility_code(unraisable_exception_utility_code)

1424 env.use_utility_code(restore_exception_utility_code)

1425 default_retval = self.return_type.default_value

1426 if err_val is None and default_retval:

1427 err_val = default_retval

1428 if err_val is not None:

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

1430

1431 if is_getbuffer_slot:

1432 self.getbuffer_error_cleanup(code)

1433

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

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

1436 # whether this section is used.

1437 if buffers_present or is_getbuffer_slot:

1438 code.put_goto(code.return_from_error_cleanup_label)

1439

1440

1441 # ----- Non-error return cleanup

1442 code.put_label(code.return_label)

1443 for entry in lenv.buffer_entries:

1444 if entry.used:

1445 Buffer.put_release_buffer_code(code, entry)

1446 if is_getbuffer_slot:

1447 self.getbuffer_normal_cleanup(code)

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

1449 code.put_label(code.return_from_error_cleanup_label)

1450 if not Options.init_local_none:

1451 for entry in lenv.var_entries:

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

1453 entry.xdecref_cleanup = 1

1454

1455 for entry in lenv.var_entries:

1456 if entry.type.is_pyobject:

1457 if entry.used and not entry.in_closure:

1458 code.put_var_decref(entry)

1459 elif entry.in_closure and self.needs_closure:

1460 code.put_giveref(entry.cname)

1461 # Decref any increfed args

1462 for entry in lenv.arg_entries:

1463 if entry.type.is_pyobject:

1464 if entry.in_closure:

1465 code.put_var_giveref(entry)

1466 elif entry.assignments:

1467 code.put_var_decref(entry)

1468 if self.needs_closure:

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

1470

1471 # ----- Return

1472 # This code is duplicated in ModuleNode.generate_module_init_func

1473 if not lenv.nogil:

1474 default_retval = self.return_type.default_value

1475 err_val = self.error_value()

1476 if err_val is None and default_retval:

1477 err_val = default_retval

1478 if self.return_type.is_pyobject:

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

1480

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

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

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

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

1485 Naming.retval_cname, Naming.retval_cname))

1486

1487 if profile:

1488 if self.return_type.is_pyobject:

1489 code.put_trace_return(Naming.retval_cname)

1490 else:

1491 code.put_trace_return("Py_None")

1492 if not lenv.nogil:

1493 code.put_finish_refcount_context()

1494

1495 if acquire_gil:

1496 code.putln("#ifdef WITH_THREAD")

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

1498 code.putln("#endif")

1499

1500 if not self.return_type.is_void:

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

1502

1503 code.putln("}")

1504

1505 if preprocessor_guard:

1506 code.putln("#endif /*!(%s)*/" % preprocessor_guard)

1507

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

1509 tempvardecl_code.put_temp_declarations(code.funcstate)

1510 # ----- Python version

1511 code.exit_cfunc_scope()

1512 if self.py_func:

1513 self.py_func.generate_function_definitions(env, code)

1514 self.generate_wrapper_functions(code)

1515

1516 def declare_argument(self, env, arg):

1517 if arg.type.is_void:

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

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

1520 error(arg.pos,

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

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

1523

1524 def generate_arg_type_test(self, arg, code):

1525 # Generate type test for one argument.

1526 if arg.type.typeobj_is_available():

1527 code.globalstate.use_utility_code(arg_type_test_utility_code)

1528 typeptr_cname = arg.type.typeptr_cname

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

1530 code.putln(

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

1532 arg_code,

1533 typeptr_cname,

1534 arg.accept_none,

1535 arg.name,

1536 arg.type.is_builtin_type,

1537 code.error_goto(arg.pos)))

1538 else:

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

1540 "without type object name specification")

1541

1542 def generate_arg_none_check(self, arg, code):

1543 # Generate None check for one argument.

1544 code.globalstate.use_utility_code(arg_type_test_utility_code)

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

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

1547 arg.name,

1548 code.error_goto(arg.pos)))

1549 code.putln('}')

1550

1551 def generate_wrapper_functions(self, code):

1552 pass

1553

1554 def generate_execution_code(self, code):

1555 # Evaluate and store argument default values

1556 for arg in self.args:

1557 default = arg.default

1558 if default:

1559 if not default.is_literal:

1560 default.generate_evaluation_code(code)

1561 default.make_owned_reference(code)

1562 result = default.result_as(arg.type)

1563 code.putln(

1564 "%s = %s;" % (

1565 arg.calculate_default_value_code(code),

1566 result))

1567 if arg.type.is_pyobject:

1568 code.put_giveref(default.result())

1569 default.generate_post_assignment_code(code)

1570 default.free_temps(code)

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

1572 if self.assmt:

1573 self.assmt.generate_execution_code(code)

1574

1575 #

1576 # Special code for the __getbuffer__ function

1577 #

1578 def getbuffer_init(self, code):

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

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

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

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

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

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

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

1586

1587 def getbuffer_error_cleanup(self, code):

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

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

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

1591 (info, info))

1592

1593 def getbuffer_normal_cleanup(self, code):

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

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

1596 code.put_gotref("Py_None")

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

1598 code.putln("}")

1599

1600 class CFuncDefNode(FuncDefNode):

1601 # C function definition.

1602 #

1603 # modifiers ['inline']

1604 # visibility 'private' or 'public' or 'extern'

1605 # base_type CBaseTypeNode

1606 # declarator CDeclaratorNode

1607 # body StatListNode

1608 # api boolean

1609 # decorators [DecoratorNode] list of decorators

1610 #

1611 # with_gil boolean Acquire GIL around body

1612 # type CFuncType

1613 # py_func wrapper for calling from Python

1614 # overridable whether or not this is a cpdef function

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

1616

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

1618

1619 inline_in_pxd = False

1620 decorators = None

1621 directive_locals = {}

1622

1623 def unqualified_name(self):

1624 return self.entry.name

1625

1626 def analyse_declarations(self, env):

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

1628 base_type = self.base_type.analyse(env)

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

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

1631 if not type.is_cfunction:

1632 error(self.pos,

1633 "Suite attached to non-function declaration")

1634 # Remember the actual type according to the function header

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

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

1637 # from the base type of an extension type.

1638 self.type = type

1639 type.is_overridable = self.overridable

1640 declarator = self.declarator

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

1642 declarator = declarator.base

1643 self.args = declarator.args

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

1645 formal_arg.type = type_arg.type

1646 formal_arg.name = type_arg.name

1647 formal_arg.cname = type_arg.cname

1648 name = name_declarator.name

1649 cname = name_declarator.cname

1650 self.entry = env.declare_cfunction(

1651 name, type, self.pos,

1652 cname = cname, visibility = self.visibility,

1653 defining = self.body is not None,

1654 api = self.api, modifiers = self.modifiers)

1655 self.entry.inline_func_in_pxd = self.inline_in_pxd

1656 self.return_type = type.return_type

1657

1658 if self.overridable and not env.is_module_scope:

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

1660 # An error will be produced in the cdef function

1661 self.overridable = False

1662

1663 if self.overridable:

1664 import ExprNodes

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

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

1667 name = self.entry.name,

1668 args = self.args,

1669 star_arg = None,

1670 starstar_arg = None,

1671 doc = self.doc,

1672 body = py_func_body,

1673 is_wrapper = 1)

1674 self.py_func.is_module_scope = env.is_module_scope

1675 self.py_func.analyse_declarations(env)

1676 self.entry.as_variable = self.py_func.entry

1677 # Reset scope entry the above cfunction

1678 env.entries[name] = self.entry

1679 if not env.is_module_scope or Options.lookup_module_cpdef:

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

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

1682 self.create_local_scope(env)

1683

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

1685 import ExprNodes

1686 args = self.type.args

1687 if omit_optional_args:

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

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

1690 if is_module_scope:

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

1692 else:

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

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

1695 skip_dispatch = not is_module_scope or Options.lookup_module_cpdef

1696 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)

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

1698

1699 def declare_arguments(self, env):

1700 for arg in self.type.args:

1701 if not arg.name:

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

1703 self.declare_argument(env, arg)

1704

1705 def need_gil_acquisition(self, lenv):

1706 return self.type.with_gil

1707

1708 def nogil_check(self, env):

1709 type = self.type

1710 with_gil = type.with_gil

1711 if type.nogil and not with_gil:

1712 if type.return_type.is_pyobject:

1713 error(self.pos,

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

1715 for entry in self.local_scope.var_entries:

1716 if entry.type.is_pyobject:

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

1718

1719 def analyse_expressions(self, env):

1720 self.local_scope.directives = env.directives

1721 if self.py_func is not None:

1722 # this will also analyse the default values

1723 self.py_func.analyse_expressions(env)

1724 else:

1725 self.analyse_default_values(env)

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

1727

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

1729 return False

1730

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

1732 arg_decls = []

1733 type = self.type

1734 visibility = self.entry.visibility

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

1736 arg_decls.append(arg.declaration_code())

1737 if with_dispatch and self.overridable:

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

1739 if type.optional_arg_count and with_opt_args:

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

1741 if type.has_varargs:

1742 arg_decls.append("...")

1743 if not arg_decls:

1744 arg_decls = ["void"]

1745 if cname is None:

1746 cname = self.entry.func_cname

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

1748 if visibility == 'public':

1749 dll_linkage = "DL_EXPORT"

1750 else:

1751 dll_linkage = None

1752 header = self.return_type.declaration_code(entity,

1753 dll_linkage = dll_linkage)

1754 if visibility == 'extern':

1755 storage_class = "%s " % Naming.extern_c_macro

1756 elif visibility == 'public':

1757 storage_class = ""

1758 else:

1759 storage_class = "static "

1760 if 'inline' in self.modifiers:

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

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

1763 storage_class,

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

1765 header))

1766

1767 def generate_argument_declarations(self, env, code):

1768 for arg in self.args:

1769 if arg.default:

1770 result = arg.calculate_default_value_code(code)

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

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

1773

1774 def generate_keyword_list(self, code):

1775 pass

1776

1777 def generate_argument_parsing_code(self, env, code):

1778 i = 0

1779 if self.type.optional_arg_count:

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

1781 for arg in self.args:

1782 if arg.default:

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

1784 declarator = arg.declarator

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

1786 declarator = declarator.base

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

1788 i += 1

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

1790 code.putln('}')

1791 code.putln('}')

1792

1793 def generate_argument_conversion_code(self, code):

1794 pass

1795

1796 def generate_argument_type_tests(self, code):

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

1798 # class is a supertype of the declared type.

1799 for arg in self.type.args:

1800 if arg.needs_type_test:

1801 self.generate_arg_type_test(arg, code)

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

1803 self.generate_arg_none_check(arg, code)

1804

1805 def error_value(self):

1806 if self.return_type.is_pyobject:

1807 return "0"

1808 else:

1809 #return None

1810 return self.entry.type.exception_value

1811

1812 def caller_will_check_exceptions(self):

1813 return self.entry.type.exception_check

1814

1815 def generate_wrapper_functions(self, code):

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

1817 # wrappers to put in the slots here.

1818 k = 0

1819 entry = self.entry

1820 func_type = entry.type

1821 while entry.prev_entry is not None:

1822 k += 1

1823 entry = entry.prev_entry

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

1825 code.putln()

1826 self.generate_function_header(code,

1827 0,

1828 with_dispatch = entry.type.is_overridable,

1829 with_opt_args = entry.type.optional_arg_count,

1830 cname = entry.func_cname)

1831 if not self.return_type.is_void:

1832 code.put('return ')

1833 args = self.type.args

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

1835 if entry.type.is_overridable:

1836 arglist.append(Naming.skip_dispatch_cname)

1837 elif func_type.is_overridable:

1838 arglist.append('0')

1839 if entry.type.optional_arg_count:

1840 arglist.append(Naming.optional_args_cname)

1841 elif func_type.optional_arg_count:

1842 arglist.append('NULL')

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

1844 code.putln('}')

1845

1846

1847 class PyArgDeclNode(Node):

1848 # Argument which must be a Python object (used

1849 # for * and ** arguments).

1850 #

1851 # name string

1852 # entry Symtab.Entry

1853 # annotation ExprNode or None Py3 argument annotation

1854 child_attrs = []

1855

1856 def generate_function_definitions(self, env, code):

1857 self.entry.generate_function_definitions(env, code)

1858

1859 class DecoratorNode(Node):

1860 # A decorator

1861 #

1862 # decorator NameNode or CallNode or AttributeNode

1863 child_attrs = ['decorator']

1864

1865

1866 class DefNode(FuncDefNode):

1867 # A Python function definition.

1868 #

1869 # name string the Python name of the function

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

1871 # decorators [DecoratorNode] list of decorators

1872 # args [CArgDeclNode] formal arguments

1873 # star_arg PyArgDeclNode or None * argument

1874 # starstar_arg PyArgDeclNode or None ** argument

1875 # doc EncodedString or None

1876 # body StatListNode

1877 # return_type_annotation

1878 # ExprNode or None the Py3 return type annotation

1879 #

1880 # The following subnode is constructed internally

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

1882 #

1883 # assmt AssignmentNode Function construction/assignment

1884

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

1886

1887 lambda_name = None

1888 assmt = None

1889 num_kwonly_args = 0

1890 num_required_kw_args = 0

1891 reqd_kw_flags_cname = "0"

1892 is_wrapper = 0

1893 decorators = None

1894 return_type_annotation = None

1895 entry = None

1896 acquire_gil = 0

1897 self_in_stararg = 0

1898

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

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

1901 k = rk = r = 0

1902 for arg in self.args:

1903 if arg.kw_only:

1904 k += 1

1905 if not arg.default:

1906 rk += 1

1907 if not arg.default:

1908 r += 1

1909 self.num_kwonly_args = k

1910 self.num_required_kw_args = rk

1911 self.num_required_args = r

1912

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

1914 if self.star_arg:

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

1916 if self.starstar_arg:

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

1918 if cfunc is None:

1919 cfunc_args = []

1920 for formal_arg in self.args:

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

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

1923 cname = None,

1924 type = py_object_type,

1925 pos = formal_arg.pos))

1926 cfunc_type = PyrexTypes.CFuncType(return_type = py_object_type,

1927 args = cfunc_args,

1928 has_varargs = False,

1929 exception_value = None,

1930 exception_check = False,

1931 nogil = False,

1932 with_gil = False,

1933 is_overridable = True)

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

1935 else:

1936 if scope is None:

1937 scope = cfunc.scope

1938 cfunc_type = cfunc.type

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

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

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

1942 for i, (formal_arg, type_arg) in enumerate(zip(self.args, cfunc_type.args)):

1943 name_declarator, type = formal_arg.analyse(scope, nonempty=1,

1944 is_self_arg = (i == 0 and scope.is_c_class_scope))

1945 if type is None or type is PyrexTypes.py_object_type:

1946 formal_arg.type = type_arg.type

1947 formal_arg.name_declarator = name_declarator

1948 import ExprNodes

1949 if cfunc_type.exception_value is None:

1950 exception_value = None

1951 else:

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

1953 declarator = CFuncDeclaratorNode(self.pos,

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

1955 args = self.args,

1956 has_varargs = False,

1957 exception_check = cfunc_type.exception_check,

1958 exception_value = exception_value,

1959 with_gil = cfunc_type.with_gil,

1960 nogil = cfunc_type.nogil)

1961 return CFuncDefNode(self.pos,

1962 modifiers = [],

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

1964 declarator = declarator,

1965 body = self.body,

1966 doc = self.doc,

1967 overridable = cfunc_type.is_overridable,

1968 type = cfunc_type,

1969 with_gil = cfunc_type.with_gil,

1970 nogil = cfunc_type.nogil,

1971 visibility = 'private',

1972 api = False,

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

1974

1975 def analyse_declarations(self, env):

1976 self.is_classmethod = self.is_staticmethod = False

1977 if self.decorators:

1978 for decorator in self.decorators:

1979 func = decorator.decorator

1980 if func.is_name:

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

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

1983

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

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

1986 self.is_classmethod = False

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

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

1989 self.is_staticmethod = False

1990

1991 if self.name == '__new__' and env.is_py_class_scope:

1992 self.is_staticmethod = 1

1993

1994 self.analyse_argument_types(env)

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

1996 self.declare_lambda_function(env)

1997 else:

1998 self.declare_pyfunction(env)

1999 self.analyse_signature(env)

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

2001 self.create_local_scope(env)

2002

2003 def analyse_argument_types(self, env):

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

2005 allow_none_for_extension_args = env.directives['allow_none_for_extension_args']

2006 for arg in self.args:

2007 if hasattr(arg, 'name'):

2008 type = arg.type

2009 name_declarator = None

2010 else:

2011 base_type = arg.base_type.analyse(env)

2012 name_declarator, type = \

2013 arg.declarator.analyse(base_type, env)

2014 arg.name = name_declarator.name

2015 if arg.name in directive_locals:

2016 type_node = directive_locals[arg.name]

2017 other_type = type_node.analyse_as_type(env)

2018 if other_type is None:

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

2020 elif (type is not PyrexTypes.py_object_type

2021 and not type.same_as(other_type)):

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

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

2024 else:

2025 type = other_type

2026 if name_declarator and name_declarator.cname:

2027 error(self.pos,

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

2029 arg.type = type.as_argument_type()

2030 arg.hdr_type = None

2031 arg.needs_conversion = 0

2032 arg.needs_type_test = 0

2033 arg.is_generic = 1

2034 if arg.type.is_pyobject:

2035 if arg.or_none:

2036 arg.accept_none = True

2037 elif arg.not_none:

2038 arg.accept_none = False

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

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

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

2042 arg.accept_none = True

2043 else:

2044 # default depends on compiler directive

2045 arg.accept_none = allow_none_for_extension_args

2046 else:

2047 # probably just a plain 'object'

2048 arg.accept_none = True

2049 else:

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

2051 if arg.not_none:

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

2053 if arg.or_none:

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

2055

2056 def analyse_signature(self, env):

2057 if self.entry.is_special:

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

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

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

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

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

2063 self.entry.signature = TypeSlots.pyfunction_noargs

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

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

2066 self.entry.signature = TypeSlots.pyfunction_onearg

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

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

2069 self.entry.signature = TypeSlots.unaryfunc

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

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

2072 self.entry.signature = TypeSlots.ibinaryfunc

2073

2074 sig = self.entry.signature

2075 nfixed = sig.num_fixed_args()

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

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

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

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

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

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

2082 self.self_in_stararg = 1

2083 nfixed = 0

2084

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

2086 arg = self.args[i]

2087 arg.is_generic = 0

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

2089 if self.is_classmethod:

2090 arg.is_type_arg = 1

2091 arg.hdr_type = arg.type = Builtin.type_type

2092 else:

2093 arg.is_self_arg = 1

2094 arg.hdr_type = arg.type = env.parent_type

2095 arg.needs_conversion = 0

2096 else:

2097 arg.hdr_type = sig.fixed_arg_type(i)

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

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

2100 arg.needs_type_test = 1

2101 else:

2102 arg.needs_conversion = 1

2103 if arg.needs_conversion:

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

2105 else:

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

2107

2108 if nfixed > len(self.args):

2109 self.bad_signature()

2110 return

2111 elif nfixed < len(self.args):

2112 if not sig.has_generic_args:

2113 self.bad_signature()

2114 for arg in self.args:

2115 if arg.is_generic and \

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

2117 arg.needs_type_test = 1

2118

2119 def bad_signature(self):

2120 sig = self.entry.signature

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

2122 if sig.has_generic_args:

2123 expected_str = expected_str + " or more"

2124 name = self.name

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

2126 desc = "Special method"

2127 else:

2128 desc = "Method"

2129 error(self.pos,

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

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

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

2133

2134 def signature_has_nongeneric_args(self):

2135 argcount = len(self.args)

2136 if argcount == 0 or (

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

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

2139 return 0

2140 return 1

2141

2142 def signature_has_generic_args(self):

2143 return self.entry.signature.has_generic_args

2144

2145 def declare_pyfunction(self, env):

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

2147 name = self.name

2148 entry = env.lookup_here(name)

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

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

2151 entry = env.declare_pyfunction(name, self.pos, allow_redefine=not self.is_wrapper)

2152 self.entry = entry

2153 prefix = env.next_id(env.scope_prefix)

2154

2155 entry.func_cname = \

2156 Naming.pyfunc_prefix + prefix + name

2157 entry.pymethdef_cname = \

2158 Naming.pymethdef_prefix + prefix + name

2159 if Options.docstrings:

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

2161 entry.doc_cname = \

2162 Naming.funcdoc_prefix + prefix + name

2163 if entry.is_special:

2164 if entry.name in TypeSlots.invisible or not entry.doc or (entry.name in '__getattr__' and env.directives['fast_getattr']):

2165 entry.wrapperbase_cname = None

2166 else:

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

2168 else:

2169 entry.doc = None

2170

2171 def declare_lambda_function(self, env):

2172 name = self.name

2173 prefix = env.scope_prefix

2174 func_cname = \

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

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

2177 entry.pymethdef_cname = \

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

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

2180 entry.doc = None

2181 self.entry = entry

2182

2183 def declare_arguments(self, env):

2184 for arg in self.args:

2185 if not arg.name:

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

2187 else:

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

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

2190 if arg.needs_conversion:

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

2192 if arg.type.is_pyobject:

2193 arg.entry.init = "0"

2194 arg.entry.init_to_none = 0

2195 else:

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

2197 arg.entry.used = 1

2198 arg.entry.is_self_arg = arg.is_self_arg

2199 if arg.hdr_type:

2200 if arg.is_self_arg or arg.is_type_arg or \

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

2202 arg.entry.is_declared_generic = 1

2203 self.declare_python_arg(env, self.star_arg)

2204 self.declare_python_arg(env, self.starstar_arg)

2205

2206 def declare_python_arg(self, env, arg):

2207 if arg:

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

2209 type = PyrexTypes.unspecified_type

2210 else:

2211 type = py_object_type

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

2213 entry.used = 1

2214 entry.init = "0"

2215 entry.init_to_none = 0

2216 entry.xdecref_cleanup = 1

2217 arg.entry = entry

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

2219

2220 def analyse_expressions(self, env):

2221 self.local_scope.directives = env.directives

2222 self.analyse_default_values(env)

2223 if self.needs_assignment_synthesis(env):

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

2225 self.synthesize_assignment_node(env)

2226

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

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

2229 if self.entry.is_anonymous:

2230 return True

2231 if env.is_module_scope:

2232 if code is None:

2233 return env.directives['binding']

2234 else:

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

2236 return env.is_py_class_scope or env.is_closure_scope

2237

2238 def synthesize_assignment_node(self, env):

2239 import ExprNodes

2240 genv = env

2241 while genv.is_py_class_scope or genv.is_c_class_scope:

2242 genv = genv.outer_scope

2243

2244 if genv.is_closure_scope:

2245 rhs = ExprNodes.InnerFunctionNode(

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

2247 else:

2248 rhs = ExprNodes.PyCFunctionNode(

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

2250

2251 if env.is_py_class_scope:

2252 if not self.is_staticmethod and not self.is_classmethod:

2253 rhs.binding = True

2254

2255 self.assmt = SingleAssignmentNode(self.pos,

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

2257 rhs = rhs)

2258 self.assmt.analyse_declarations(env)

2259 self.assmt.analyse_expressions(env)

2260

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

2262 arg_code_list = []

2263 sig = self.entry.signature

2264 if sig.has_dummy_arg or self.self_in_stararg:

2265 arg_code_list.append(

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

2267 for arg in self.args:

2268 if not arg.is_generic:

2269 if arg.is_self_arg or arg.is_type_arg:

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

2271 else:

2272 arg_code_list.append(

2273 arg.hdr_type.declaration_code(arg.hdr_cname))

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

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

2276 if sig.has_generic_args:

2277 arg_code_list.append(

2278 "PyObject *%s, PyObject *%s"

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

2280 arg_code = ", ".join(arg_code_list)

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

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

2283 if mf: mf += " "

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

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

2286 if proto_only:

2287 return

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

2289 not self.entry.scope.is_property_scope and

2290 (not self.entry.is_special or self.entry.wrapperbase_cname)):

2291 docstr = self.entry.doc

2292 if docstr.is_unicode:

2293 docstr = docstr.utf8encode()

2294 code.putln(

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

2296 self.entry.doc_cname,

2297 split_string_literal(escape_byte_string(docstr))))

2298 if self.entry.is_special:

2299 code.putln(

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

2301 if with_pymethdef:

2302 code.put(

2303 "static PyMethodDef %s = " %

2304 self.entry.pymethdef_cname)

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

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

2307

2308 def generate_argument_declarations(self, env, code):

2309 for arg in self.args:

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

2311 if arg.needs_conversion:

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

2313 elif not arg.entry.in_closure:

2314 code.put_var_declaration(arg.entry)

2315

2316 def generate_keyword_list(self, code):

2317 if self.signature_has_generic_args() and \

2318 self.signature_has_nongeneric_args():

2319 code.put(

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

2321 Naming.pykwdlist_cname)

2322 for arg in self.args:

2323 if arg.is_generic:

2324 pystring_cname = code.intern_identifier(arg.name)

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

2326 code.putln("0};")

2327

2328 def generate_argument_parsing_code(self, env, code):

2329 # Generate PyArg_ParseTuple call for generic

2330 # arguments, if any.

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

2332 # get rid of unused argument warning

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

2334

2335 old_error_label = code.new_error_label()

2336 our_error_label = code.error_label

2337 end_label = code.new_label("argument_unpacking_done")

2338

2339 has_kwonly_args = self.num_kwonly_args > 0

2340 has_star_or_kw_args = self.star_arg is not None \

2341 or self.starstar_arg is not None or has_kwonly_args

2342

2343 for arg in self.args:

2344 if not arg.type.is_pyobject:

2345 done = arg.type.create_from_py_utility_code(env)

2346 if not done: pass # will fail later

2347

2348 if not self.signature_has_generic_args():

2349 if has_star_or_kw_args:

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

2351 self.generate_argument_conversion_code(code)

2352

2353 elif not self.signature_has_nongeneric_args():

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

2355 self.generate_stararg_copy_code(code)

2356

2357 else:

2358 positional_args = []

2359 kw_only_args = []

2360 for arg in self.args:

2361 arg_entry = arg.entry

2362 if arg.is_generic:

2363 if arg.default:

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

2365 if arg.kw_only:

2366 kw_only_args.append(arg)

2367 else:

2368 positional_args.append(arg)

2369 elif arg.kw_only:

2370 kw_only_args.append(arg)

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

2372 positional_args.append(arg)

2373

2374 self.generate_tuple_and_keyword_parsing_code(

2375 positional_args, kw_only_args, end_label, code)

2376

2377 code.error_label = old_error_label

2378 if code.label_used(our_error_label):

2379 if not code.label_used(end_label):

2380 code.put_goto(end_label)

2381 code.put_label(our_error_label)

2382 if has_star_or_kw_args:

2383 self.generate_arg_decref(self.star_arg, code)

2384 if self.starstar_arg:

2385 if self.starstar_arg.entry.xdecref_cleanup:

2386 code.put_var_xdecref(self.starstar_arg.entry)

2387 else:

2388 code.put_var_decref(self.starstar_arg.entry)

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

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

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

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

2393 # facilitate generic closure instance deallocation. In

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

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

2396 # frees their references as early as possible.

2397 for arg in self.args:

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

2399 code.put_var_xdecref_clear(arg.entry)

2400 if self.needs_closure:

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

2402 code.put_finish_refcount_context()

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

2404 if code.label_used(end_label):

2405 code.put_label(end_label)

2406

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

2408 if arg.type.is_pyobject:

2409 if arg.is_generic:

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

2411 entry = arg.entry

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

2413 if entry.in_closure:

2414 code.put_var_incref(entry)

2415 else:

2416 func = arg.type.from_py_function

2417 if func:

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

2419 arg.entry.cname,

2420 func,

2421 item,

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

2423 else:

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

2425

2426 def generate_arg_xdecref(self, arg, code):

2427 if arg:

2428 code.put_var_xdecref(arg.entry)

2429

2430 def generate_arg_decref(self, arg, code):

2431 if arg:

2432 code.put_var_decref(arg.entry)

2433

2434 def generate_stararg_copy_code(self, code):

2435 if not self.star_arg:

2436 code.globalstate.use_utility_code(raise_argtuple_invalid_utility_code)

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

2438 Naming.args_cname)

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

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

2441 code.putln("}")

2442

2443 code.globalstate.use_utility_code(keyword_string_check_utility_code)

2444

2445 if self.starstar_arg:

2446 if self.star_arg:

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

2448 else:

2449 kwarg_check = "%s" % Naming.kwds_cname

2450 else:

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

2452 Naming.kwds_cname, Naming.kwds_cname)

2453 code.putln(

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

2455 kwarg_check, Naming.kwds_cname, self.name,

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

2457

2458 if self.starstar_arg:

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

2460 self.starstar_arg.entry.cname,

2461 Naming.kwds_cname,

2462 Naming.kwds_cname))

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

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

2465 self.starstar_arg.entry.xdecref_cleanup = 0

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

2467

2468 if self.self_in_stararg:

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

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

2471 self.star_arg.entry.cname,

2472 Naming.args_cname,

2473 self.star_arg.entry.cname))

2474 if self.starstar_arg:

2475 code.putln("{")

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

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

2478 code.putln("}")

2479 else:

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

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

2482 code.put_incref(Naming.self_cname, py_object_type)

2483 code.put_giveref(Naming.self_cname)

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

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

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

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

2488 temp, temp, Naming.args_cname, temp))

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

2490 Naming.args_cname, temp))

2491 code.put_incref("item", py_object_type)

2492 code.put_giveref("item")

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

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

2495 code.putln("}")

2496 code.funcstate.release_temp(temp)

2497 self.star_arg.entry.xdecref_cleanup = 0

2498 elif self.star_arg:

2499 code.put_incref(Naming.args_cname, py_object_type)

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

2501 self.star_arg.entry.cname,

2502 Naming.args_cname))

2503 self.star_arg.entry.xdecref_cleanup = 0

2504

2505 def generate_tuple_and_keyword_parsing_code(self, positional_args,

2506 kw_only_args, success_label, code):

2507 argtuple_error_label = code.new_label("argtuple_error")

2508

2509 min_positional_args = self.num_required_args - self.num_required_kw_args

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

2511 min_positional_args -= 1

2512 max_positional_args = len(positional_args)

2513 has_fixed_positional_count = not self.star_arg and \

2514 min_positional_args == max_positional_args

2515

2516 code.globalstate.use_utility_code(raise_double_keywords_utility_code)

2517 code.globalstate.use_utility_code(raise_argtuple_invalid_utility_code)

2518 if self.num_required_kw_args:

2519 code.globalstate.use_utility_code(raise_keyword_required_utility_code)

2520

2521 if self.starstar_arg or self.star_arg:

2522 self.generate_stararg_init_code(max_positional_args, code)

2523

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

2525 if self.num_required_kw_args:

2526 likely_hint = "likely"

2527 else:

2528 likely_hint = "unlikely"

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

2530 self.generate_keyword_unpacking_code(

2531 min_positional_args, max_positional_args,

2532 has_fixed_positional_count,

2533 positional_args, kw_only_args, argtuple_error_label, code)

2534

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

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

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

2538 # check the length here

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

2540 compare = '!='

2541 else:

2542 compare = '<'

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

2544 Naming.args_cname, compare, min_positional_args))

2545 code.put_goto(argtuple_error_label)

2546

2547 if self.num_required_kw_args:

2548 # pure error case: keywords required but not passed

2549 if max_positional_args > min_positional_args and not self.star_arg:

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

2551 Naming.args_cname, max_positional_args))

2552 code.put_goto(argtuple_error_label)

2553 code.putln('} else {')

2554 for i, arg in enumerate(kw_only_args):

2555 if not arg.default:

2556 pystring_cname = code.intern_identifier(arg.name)

2557 # required keyword-only argument missing

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

2559 self.name,

2560 pystring_cname))

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

2562 break

2563

2564 elif min_positional_args == max_positional_args:

2565 # parse the exact number of positional arguments from the

2566 # args tuple

2567 code.putln('} else {')

2568 for i, arg in enumerate(positional_args):

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

2570 self.generate_arg_assignment(arg, item, code)

2571 self.generate_arg_default_assignments(code)

2572

2573 else:

2574 # parse the positional arguments from the variable length

2575 # args tuple

2576 code.putln('} else {')

2577 self.generate_arg_default_assignments(code)

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

2579 if self.star_arg:

2580 code.putln('default:')

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

2582 for i, arg in reversed_args:

2583 if i >= min_positional_args-1:

2584 if min_positional_args > 1:

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

2586 else:

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

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

2589 self.generate_arg_assignment(arg, item, code)

2590 if min_positional_args == 0:

2591 code.put('case 0: ')

2592 code.putln('break;')

2593 if self.star_arg:

2594 if min_positional_args:

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

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

2597 code.put_goto(argtuple_error_label)

2598 else:

2599 code.put('default: ')

2600 code.put_goto(argtuple_error_label)

2601 code.putln('}')

2602

2603 code.putln('}')

2604

2605 if code.label_used(argtuple_error_label):

2606 code.put_goto(success_label)

2607 code.put_label(argtuple_error_label)

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

2609 self.name, has_fixed_positional_count,

2610 min_positional_args, max_positional_args,

2611 Naming.args_cname))

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

2613

2614 def generate_arg_default_assignments(self, code):

2615 for arg in self.args:

2616 if arg.is_generic and arg.default:

2617 code.putln(

2618 "%s = %s;" % (

2619 arg.entry.cname,

2620 arg.calculate_default_value_code(code)))

2621

2622 def generate_stararg_init_code(self, max_positional_args, code):

2623 if self.starstar_arg:

2624 self.starstar_arg.entry.xdecref_cleanup = 0

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

2626 self.starstar_arg.entry.cname,

2627 self.starstar_arg.entry.cname,

2628 self.error_value()))

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

2630 if self.star_arg:

2631 self.star_arg.entry.xdecref_cleanup = 0

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

2633 Naming.args_cname,

2634 max_positional_args))

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

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

2637 max_positional_args, Naming.args_cname))

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

2639 if self.starstar_arg:

2640 code.putln("")

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

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

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

2644 code.putln('}')

2645 else:

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

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

2648 code.putln('} else {')

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

2650 code.put_incref(Naming.empty_tuple, py_object_type)

2651 code.putln('}')

2652

2653 def generate_keyword_unpacking_code(self, min_positional_args, max_positional_args,

2654 has_fixed_positional_count, positional_args,

2655 kw_only_args, argtuple_error_label, code):

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

2657 max_args = len(all_args)

2658

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

2660 Naming.kwds_cname)

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

2662 # before doing any type coercion etc.

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

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

2665

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

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

2668 for i, arg in enumerate(all_args):

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

2670 default_value = arg.calculate_default_value_code(code)

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

2672

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

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

2675 if self.star_arg:

2676 code.putln('default:')

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

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

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

2680 i, Naming.args_cname, i))

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

2682 if not self.star_arg:

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

2684 code.put_goto(argtuple_error_label)

2685 code.putln('}')

2686

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

2688 # from the kw dict

2689 if self.num_required_args or max_positional_args > 0:

2690 last_required_arg = -1

2691 for i, arg in enumerate(all_args):

2692 if not arg.default:

2693 last_required_arg = i

2694 if last_required_arg < max_positional_args:

2695 last_required_arg = max_positional_args-1

2696 num_required_args = self.num_required_args

2697 if max_positional_args > 0:

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

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

2700 if max_positional_args > 0 and i <= max_positional_args:

2701 if self.star_arg and i == max_positional_args:

2702 code.putln('default:')

2703 else:

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

2705 pystring_cname = code.intern_identifier(arg.name)

2706 if arg.default:

2707 if arg.kw_only:

2708 # handled separately below

2709 continue

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

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

2712 Naming.kwds_cname, pystring_cname))

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

2714 code.putln('}')

2715 else:

2716 num_required_args -= 1

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

2718 i, Naming.kwds_cname, pystring_cname))

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

2720 if i < min_positional_args:

2721 if i == 0:

2722 # special case: we know arg 0 is missing

2723 code.put('else ')

2724 code.put_goto(argtuple_error_label)

2725 else:

2726 # print the correct number of values (args or

2727 # kwargs) that were passed into positional

2728 # arguments up to this point

2729 code.putln('else {')

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

2731 self.name, has_fixed_positional_count,

2732 min_positional_args, max_positional_args, i))

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

2734 code.putln('}')

2735 elif arg.kw_only:

2736 code.putln('else {')

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

2738 self.name, pystring_cname))

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

2740 code.putln('}')

2741 if max_positional_args > 0:

2742 code.putln('}')

2743

2744 if kw_only_args and not self.starstar_arg:

2745 # unpack optional keyword-only arguments

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

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

2748 optional_args = []

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

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

2751 continue

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

2753 if optional_args:

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

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

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

2757 for i, arg in optional_args:

2758 pystring_cname = code.intern_identifier(arg.name)

2759 code.putln(

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

2761 Naming.kwds_cname, pystring_cname))

2762 code.putln(

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

2764 code.putln('break;')

2765 code.putln('}')

2766

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

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

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

2770 #

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

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

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

2774 # common cases above.

2775 if max_positional_args == 0:

2776 pos_arg_count = "0"

2777 elif self.star_arg:

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

2779 Naming.args_cname, max_positional_args,

2780 Naming.args_cname, max_positional_args))

2781 pos_arg_count = "used_pos_args"

2782 else:

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

2784 code.globalstate.use_utility_code(parse_keywords_utility_code)

2785 code.put(

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

2787 Naming.kwds_cname,

2788 Naming.pykwdlist_cname,

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

2790 pos_arg_count,

2791 self.name))

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

2793 code.putln('}')

2794

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

2796 for i, arg in enumerate(all_args):

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

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

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

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

2801 code.putln('} else {')

2802 code.putln(

2803 "%s = %s;" % (

2804 arg.entry.cname,

2805 arg.calculate_default_value_code(code)))

2806 code.putln('}')

2807

2808 def generate_argument_conversion_code(self, code):

2809 # Generate code to convert arguments from signature type to

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

2811 # into closure fields.

2812 for arg in self.args:

2813 if arg.needs_conversion:

2814 self.generate_arg_conversion(arg, code)

2815 elif arg.entry.in_closure:

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

2817 if arg.type.is_pyobject:

2818 code.put_var_incref(arg.entry)

2819

2820 def generate_arg_conversion(self, arg, code):

2821 # Generate conversion code for one argument.

2822 old_type = arg.hdr_type

2823 new_type = arg.type

2824 if old_type.is_pyobject:

2825 if arg.default:

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

2827 else:

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

2829 self.generate_arg_conversion_from_pyobject(arg, code)

2830 code.putln("}")

2831 elif new_type.is_pyobject:

2832 self.generate_arg_conversion_to_pyobject(arg, code)

2833 else:

2834 if new_type.assignable_from(old_type):

2835 code.putln(

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

2837 else:

2838 error(arg.pos,

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

2840 (old_type, new_type))

2841

2842 def generate_arg_conversion_from_pyobject(self, arg, code):

2843 new_type = arg.type

2844 func = new_type.from_py_function

2845 # copied from CoerceFromPyTypeNode

2846 if func:

2847 lhs = arg.entry.cname

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

2849 if new_type.is_enum:

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

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

2852 lhs,

2853 rhs,

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

2855 else:

2856 error(arg.pos,

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

2858 % new_type)

2859

2860 def generate_arg_conversion_to_pyobject(self, arg, code):

2861 old_type = arg.hdr_type

2862 func = old_type.to_py_function

2863 if func:

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

2865 arg.entry.cname,

2866 func,

2867 arg.hdr_cname,

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

2869 code.put_var_gotref(arg.entry)

2870 else:

2871 error(arg.pos,

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

2873 % old_type)

2874

2875 def generate_argument_type_tests(self, code):

2876 # Generate type tests for args whose signature

2877 # type is PyObject * and whose declared type is

2878 # a subtype thereof.

2879 for arg in self.args:

2880 if arg.needs_type_test:

2881 self.generate_arg_type_test(arg, code)

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

2883 self.generate_arg_none_check(arg, code)

2884

2885 def error_value(self):

2886 return self.entry.signature.error_value

2887

2888 def caller_will_check_exceptions(self):

2889 return 1

2890

2891 class OverrideCheckNode(StatNode):

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

2893 # is overriden.

2894 #

2895 # py_func

2896 #

2897 # args

2898 # func_temp

2899 # body

2900

2901 child_attrs = ['body']

2902

2903 body = None

2904

2905 def analyse_expressions(self, env):

2906 self.args = env.arg_entries

2907 if self.py_func.is_module_scope:

2908 first_arg = 0

2909 else:

2910 first_arg = 1

2911 import ExprNodes

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

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

2914 call_node = ExprNodes.SimpleCallNode(self.pos,

2915 function=self.func_node,

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

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

2918 self.body.analyse_expressions(env)

2919

2920 def generate_execution_code(self, code):

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

2922 # Check to see if we are an extension type

2923 if self.py_func.is_module_scope:

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

2925 else:

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

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

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

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

2930 if self.py_func.is_module_scope:

2931 code.putln("else {")

2932 else:

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

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

2935 self.func_node.set_cname(func_node_temp)

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

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

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

2939 func_node_temp, self_arg, interned_attr_cname, err))

2940 code.put_gotref(func_node_temp)

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

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

2943 func_node_temp, self.py_func.entry.func_cname)

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

2945 self.body.generate_execution_code(code)

2946 code.putln("}")

2947 code.put_decref_clear(func_node_temp, PyrexTypes.py_object_type)

2948 code.funcstate.release_temp(func_node_temp)

2949 code.putln("}")

2950

2951 class ClassDefNode(StatNode, BlockNode):

2952 pass

2953

2954 class PyClassDefNode(ClassDefNode):

2955 # A Python class definition.

2956 #

2957 # name EncodedString Name of the class

2958 # doc string or None

2959 # body StatNode Attribute definition code

2960 # entry Symtab.Entry

2961 # scope PyClassScope

2962 # decorators [DecoratorNode] list of decorators or None

2963 #

2964 # The following subnodes are constructed internally:

2965 #

2966 # dict DictNode Class dictionary or Py3 namespace

2967 # classobj ClassNode Class object

2968 # target NameNode Variable to assign class object to

2969

2970 child_attrs = ["body", "dict", "metaclass", "mkw", "bases", "classobj", "target"]

2971 decorators = None

2972 py3_style_class = False # Python3 style class (bases+kwargs)

2973

2974 def __init__(self, pos, name, bases, doc, body, decorators = None,

2975 keyword_args = None, starstar_arg = None):

2976 StatNode.__init__(self, pos)

2977 self.name = name

2978 self.doc = doc

2979 self.body = body

2980 self.decorators = decorators

2981 import ExprNodes

2982 if self.doc and Options.docstrings:

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

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

2985 else:

2986 doc_node = None

2987 if keyword_args or starstar_arg:

2988 self.py3_style_class = True

2989 self.bases = bases

2990 self.metaclass = None

2991 if keyword_args and not starstar_arg:

2992 for i, item in list(enumerate(keyword_args.key_value_pairs))[::-1]:

2993 if item.key.value == 'metaclass':

2994 if self.metaclass is not None:

2995 error(item.pos, "keyword argument 'metaclass' passed multiple times")

2996 # special case: we already know the metaclass,

2997 # so we don't need to do the "build kwargs,

2998 # find metaclass" dance at runtime

2999 self.metaclass = item.value

3000 del keyword_args.key_value_pairs[i]

3001 if starstar_arg or (keyword_args and keyword_args.key_value_pairs):

3002 self.mkw = ExprNodes.KeywordArgsNode(

3003 pos, keyword_args = keyword_args, starstar_arg = starstar_arg)

3004 else:

3005 self.mkw = ExprNodes.NullNode(pos)

3006 if self.metaclass is None:

3007 self.metaclass = ExprNodes.PyClassMetaclassNode(

3008 pos, mkw = self.mkw, bases = self.bases)

3009 self.dict = ExprNodes.PyClassNamespaceNode(pos, name = name,

3010 doc = doc_node, metaclass = self.metaclass, bases = self.bases,

3011 mkw = self.mkw)

3012 self.classobj = ExprNodes.Py3ClassNode(pos, name = name,

3013 bases = self.bases, dict = self.dict, doc = doc_node,

3014 metaclass = self.metaclass, mkw = self.mkw)

3015 else:

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

3017 self.metaclass = None

3018 self.mkw = None

3019 self.bases = None

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

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

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

3023

3024 def as_cclass(self):

3025 """

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

3027 """

3028 if self.py3_style_class:

3029 error(self.classobj.pos, "Python3 style class could not be represented as C class")

3030 return

3031 bases = self.classobj.bases.args

3032 if len(bases) == 0:

3033 base_class_name = None

3034 base_class_module = None

3035 elif len(bases) == 1:

3036 base = bases[0]

3037 path = []

3038 from ExprNodes import AttributeNode, NameNode

3039 while isinstance(base, AttributeNode):

3040 path.insert(0, base.attribute)

3041 base = base.obj

3042 if isinstance(base, NameNode):

3043 path.insert(0, base.name)

3044 base_class_name = path[-1]

3045 if len(path) > 1:

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

3047 else:

3048 base_class_module = None

3049 else:

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

3051 else:

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

3053 return None

3054

3055 return CClassDefNode(self.pos,

3056 visibility = 'private',

3057 module_name = None,

3058 class_name = self.name,

3059 base_class_module = base_class_module,

3060 base_class_name = base_class_name,

3061 decorators = self.decorators,

3062 body = self.body,

3063 in_pxd = False,

3064 doc = self.doc)

3065

3066 def create_scope(self, env):

3067 genv = env

3068 while genv.is_py_class_scope or genv.is_c_class_scope:

3069 genv = genv.outer_scope

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

3071 return cenv

3072

3073 def analyse_declarations(self, env):

3074 self.target.analyse_target_declaration(env)

3075 cenv = self.create_scope(env)

3076 cenv.directives = env.directives

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

3078 self.body.analyse_declarations(cenv)

3079

3080 def analyse_expressions(self, env):

3081 if self.py3_style_class:

3082 self.bases.analyse_expressions(env)

3083 self.metaclass.analyse_expressions(env)

3084 self.mkw.analyse_expressions(env)

3085 self.dict.analyse_expressions(env)

3086 self.classobj.analyse_expressions(env)

3087 genv = env.global_scope()

3088 cenv = self.scope

3089 self.body.analyse_expressions(cenv)

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

3091

3092 def generate_function_definitions(self, env, code):

3093 self.generate_lambda_definitions(self.scope, code)

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

3095

3096 def generate_execution_code(self, code):

3097 code.pyclass_stack.append(self)

3098 cenv = self.scope

3099 if self.py3_style_class:

3100 self.bases.generate_evaluation_code(code)

3101 self.mkw.generate_evaluation_code(code)

3102 self.metaclass.generate_evaluation_code(code)

3103 self.dict.generate_evaluation_code(code)

3104 cenv.namespace_cname = cenv.class_obj_cname = self.dict.result()

3105 self.body.generate_execution_code(code)

3106 self.classobj.generate_evaluation_code(code)

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

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

3109 self.dict.generate_disposal_code(code)

3110 self.dict.free_temps(code)

3111 if self.py3_style_class:

3112 self.mkw.generate_disposal_code(code)

3113 self.mkw.free_temps(code)

3114 self.metaclass.generate_disposal_code(code)

3115 self.metaclass.free_temps(code)

3116 self.bases.generate_disposal_code(code)

3117 self.bases.free_temps(code)

3118 code.pyclass_stack.pop()

3119

3120 class CClassDefNode(ClassDefNode):

3121 # An extension type definition.

3122 #

3123 # visibility 'private' or 'public' or 'extern'

3124 # typedef_flag boolean

3125 # api boolean

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

3127 # class_name string Unqualified name of class

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

3129 # base_class_module string or None Module containing the base class

3130 # base_class_name string or None Name of the base class

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

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

3133 # in_pxd boolean Is in a .pxd file

3134 # decorators [DecoratorNode] list of decorators or None

3135 # doc string or None

3136 # body StatNode or None

3137 # entry Symtab.Entry

3138 # base_type PyExtensionType or None

3139 # buffer_defaults_node DictNode or None Declares defaults for a buffer

3140 # buffer_defaults_pos

3141

3142 child_attrs = ["body"]

3143 buffer_defaults_node = None

3144 buffer_defaults_pos = None

3145 typedef_flag = False

3146 api = False

3147 objstruct_name = None

3148 typeobj_name = None

3149 decorators = None

3150

3151 def analyse_declarations(self, env):

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

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

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

3155

3156 import Buffer

3157 if self.buffer_defaults_node:

3158 buffer_defaults = Buffer.analyse_buffer_options(self.buffer_defaults_pos,

3159 env, [], self.buffer_defaults_node,

3160 need_complete=False)

3161 else:

3162 buffer_defaults = None

3163

3164 if env.in_cinclude and not self.objstruct_name:

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

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

3167 self.base_type = None

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

3169 # import the modules for extern classes.

3170 if self.module_name:

3171 self.module = None

3172 for module in env.cimported_modules:

3173 if module.name == self.module_name:

3174 self.module = module

3175 if self.module is None:

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

3177 self.module.has_extern_class = 1

3178 env.add_imported_module(self.module)

3179

3180 if self.base_class_name:

3181 if self.base_class_module:

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

3183 else:

3184 base_class_scope = env

3185 if self.base_class_name == 'object':

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

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

3188 self.base_class_name = None

3189 self.base_class_module = None

3190 base_class_scope = None

3191 if base_class_scope:

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

3193 if base_class_entry:

3194 if not base_class_entry.is_type:

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

3196 elif not base_class_entry.type.is_extension_type and \

3197 not (base_class_entry.type.is_builtin_type and \

3198 base_class_entry.type.objstruct_cname):

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

3200 elif not base_class_entry.type.is_complete():

3201 error(self.pos, "Base class '%s' of type '%s' is incomplete" % (

3202 self.base_class_name, self.class_name))

3203 elif base_class_entry.type.scope and base_class_entry.type.scope.directives and \

3204 base_class_entry.type.scope.directives['final']:

3205 error(self.pos, "Base class '%s' of type '%s' is final" % (

3206 self.base_class_name, self.class_name))

3207 elif base_class_entry.type.is_builtin_type and \

3208 base_class_entry.type.name in ('tuple', 'str', 'bytes'):

3209 error(self.pos, "inheritance from PyVarObject types like '%s' is not currently supported"

3210 % base_class_entry.type.name)

3211 else:

3212 self.base_type = base_class_entry.type

3213 has_body = self.body is not None

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

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

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

3217 if not home_scope:

3218 return

3219 else:

3220 home_scope = env

3221

3222 if self.visibility == 'extern':

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

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

3225

3226 self.entry = home_scope.declare_c_class(

3227 name = self.class_name,

3228 pos = self.pos,

3229 defining = has_body and self.in_pxd,

3230 implementing = has_body and not self.in_pxd,

3231 module_name = self.module_name,

3232 base_type = self.base_type,

3233 objstruct_cname = self.objstruct_name,

3234 typeobj_cname = self.typeobj_name,

3235 visibility = self.visibility,

3236 typedef_flag = self.typedef_flag,

3237 api = self.api,

3238 buffer_defaults = buffer_defaults)

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

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

3241 self.scope = scope = self.entry.type.scope

3242 if scope is not None:

3243 scope.directives = env.directives

3244

3245 if self.doc and Options.docstrings:

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

3247

3248 if has_body:

3249 self.body.analyse_declarations(scope)

3250 if self.in_pxd:

3251 scope.defined = 1

3252 else:

3253 scope.implemented = 1

3254 env.allocate_vtable_names(self.entry)

3255

3256 def analyse_expressions(self, env):

3257 if self.body:

3258 scope = self.entry.type.scope

3259 self.body.analyse_expressions(scope)

3260

3261 def generate_function_definitions(self, env, code):

3262 if self.body:

3263 self.generate_lambda_definitions(self.scope, code)

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

3265

3266 def generate_execution_code(self, code):

3267 # This is needed to generate evaluation code for

3268 # default values of method arguments.

3269 if self.body:

3270 self.body.generate_execution_code(code)

3271

3272 def annotate(self, code):

3273 if self.body:

3274 self.body.annotate(code)

3275

3276

3277 class PropertyNode(StatNode):

3278 # Definition of a property in an extension type.

3279 #

3280 # name string

3281 # doc EncodedString or None Doc string

3282 # body StatListNode

3283

3284 child_attrs = ["body"]

3285

3286 def analyse_declarations(self, env):

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

3288 if entry:

3289 entry.scope.directives = env.directives

3290 self.body.analyse_declarations(entry.scope)

3291

3292 def analyse_expressions(self, env):

3293 self.body.analyse_expressions(env)

3294

3295 def generate_function_definitions(self, env, code):

3296 self.body.generate_function_definitions(env, code)

3297

3298 def generate_execution_code(self, code):

3299 pass

3300

3301 def annotate(self, code):

3302 self.body.annotate(code)

3303

3304

3305 class GlobalNode(StatNode):

3306 # Global variable declaration.

3307 #

3308 # names [string]

3309

3310 child_attrs = []

3311

3312 def analyse_declarations(self, env):

3313 for name in self.names:

3314 env.declare_global(name, self.pos)

3315

3316 def analyse_expressions(self, env):

3317 pass

3318

3319 def generate_execution_code(self, code):

3320 pass

3321

3322

3323 class ExprStatNode(StatNode):

3324 # Expression used as a statement.

3325 #

3326 # expr ExprNode

3327

3328 child_attrs = ["expr"]

3329

3330 def analyse_declarations(self, env):

3331 import ExprNodes

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

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

3334 if func == u'declare':

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

3336 if len(args):

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

3338 for var, type_node in kwds.key_value_pairs:

3339 type = type_node.analyse_as_type(env)

3340 if type is None:

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

3342 else:

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

3344 self.__class__ = PassStatNode

3345

3346 def analyse_expressions(self, env):

3347 self.expr.analyse_expressions(env)

3348

3349 def generate_execution_code(self, code):

3350 self.expr.generate_evaluation_code(code)

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

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

3353 self.expr.generate_disposal_code(code)

3354 self.expr.free_temps(code)

3355

3356 def generate_function_definitions(self, env, code):

3357 self.expr.generate_function_definitions(env, code)

3358

3359 def annotate(self, code):

3360 self.expr.annotate(code)

3361

3362

3363 class AssignmentNode(StatNode):

3364 # Abstract base class for assignment nodes.

3365 #

3366 # The analyse_expressions and generate_execution_code

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

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

3369 # parallel assignment to be evaluated before assigning

3370 # to any of the left hand sides.

3371

3372 def analyse_expressions(self, env):

3373 self.analyse_types(env)

3374

3375 # def analyse_expressions(self, env):

3376 # self.analyse_expressions_1(env)

3377 # self.analyse_expressions_2(env)

3378

3379 def generate_execution_code(self, code):

3380 self.generate_rhs_evaluation_code(code)

3381 self.generate_assignment_code(code)

3382

3383

3384 class SingleAssignmentNode(AssignmentNode):

3385 # The simplest case:

3386 #

3387 # a = b

3388 #

3389 # lhs ExprNode Left hand side

3390 # rhs ExprNode Right hand side

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

3392

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

3394 first = False

3395 declaration_only = False

3396

3397 def analyse_declarations(self, env):

3398 import ExprNodes

3399

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

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

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

3403 if func_name:

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

3405

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

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

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

3409 return

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

3411 if type is None:

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

3413 return

3414 lhs = self.lhs

3415 if func_name == 'declare':

3416 if isinstance(lhs, ExprNodes.NameNode):

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

3418 elif isinstance(lhs, ExprNodes.TupleNode):

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

3420 else:

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

3422 return

3423 for var, pos in vars:

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

3425 if len(args) == 2:

3426 # we have a value

3427 self.rhs = args[1]

3428 else:

3429 self.declaration_only = True

3430 else:

3431 self.declaration_only = True

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

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

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

3435

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

3437 self.declaration_only = True

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

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

3440 return

3441 members = []

3442 for member, type_node in kwds.key_value_pairs:

3443 type = type_node.analyse_as_type(env)

3444 if type is None:

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

3446 else:

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

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

3449 return

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

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

3452 name = self.lhs.name

3453 scope = StructOrUnionScope(name)

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

3455 for member, type, pos in members:

3456 scope.declare_var(member, type, pos)

3457

3458 if self.declaration_only:

3459 return

3460 else:

3461 self.lhs.analyse_target_declaration(env)

3462

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

3464 self.rhs.analyse_types(env)

3465 self.lhs.analyse_target_types(env)

3466 self.lhs.gil_assignment_check(env)

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

3468 if use_temp:

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

3470

3471 def generate_rhs_evaluation_code(self, code):

3472 self.rhs.generate_evaluation_code(code)

3473

3474 def generate_assignment_code(self, code):

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

3476

3477 def generate_function_definitions(self, env, code):

3478 self.rhs.generate_function_definitions(env, code)

3479

3480 def annotate(self, code):

3481 self.lhs.annotate(code)

3482 self.rhs.annotate(code)

3483

3484

3485 class CascadedAssignmentNode(AssignmentNode):

3486 # An assignment with multiple left hand sides:

3487 #

3488 # a = b = c

3489 #

3490 # lhs_list [ExprNode] Left hand sides

3491 # rhs ExprNode Right hand sides

3492 #

3493 # Used internally:

3494 #

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

3496

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

3498 coerced_rhs_list = None

3499

3500 def analyse_declarations(self, env):

3501 for lhs in self.lhs_list:

3502 lhs.analyse_target_declaration(env)

3503

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

3505 self.rhs.analyse_types(env)

3506 if not self.rhs.is_simple():

3507 if use_temp:

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

3509 else:

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

3511 from ExprNodes import CloneNode

3512 self.coerced_rhs_list = []

3513 for lhs in self.lhs_list:

3514 lhs.analyse_target_types(env)

3515 lhs.gil_assignment_check(env)

3516 rhs = CloneNode(self.rhs)

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

3518 self.coerced_rhs_list.append(rhs)

3519

3520 def generate_rhs_evaluation_code(self, code):

3521 self.rhs.generate_evaluation_code(code)

3522

3523 def generate_assignment_code(self, code):

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

3525 lhs = self.lhs_list[i]

3526 rhs = self.coerced_rhs_list[i]

3527 rhs.generate_evaluation_code(code)

3528 lhs.generate_assignment_code(rhs, code)

3529 # Assignment has disposed of the cloned RHS

3530 self.rhs.generate_disposal_code(code)

3531 self.rhs.free_temps(code)

3532

3533 def generate_function_definitions(self, env, code):

3534 self.rhs.generate_function_definitions(env, code)

3535

3536 def annotate(self, code):

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

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

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

3540 self.rhs.annotate(code)

3541

3542

3543 class ParallelAssignmentNode(AssignmentNode):

3544 # A combined packing/unpacking assignment:

3545 #

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

3547 #

3548 # This has been rearranged by the parser into

3549 #

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

3551 #

3552 # but we must evaluate all the right hand sides

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

3554 #

3555 # stats [AssignmentNode] The constituent assignments

3556

3557 child_attrs = ["stats"]

3558

3559 def analyse_declarations(self, env):

3560 for stat in self.stats:

3561 stat.analyse_declarations(env)

3562

3563 def analyse_expressions(self, env):

3564 for stat in self.stats:

3565 stat.analyse_types(env, use_temp = 1)

3566

3567 # def analyse_expressions(self, env):

3568 # for stat in self.stats:

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

3570 # for stat in self.stats:

3571 # stat.analyse_expressions_2(env)

3572

3573 def generate_execution_code(self, code):

3574 for stat in self.stats:

3575 stat.generate_rhs_evaluation_code(code)

3576 for stat in self.stats:

3577 stat.generate_assignment_code(code)

3578

3579 def generate_function_definitions(self, env, code):

3580 for stat in self.stats:

3581 stat.generate_function_definitions(env, code)

3582

3583 def annotate(self, code):

3584 for stat in self.stats:

3585 stat.annotate(code)

3586

3587

3588 class InPlaceAssignmentNode(AssignmentNode):

3589 # An in place arithmetic operand:

3590 #

3591 # a += b

3592 # a -= b

3593 # ...

3594 #

3595 # lhs ExprNode Left hand side

3596 # rhs ExprNode Right hand side

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

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

3599 #

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

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

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

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

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

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

3606

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

3608

3609 def analyse_declarations(self, env):

3610 self.lhs.analyse_target_declaration(env)

3611

3612 def analyse_types(self, env):

3613 self.rhs.analyse_types(env)

3614 self.lhs.analyse_target_types(env)

3615

3616 def generate_execution_code(self, code):

3617 import ExprNodes

3618 self.rhs.generate_evaluation_code(code)

3619 self.lhs.generate_subexpr_evaluation_code(code)

3620 c_op = self.operator

3621 if c_op == "//":

3622 c_op = "/"

3623 elif c_op == "**":

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

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

3626 if self.lhs.type.is_pyobject:

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

3628 if c_op in ('/', '%') and self.lhs.type.is_int and not code.directives['cdivision']:

3629 error(self.pos, "In-place non-c divide operators not allowed on int buffers.")

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

3631 else:

3632 # C++

3633 # TODO: make sure overload is declared

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

3635 self.lhs.generate_subexpr_disposal_code(code)

3636 self.lhs.free_subexpr_temps(code)

3637 self.rhs.generate_disposal_code(code)

3638 self.rhs.free_temps(code)

3639

3640 def annotate(self, code):

3641 self.lhs.annotate(code)

3642 self.rhs.annotate(code)

3643

3644 def create_binop_node(self):

3645 import ExprNodes

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

3647

3648

3649 class PrintStatNode(StatNode):

3650 # print statement

3651 #

3652 # arg_tuple TupleNode

3653 # stream ExprNode or None (stdout)

3654 # append_newline boolean

3655

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

3657

3658 def analyse_expressions(self, env):

3659 if self.stream:

3660 self.stream.analyse_expressions(env)

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

3662 self.arg_tuple.analyse_expressions(env)

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

3664 env.use_utility_code(printing_utility_code)

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

3666 env.use_utility_code(printing_one_utility_code)

3667

3668 nogil_check = Node.gil_error

3669 gil_message = "Python print statement"

3670

3671 def generate_execution_code(self, code):

3672 if self.stream:

3673 self.stream.generate_evaluation_code(code)

3674 stream_result = self.stream.py_result()

3675 else:

3676 stream_result = '0'

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

3678 arg = self.arg_tuple.args[0]

3679 arg.generate_evaluation_code(code)

3680

3681 code.putln(

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

3683 stream_result,

3684 arg.py_result(),

3685 code.error_goto(self.pos)))

3686 arg.generate_disposal_code(code)

3687 arg.free_temps(code)

3688 else:

3689 self.arg_tuple.generate_evaluation_code(code)

3690 code.putln(

3691 "if (__Pyx_Print(%s, %s, %d) < 0) %s" % (

3692 stream_result,

3693 self.arg_tuple.py_result(),

3694 self.append_newline,

3695 code.error_goto(self.pos)))

3696 self.arg_tuple.generate_disposal_code(code)

3697 self.arg_tuple.free_temps(code)

3698

3699 if self.stream:

3700 self.stream.generate_disposal_code(code)

3701 self.stream.free_temps(code)

3702

3703 def generate_function_definitions(self, env, code):

3704 if self.stream:

3705 self.stream.generate_function_definitions(env, code)

3706 self.arg_tuple.generate_function_definitions(env, code)

3707

3708 def annotate(self, code):

3709 if self.stream:

3710 self.stream.annotate(code)

3711 self.arg_tuple.annotate(code)

3712

3713

3714 class ExecStatNode(StatNode):

3715 # exec statement

3716 #

3717 # args [ExprNode]

3718

3719 child_attrs = ["args"]

3720

3721 def analyse_expressions(self, env):

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

3723 arg.analyse_expressions(env)

3724 arg = arg.coerce_to_pyobject(env)

3725 self.args[i] = arg

3726 env.use_utility_code(Builtin.pyexec_utility_code)

3727

3728 nogil_check = Node.gil_error

3729 gil_message = "Python exec statement"

3730

3731 def generate_execution_code(self, code):

3732 args = []

3733 for arg in self.args:

3734 arg.generate_evaluation_code(code)

3735 args.append( arg.py_result() )

3736 args = tuple(args + ['0', '0'][:3-len(args)])

3737 temp_result = code.funcstate.allocate_temp(PyrexTypes.py_object_type, manage_ref=True)

3738 code.putln("%s = __Pyx_PyRun(%s, %s, %s);" % (

3739 (temp_result,) + args))

3740 for arg in self.args:

3741 arg.generate_disposal_code(code)

3742 arg.free_temps(code)

3743 code.putln(

3744 code.error_goto_if_null(temp_result, self.pos))

3745 code.put_gotref(temp_result)

3746 code.put_decref_clear(temp_result, py_object_type)

3747 code.funcstate.release_temp(temp_result)

3748

3749 def annotate(self, code):

3750 for arg in self.args:

3751 arg.annotate(code)

3752

3753

3754 class DelStatNode(StatNode):

3755 # del statement

3756 #

3757 # args [ExprNode]

3758

3759 child_attrs = ["args"]

3760

3761 def analyse_declarations(self, env):

3762 for arg in self.args:

3763 arg.analyse_target_declaration(env)

3764

3765 def analyse_expressions(self, env):

3766 for arg in self.args:

3767 arg.analyse_target_expression(env, None)

3768 if arg.type.is_pyobject:

3769 pass

3770 elif arg.type.is_ptr and arg.type.base_type.is_cpp_class:

3771 self.cpp_check(env)

3772 elif arg.type.is_cpp_class:

3773 error(arg.pos, "Deletion of non-heap C++ object")

3774 else:

3775 error(arg.pos, "Deletion of non-Python, non-C++ object")

3776 #arg.release_target_temp(env)

3777

3778 def nogil_check(self, env):

3779 for arg in self.args:

3780 if arg.type.is_pyobject:

3781 self.gil_error()

3782

3783 gil_message = "Deleting Python object"

3784

3785 def generate_execution_code(self, code):

3786 for arg in self.args:

3787 if arg.type.is_pyobject:

3788 arg.generate_deletion_code(code)

3789 elif arg.type.is_ptr and arg.type.base_type.is_cpp_class:

3790 arg.generate_result_code(code)

3791 code.putln("delete %s;" % arg.result())

3792 # else error reported earlier

3793

3794 def annotate(self, code):

3795 for arg in self.args:

3796 arg.annotate(code)

3797

3798

3799 class PassStatNode(StatNode):

3800 # pass statement

3801

3802 child_attrs = []

3803

3804 def analyse_expressions(self, env):

3805 pass

3806

3807 def generate_execution_code(self, code):

3808 pass

3809

3810

3811 class BreakStatNode(StatNode):

3812

3813 child_attrs = []

3814

3815 def analyse_expressions(self, env):

3816 pass

3817

3818 def generate_execution_code(self, code):

3819 if not code.break_label:

3820 error(self.pos, "break statement not inside loop")

3821 else:

3822 code.put_goto(code.break_label)

3823

3824

3825 class ContinueStatNode(StatNode):

3826

3827 child_attrs = []

3828

3829 def analyse_expressions(self, env):

3830 pass

3831

3832 def generate_execution_code(self, code):

3833 if code.funcstate.in_try_finally:

3834 error(self.pos, "continue statement inside try of try...finally")

3835 elif not code.continue_label:

3836 error(self.pos, "continue statement not inside loop")

3837 else:

3838 code.put_goto(code.continue_label)

3839

3840

3841 class ReturnStatNode(StatNode):

3842 # return statement

3843 #

3844 # value ExprNode or None

3845 # return_type PyrexType

3846

3847 child_attrs = ["value"]

3848

3849 def analyse_expressions(self, env):

3850 return_type = env.return_type

3851 self.return_type = return_type

3852 if not return_type:

3853 error(self.pos, "Return not inside a function body")

3854 return

3855 if self.value:

3856 self.value.analyse_types(env)

3857 if return_type.is_void or return_type.is_returncode:

3858 error(self.value.pos,

3859 "Return with value in void function")

3860 else:

3861 self.value = self.value.coerce_to(env.return_type, env)

3862 else:

3863 if (not return_type.is_void

3864 and not return_type.is_pyobject

3865 and not return_type.is_returncode):

3866 error(self.pos, "Return value required")

3867

3868 def nogil_check(self, env):

3869 if self.return_type.is_pyobject:

3870 self.gil_error()

3871

3872 gil_message = "Returning Python object"

3873

3874 def generate_execution_code(self, code):

3875 code.mark_pos(self.pos)

3876 if not self.return_type:

3877 # error reported earlier

3878 return

3879 if self.return_type.is_pyobject:

3880 code.put_xdecref(Naming.retval_cname,

3881 self.return_type)

3882 if self.value:

3883 self.value.generate_evaluation_code(code)

3884 self.value.make_owned_reference(code)

3885 code.putln(

3886 "%s = %s;" % (

3887 Naming.retval_cname,

3888 self.value.result_as(self.return_type)))

3889 self.value.generate_post_assignment_code(code)

3890 self.value.free_temps(code)

3891 else:

3892 if self.return_type.is_pyobject:

3893 code.put_init_to_py_none(Naming.retval_cname, self.return_type)

3894 elif self.return_type.is_returncode:

3895 code.putln(

3896 "%s = %s;" % (

3897 Naming.retval_cname,

3898 self.return_type.default_value))

3899 for cname, type in code.funcstate.temps_holding_reference():

3900 code.put_decref_clear(cname, type)

3901 code.put_goto(code.return_label)

3902

3903 def generate_function_definitions(self, env, code):

3904 if self.value is not None:

3905 self.value.generate_function_definitions(env, code)

3906

3907 def annotate(self, code):

3908 if self.value:

3909 self.value.annotate(code)

3910

3911

3912 class RaiseStatNode(StatNode):

3913 # raise statement

3914 #

3915 # exc_type ExprNode or None

3916 # exc_value ExprNode or None

3917 # exc_tb ExprNode or None

3918

3919 child_attrs = ["exc_type", "exc_value", "exc_tb"]

3920

3921 def analyse_expressions(self, env):

3922 if self.exc_type:

3923 self.exc_type.analyse_types(env)

3924 self.exc_type = self.exc_type.coerce_to_pyobject(env)

3925 if self.exc_value:

3926 self.exc_value.analyse_types(env)

3927 self.exc_value = self.exc_value.coerce_to_pyobject(env)

3928 if self.exc_tb:

3929 self.exc_tb.analyse_types(env)

3930 self.exc_tb = self.exc_tb.coerce_to_pyobject(env)

3931 env.use_utility_code(raise_utility_code)

3932

3933 nogil_check = Node.gil_error

3934 gil_message = "Raising exception"

3935

3936 def generate_execution_code(self, code):

3937 if self.exc_type:

3938 self.exc_type.generate_evaluation_code(code)

3939 type_code = self.exc_type.py_result()

3940 else:

3941 type_code = "0"

3942 if self.exc_value:

3943 self.exc_value.generate_evaluation_code(code)

3944 value_code = self.exc_value.py_result()

3945 else:

3946 value_code = "0"

3947 if self.exc_tb:

3948 self.exc_tb.generate_evaluation_code(code)

3949 tb_code = self.exc_tb.py_result()

3950 else:

3951 tb_code = "0"

3952 code.putln(

3953 "__Pyx_Raise(%s, %s, %s);" % (

3954 type_code,

3955 value_code,

3956 tb_code))

3957 for obj in (self.exc_type, self.exc_value, self.exc_tb):

3958 if obj:

3959 obj.generate_disposal_code(code)

3960 obj.free_temps(code)

3961 code.putln(

3962 code.error_goto(self.pos))

3963

3964 def generate_function_definitions(self, env, code):

3965 if self.exc_type is not None:

3966 self.exc_type.generate_function_definitions(env, code)

3967 if self.exc_value is not None:

3968 self.exc_value.generate_function_definitions(env, code)

3969 if self.exc_tb is not None:

3970 self.exc_tb.generate_function_definitions(env, code)

3971

3972 def annotate(self, code):