1 #

2 # Pyrex - Parse tree nodes

3 #

4

5 import sys, os, time, copy

6

7 import Code

8 import Builtin

9 from Errors import error, warning, InternalError

10 import Naming

11 import PyrexTypes

12 import TypeSlots

13 from PyrexTypes import py_object_type, error_type, CTypedefType, CFuncType

14 from Symtab import ModuleScope, LocalScope, GeneratorLocalScope, \

15 StructOrUnionScope, PyClassScope, CClassScope

16 from Cython.Utils import open_new_file, replace_suffix, UtilityCode

17 from StringEncoding import EncodedString, escape_byte_string, split_docstring

18 import Options

19 import ControlFlow

20 import DebugFlags

21

22 absolute_path_length = 0

23

24 def relative_position(pos):

25 """

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

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

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

29 e.g,. when distributing binaries.)

30

31 INPUT:

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

33

34 OUTPUT:

35 relative filename

36 line number

37

38 AUTHOR: William Stein

39 """

40 global absolute_path_length

41 if absolute_path_length==0:

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

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

44

45 def embed_position(pos, docstring):

46 if not Options.embed_pos_in_docstring:

47 return docstring

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

49 if docstring is None:

50 # unicode string

51 return EncodedString(pos_line)

52

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

54 # otherwise make the docstring a unicode string

55 encoding = docstring.encoding

56 if encoding is not None:

57 try:

58 encoded_bytes = pos_line.encode(encoding)

59 except UnicodeEncodeError:

60 encoding = None

61

62 if not docstring:

63 # reuse the string encoding of the original docstring

64 doc = EncodedString(pos_line)

65 else:

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

67 doc.encoding = encoding

68 return doc

69

70

71 from Code import CCodeWriter

72 from types import FunctionType

73

74 def write_func_call(func):

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

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

77 # here we annotate the code with this function call

78 # but only if new code is generated

79 node, code = args[:2]

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

81 ' ' * code.call_level,

82 node.__class__.__name__,

83 func.__name__,

84 node.pos[1:])

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

86 code.putln(marker)

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

88 code.call_level += 4

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

90 code.call_level -= 4

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

92 code.buffer.stream.seek(pristine)

93 else:

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

95 code.putln(marker)

96 return res

97 else:

98 return func(*args, **kwds)

99 return f

100

101 class VerboseCodeWriter(type):

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

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

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

105 attrs = dict(attrs)

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

107 if isinstance(m, FunctionType):

108 attrs[mname] = write_func_call(m)

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

110

111

112 class Node(object):

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

114 # is_name boolean Is a NameNode

115 # is_literal boolean Is a ConstNode

116

117 if DebugFlags.debug_trace_code_generation:

118 __metaclass__ = VerboseCodeWriter

119

120 is_name = 0

121 is_literal = 0

122 temps = None

123

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

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

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

127 child_attrs = None

128

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

130 self.pos = pos

131 self.__dict__.update(kw)

132

133 gil_message = "Operation"

134

135 gil_check = None

136 def _gil_check(self, env):

137 if env.nogil:

138 self.gil_error()

139

140 def gil_error(self):

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

142

143 def clone_node(self):

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

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

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

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

148 level in the tree."""

149 result = copy.copy(self)

150 for attrname in result.child_attrs:

151 value = getattr(result, attrname)

152 if isinstance(value, list):

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

154 return result

155

156

157 #

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

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

160 #

161 # (0) analyse_control_flow

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

163 # queried.

164 #

165 # (1) analyse_declarations

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

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

168 # to an otherwise undeclared name).

169 #

170 # (2) analyse_expressions

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

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

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

174 # Allocate temporary locals for intermediate results. Fill

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

176 # fragment.

177 #

178 # (3) generate_code

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

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

181 # functions.

182 #

183

184 def analyse_control_flow(self, env):

185 pass

186

187 def analyse_declarations(self, env):

188 pass

189

190 def analyse_expressions(self, env):

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

192 self.__class__.__name__)

193

194 def generate_code(self, code):

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

196 self.__class__.__name__)

197

198 def annotate(self, code):

199 # mro does the wrong thing

200 if isinstance(self, BlockNode):

201 self.body.annotate(code)

202

203 def end_pos(self):

204 try:

205 return self._end_pos

206 except AttributeError:

207 pos = self.pos

208 if not self.child_attrs:

209 self._end_pos = pos

210 return pos

211 for attr in self.child_attrs:

212 child = getattr(self, attr)

213 # Sometimes lists, sometimes nodes

214 if child is None:

215 pass

216 elif isinstance(child, list):

217 for c in child:

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

219 else:

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

221 self._end_pos = pos

222 return pos

223

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

225 if cutoff == 0:

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

227 if encountered is None:

228 encountered = set()

229 if id(self) in encountered:

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

231 encountered.add(id(self))

232

233 def dump_child(x, level):

234 if isinstance(x, Node):

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

236 elif isinstance(x, list):

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

238 else:

239 return repr(x)

240

241

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

243 if len(attrs) == 0:

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

245 else:

246 indent = " " * level

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

248 for key, value in attrs:

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

250 res += "%s>" % indent

251 return res

252

253 class CompilerDirectivesNode(Node):

254 """

255 Sets compiler directives for the children nodes

256 """

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

258 # *all* possible directives.

259 # body Node

260 child_attrs = ["body"]

261

262 def analyse_control_flow(self, env):

263 old = env.directives

264 env.directives = self.directives

265 self.body.analyse_control_flow(env)

266 env.directives = old

267

268 def analyse_declarations(self, env):

269 old = env.directives

270 env.directives = self.directives

271 self.body.analyse_declarations(env)

272 env.directives = old

273

274 def analyse_expressions(self, env):

275 old = env.directives

276 env.directives = self.directives

277 self.body.analyse_expressions(env)

278 env.directives = old

279

280 def generate_function_definitions(self, env, code):

281 env_old = env.directives

282 code_old = code.globalstate.directives

283 code.globalstate.directives = self.directives

284 self.body.generate_function_definitions(env, code)

285 env.directives = env_old

286 code.globalstate.directives = code_old

287

288 def generate_execution_code(self, code):

289 old = code.globalstate.directives

290 code.globalstate.directives = self.directives

291 self.body.generate_execution_code(code)

292 code.globalstate.directives = old

293

294 def annotate(self, code):

295 old = code.globalstate.directives

296 code.globalstate.directives = self.directives

297 self.body.annotate(code)

298 code.globalstate.directives = old

299

300 class BlockNode(object):

301 # Mixin class for nodes representing a declaration block.

302

303 def generate_cached_builtins_decls(self, env, code):

304 entries = env.global_scope().undeclared_cached_builtins

305 for entry in entries:

306 code.globalstate.add_cached_builtin_decl(entry)

307 del entries[:]

308

309

310 class StatListNode(Node):

311 # stats a list of StatNode

312

313 child_attrs = ["stats"]

314

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

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

317 return node # No node-specific analysis necesarry

318 create_analysed = staticmethod(create_analysed)

319

320 def analyse_control_flow(self, env):

321 for stat in self.stats:

322 stat.analyse_control_flow(env)

323

324 def analyse_declarations(self, env):

325 #print "StatListNode.analyse_declarations" ###

326 for stat in self.stats:

327 stat.analyse_declarations(env)

328

329 def analyse_expressions(self, env):

330 #print "StatListNode.analyse_expressions" ###

331 for stat in self.stats:

332 stat.analyse_expressions(env)

333

334 def generate_function_definitions(self, env, code):

335 #print "StatListNode.generate_function_definitions" ###

336 for stat in self.stats:

337 stat.generate_function_definitions(env, code)

338

339 def generate_execution_code(self, code):

340 #print "StatListNode.generate_execution_code" ###

341 for stat in self.stats:

342 code.mark_pos(stat.pos)

343 stat.generate_execution_code(code)

344

345 def annotate(self, code):

346 for stat in self.stats:

347 stat.annotate(code)

348

349

350 class StatNode(Node):

351 #

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

353 #

354 # (1) generate_function_definitions

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

356 # unions, enums and functions defined in the current

357 # scope-block.

358 #

359 # (2) generate_execution_code

360 # Emit C code for executable statements.

361 #

362

363 def generate_function_definitions(self, env, code):

364 pass

365

366 def generate_execution_code(self, code):

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

368 self.__class__.__name__)

369

370

371 class CDefExternNode(StatNode):

372 # include_file string or None

373 # body StatNode

374

375 child_attrs = ["body"]

376

377 def analyse_declarations(self, env):

378 if self.include_file:

379 env.add_include_file(self.include_file)

380 old_cinclude_flag = env.in_cinclude

381 env.in_cinclude = 1

382 self.body.analyse_declarations(env)

383 env.in_cinclude = old_cinclude_flag

384

385 def analyse_expressions(self, env):

386 pass

387

388 def generate_execution_code(self, code):

389 pass

390

391 def annotate(self, code):

392 self.body.annotate(code)

393

394

395 class CDeclaratorNode(Node):

396 # Part of a C declaration.

397 #

398 # Processing during analyse_declarations phase:

399 #

400 # analyse

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

402 # CNameDeclaratorNode of the name being declared

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

404 #

405 # calling_convention string Calling convention of CFuncDeclaratorNode

406 # for which this is a base

407

408 child_attrs = []

409

410 calling_convention = ""

411

412

413 class CNameDeclaratorNode(CDeclaratorNode):

414 # name string The Pyrex name being declared

415 # cname string or None C name, if specified

416 # default ExprNode or None the value assigned on declaration

417

418 child_attrs = ['default']

419

420 default = None

421

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

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

424 # May have mistaken the name for the type.

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

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

427 elif base_type.is_void:

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

429 else:

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

431 base_type = py_object_type

432 self.type = base_type

433 return self, base_type

434

435 class CPtrDeclaratorNode(CDeclaratorNode):

436 # base CDeclaratorNode

437

438 child_attrs = ["base"]

439

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

441 if base_type.is_pyobject:

442 error(self.pos,

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

444 ptr_type = PyrexTypes.c_ptr_type(base_type)

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

446

447 class CArrayDeclaratorNode(CDeclaratorNode):

448 # base CDeclaratorNode

449 # dimension ExprNode

450

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

452

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

454 if self.dimension:

455 self.dimension.analyse_const_expression(env)

456 if not self.dimension.type.is_int:

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

458 size = self.dimension.get_constant_c_result_code()

459 if size is not None:

460 try:

461 size = int(size)

462 except ValueError:

463 # runtime constant?

464 pass

465 else:

466 size = None

467 if not base_type.is_complete():

468 error(self.pos,

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

470 if base_type.is_pyobject:

471 error(self.pos,

472 "Array element cannot be a Python object")

473 if base_type.is_cfunction:

474 error(self.pos,

475 "Array element cannot be a function")

476 array_type = PyrexTypes.c_array_type(base_type, size)

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

478

479

480 class CFuncDeclaratorNode(CDeclaratorNode):

481 # base CDeclaratorNode

482 # args [CArgDeclNode]

483 # has_varargs boolean

484 # exception_value ConstNode

485 # exception_check boolean True if PyErr_Occurred check needed

486 # nogil boolean Can be called without gil

487 # with_gil boolean Acquire gil around function body

488

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

490

491 overridable = 0

492 optional_arg_count = 0

493

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

495 if nonempty:

496 nonempty -= 1

497 func_type_args = []

498 for arg_node in self.args:

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

500 name = name_declarator.name

501 if name_declarator.cname:

502 error(self.pos,

503 "Function argument cannot have C name specification")

504 # Turn *[] argument into **

505 if type.is_array:

506 type = PyrexTypes.c_ptr_type(type.base_type)

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

508 if type.is_void:

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

510 func_type_args.append(

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

512 if arg_node.default:

513 self.optional_arg_count += 1

514 elif self.optional_arg_count:

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

516

517 if self.optional_arg_count:

518 scope = StructOrUnionScope()

519 arg_count_member = '%sn' % Naming.pyrex_prefix

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

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

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

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

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

525 kind = 'struct',

526 scope = scope,

527 typedef_flag = 0,

528 pos = self.pos,

529 cname = struct_cname)

530 self.op_args_struct.defined_in_pxd = 1

531 self.op_args_struct.used = 1

532

533 exc_val = None

534 exc_check = 0

535 if self.exception_check == '+':

536 env.add_include_file('stdexcept')

537 if return_type.is_pyobject \

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

539 and self.exception_check != '+':

540 error(self.pos,

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

542 else:

543 if self.exception_value:

544 self.exception_value.analyse_const_expression(env)

545 exc_val = self.exception_value.get_constant_c_result_code()

546 if self.exception_check == '+':

547 exc_val_type = self.exception_value.type

548 if not exc_val_type.is_error and \

549 not exc_val_type.is_pyobject and \

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

551 error(self.exception_value.pos,

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

553 else:

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

555 error(self.exception_value.pos,

556 "Exception value incompatible with function return type")

557 exc_check = self.exception_check

558 if return_type.is_array:

559 error(self.pos,

560 "Function cannot return an array")

561 if return_type.is_cfunction:

562 error(self.pos,

563 "Function cannot return a function")

564 func_type = PyrexTypes.CFuncType(

565 return_type, func_type_args, self.has_varargs,

566 optional_arg_count = self.optional_arg_count,

567 exception_value = exc_val, exception_check = exc_check,

568 calling_convention = self.base.calling_convention,

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

570 if self.optional_arg_count:

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

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

573

574

575 class CArgDeclNode(Node):

576 # Item in a function declaration argument list.

577 #

578 # base_type CBaseTypeNode

579 # declarator CDeclaratorNode

580 # not_none boolean Tagged with 'not None'

581 # default ExprNode or None

582 # default_value PyObjectConst constant for default value

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

584 # is_kw_only boolean Is a keyword-only argument

585

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

587

588 is_self_arg = 0

589 is_generic = 1

590 type = None

591 name_declarator = None

592 default_value = None

593

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

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

596 if self.type is None:

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

598 # We fix that here.

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

600 if nonempty:

601 self.declarator.name = self.base_type.name

602 self.base_type.name = None

603 self.base_type.is_basic_c_type = False

604 could_be_name = True

605 else:

606 could_be_name = False

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

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

609 self.declarator.name = self.base_type.arg_name

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

611 else:

612 return self.name_declarator, self.type

613

614 def calculate_default_value_code(self, code):

615 if self.default_value is None:

616 if self.default:

617 if self.default.is_literal:

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

619 self.default.generate_evaluation_code(code)

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

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

622 return self.default_value

623

624 def annotate(self, code):

625 if self.default:

626 self.default.annotate(code)

627

628

629 class CBaseTypeNode(Node):

630 # Abstract base class for C base type nodes.

631 #

632 # Processing during analyse_declarations phase:

633 #

634 # analyse

635 # Returns the type.

636

637 pass

638

639 class CAnalysedBaseTypeNode(Node):

640 # type type

641

642 child_attrs = []

643

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

645 return self.type

646

647 class CSimpleBaseTypeNode(CBaseTypeNode):

648 # name string

649 # module_path [string] Qualifying name components

650 # is_basic_c_type boolean

651 # signed boolean

652 # longness integer

653 # is_self_arg boolean Is self argument of C method

654

655 child_attrs = []

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

657

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

659 # Return type descriptor.

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

661 type = None

662 if self.is_basic_c_type:

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

664 if not type:

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

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

667 type = py_object_type

668 elif self.name is None:

669 if self.is_self_arg and env.is_c_class_scope:

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

671 type = env.parent_type

672 else:

673 type = py_object_type

674 else:

675 if self.module_path:

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

677 else:

678 scope = env

679 if scope:

680 if scope.is_c_class_scope:

681 scope = scope.global_scope()

682 entry = scope.lookup(self.name)

683 if entry and entry.is_type:

684 type = entry.type

685 elif could_be_name:

686 if self.is_self_arg and env.is_c_class_scope:

687 type = env.parent_type

688 else:

689 type = py_object_type

690 self.arg_name = self.name

691 else:

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

693 if type:

694 return type

695 else:

696 return PyrexTypes.error_type

697

698 class CBufferAccessTypeNode(CBaseTypeNode):

699 # After parsing:

700 # positional_args [ExprNode] List of positional arguments

701 # keyword_args DictNode Keyword arguments

702 # base_type_node CBaseTypeNode

703

704 # After analysis:

705 # type PyrexType.BufferType ...containing the right options

706

707

708 child_attrs = ["base_type_node", "positional_args",

709 "keyword_args", "dtype_node"]

710

711 dtype_node = None

712

713 name = None

714

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

716 base_type = self.base_type_node.analyse(env)

717 if base_type.is_error: return base_type

718 import Buffer

719

720 options = Buffer.analyse_buffer_options(

721 self.pos,

722 env,

723 self.positional_args,

724 self.keyword_args,

725 base_type.buffer_defaults)

726

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

728 return self.type

729

730 class CComplexBaseTypeNode(CBaseTypeNode):

731 # base_type CBaseTypeNode

732 # declarator CDeclaratorNode

733

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

735

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

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

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

739 return type

740

741

742 class CVarDefNode(StatNode):

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

744 #

745 # visibility 'private' or 'public' or 'extern'

746 # base_type CBaseTypeNode

747 # declarators [CDeclaratorNode]

748 # in_pxd boolean

749 # api boolean

750 # need_properties [entry]

751

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

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

754

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

756 need_properties = ()

757

758 decorators = None

759 directive_locals = {}

760

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

762 if not dest_scope:

763 dest_scope = env

764 self.dest_scope = dest_scope

765 base_type = self.base_type.analyse(env)

766 if (dest_scope.is_c_class_scope

767 and self.visibility == 'public'

768 and base_type.is_pyobject

769 and (base_type.is_builtin_type or base_type.is_extension_type)):

770 self.need_properties = []

771 need_property = True

772 visibility = 'private'

773 else:

774 need_property = False

775 visibility = self.visibility

776

777 for declarator in self.declarators:

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

779 if not type.is_complete():

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

781 error(declarator.pos,

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

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

784 error(declarator.pos,

785 "Python object cannot be declared extern")

786 name = name_declarator.name

787 cname = name_declarator.cname

788 if name == '':

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

790 return

791 if type.is_cfunction:

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

793 cname = cname, visibility = self.visibility, in_pxd = self.in_pxd,

794 api = self.api)

795 if entry is not None:

796 entry.directive_locals = self.directive_locals

797 else:

798 if self.directive_locals:

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

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

801 error(self.pos,

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

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

804 cname = cname, visibility = visibility, is_cdef = 1)

805 if need_property:

806 self.need_properties.append(entry)

807 entry.needs_property = 1

808

809

810 class CStructOrUnionDefNode(StatNode):

811 # name string

812 # cname string or None

813 # kind "struct" or "union"

814 # typedef_flag boolean

815 # visibility "public" or "private"

816 # in_pxd boolean

817 # attributes [CVarDefNode] or None

818 # entry Entry

819

820 child_attrs = ["attributes"]

821

822 def analyse_declarations(self, env):

823 scope = None

824 if self.attributes is not None:

825 scope = StructOrUnionScope(self.name)

826 self.entry = env.declare_struct_or_union(

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

828 self.cname, visibility = self.visibility)

829 if self.attributes is not None:

830 if self.in_pxd and not env.in_cinclude:

831 self.entry.defined_in_pxd = 1

832 for attr in self.attributes:

833 attr.analyse_declarations(env, scope)

834 if self.visibility != 'extern':

835 need_typedef_indirection = False

836 for attr in scope.var_entries:

837 type = attr.type

838 while type.is_array:

839 type = type.base_type

840 if type == self.entry.type:

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

842 if self.typedef_flag:

843 while type.is_ptr:

844 type = type.base_type

845 if type == self.entry.type:

846 need_typedef_indirection = True

847 if need_typedef_indirection:

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

849 struct_entry = self.entry

850 self.entry = env.declare_typedef(

851 self.name, struct_entry.type, self.pos,

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

853 struct_entry.type.typedef_flag = False

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

855 struct_entry.cname = struct_entry.type.cname = \

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

857

858 def analyse_expressions(self, env):

859 pass

860

861 def generate_execution_code(self, code):

862 pass

863

864

865 class CEnumDefNode(StatNode):

866 # name string or None

867 # cname string or None

868 # items [CEnumDefItemNode]

869 # typedef_flag boolean

870 # visibility "public" or "private"

871 # in_pxd boolean

872 # entry Entry

873

874 child_attrs = ["items"]

875

876 def analyse_declarations(self, env):

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

878 cname = self.cname, typedef_flag = self.typedef_flag,

879 visibility = self.visibility)

880 if self.items is not None:

881 if self.in_pxd and not env.in_cinclude:

882 self.entry.defined_in_pxd = 1

883 for item in self.items:

884 item.analyse_declarations(env, self.entry)

885

886 def generate_execution_code(self, code):

887 if self.visibility == 'public':

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

889 for item in self.entry.enum_values:

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

891 temp,

892 item.cname,

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

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

895 Naming.module_cname,

896 item.name,

897 temp,

898 code.error_goto(item.pos)))

899 code.putln("%s = 0;" % temp)

900 code.funcstate.release_temp(temp)

901

902

903 class CEnumDefItemNode(StatNode):

904 # name string

905 # cname string or None

906 # value ExprNode or None

907

908 child_attrs = ["value"]

909

910 def analyse_declarations(self, env, enum_entry):

911 if self.value:

912 self.value.analyse_const_expression(env)

913 if not self.value.type.is_int:

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

915 self.value.analyse_const_expression(env)

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

917 self.value, self.pos, cname = self.cname,

918 visibility = enum_entry.visibility)

919 enum_entry.enum_values.append(entry)

920

921

922 class CTypeDefNode(StatNode):

923 # base_type CBaseTypeNode

924 # declarator CDeclaratorNode

925 # visibility "public" or "private"

926 # in_pxd boolean

927

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

929

930 def analyse_declarations(self, env):

931 base = self.base_type.analyse(env)

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

933 name = name_declarator.name

934 cname = name_declarator.cname

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

936 cname = cname, visibility = self.visibility)

937 if self.in_pxd and not env.in_cinclude:

938 entry.defined_in_pxd = 1

939

940 def analyse_expressions(self, env):

941 pass

942 def generate_execution_code(self, code):

943 pass

944

945

946 class FuncDefNode(StatNode, BlockNode):

947 # Base class for function definition nodes.

948 #

949 # return_type PyrexType

950 # #filename string C name of filename string const

951 # entry Symtab.Entry

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

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

954

955 py_func = None

956 assmt = None

957 needs_closure = False

958

959 def analyse_default_values(self, env):

960 genv = env.global_scope()

961 for arg in self.args:

962 if arg.default:

963 if arg.is_generic:

964 arg.default.analyse_types(env)

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

966 else:

967 error(arg.pos,

968 "This argument cannot have a default value")

969 arg.default = None

970

971 def need_gil_acquisition(self, lenv):

972 return 0

973

974 def create_local_scope(self, env):

975 genv = env

976 while env.is_py_class_scope or env.is_c_class_scope:

977 env = env.outer_scope

978 if self.needs_closure:

979 lenv = GeneratorLocalScope(name = self.entry.name, outer_scope = genv)

980 else:

981 lenv = LocalScope(name = self.entry.name, outer_scope = genv)

982 lenv.return_type = self.return_type

983 type = self.entry.type

984 if type.is_cfunction:

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

986 self.local_scope = lenv

987 return lenv

988

989 def generate_function_definitions(self, env, code):

990 import Buffer

991

992 lenv = self.local_scope

993

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

995 self.entry.scope.is_c_class_scope)

996

997 # Generate C code for header and body of function

998 code.enter_cfunc_scope()

999 code.return_from_error_cleanup_label = code.new_label()

1000

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

1002 code.mark_pos(self.pos)

1003 self.generate_cached_builtins_decls(lenv, code)

1004 # ----- Function header

1005 code.putln("")

1006 if self.py_func:

1007 self.py_func.generate_function_header(code,

1008 with_pymethdef = env.is_py_class_scope,

1009 proto_only=True)

1010 self.generate_function_header(code,

1011 with_pymethdef = env.is_py_class_scope)

1012 # ----- Local variable declarations

1013 lenv.mangle_closure_cnames(Naming.cur_scope_cname)

1014 self.generate_argument_declarations(lenv, code)

1015 if self.needs_closure:

1016 code.putln("/* TODO: declare and create scope object */")

1017 code.put_var_declarations(lenv.var_entries)

1018 init = ""

1019 if not self.return_type.is_void:

1020 if self.return_type.is_pyobject:

1021 init = " = NULL"

1022 code.putln(

1023 "%s%s;" %

1024 (self.return_type.declaration_code(

1025 Naming.retval_cname),

1026 init))

1027 tempvardecl_code = code.insertion_point()

1028 self.generate_keyword_list(code)

1029 # ----- Extern library function declarations

1030 lenv.generate_library_function_declarations(code)

1031 # ----- GIL acquisition

1032 acquire_gil = self.need_gil_acquisition(lenv)

1033 if acquire_gil:

1034 env.use_utility_code(force_init_threads_utility_code)

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

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

1037 if not lenv.nogil:

1038 code.put_setup_refcount_context(self.entry.name)

1039 if is_getbuffer_slot:

1040 self.getbuffer_init(code)

1041 # ----- Fetch arguments

1042 self.generate_argument_parsing_code(env, code)

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

1044 # incref it to properly keep track of refcounts.

1045 for entry in lenv.arg_entries:

1046 if entry.type.is_pyobject and lenv.control_flow.get_state((entry.name, 'source')) != 'arg':

1047 code.put_var_incref(entry)

1048 # ----- Initialise local variables

1049 for entry in lenv.var_entries:

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

1051 code.put_init_var_to_py_none(entry)

1052 # ----- Initialise local buffer auxiliary variables

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

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

1055 code.putln("%s.buf = NULL;" % entry.buffer_aux.buffer_info_var.cname)

1056 # ----- Check and convert arguments

1057 self.generate_argument_type_tests(code)

1058 # ----- Acquire buffer arguments

1059 for entry in lenv.arg_entries:

1060 if entry.type.is_buffer:

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

1062 # ----- Function body

1063 self.body.generate_execution_code(code)

1064 # ----- Default return value

1065 code.putln("")

1066 if self.return_type.is_pyobject:

1067 #if self.return_type.is_extension_type:

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

1069 #else:

1070 lhs = Naming.retval_cname

1071 code.put_init_to_py_none(lhs, self.return_type)

1072 else:

1073 val = self.return_type.default_value

1074 if val:

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

1076 # ----- Error cleanup

1077 if code.error_label in code.labels_used:

1078 code.put_goto(code.return_label)

1079 code.put_label(code.error_label)

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

1081 code.put_xdecref(cname, type)

1082

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

1084 # so need to save and restore error state

1085 buffers_present = len(lenv.buffer_entries) > 0

1086 if buffers_present:

1087 code.globalstate.use_utility_code(restore_exception_utility_code)

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

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

1090 for entry in lenv.buffer_entries:

1091 code.putln("%s;" % Buffer.get_release_buffer_code(entry))

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

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

1094

1095 err_val = self.error_value()

1096 exc_check = self.caller_will_check_exceptions()

1097 if err_val is not None or exc_check:

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

1099 else:

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

1101 % self.entry.qualified_name, 0)

1102 code.putln(

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

1104 self.entry.qualified_name)

1105 env.use_utility_code(unraisable_exception_utility_code)

1106 env.use_utility_code(restore_exception_utility_code)

1107 default_retval = self.return_type.default_value

1108 if err_val is None and default_retval:

1109 err_val = default_retval

1110 if err_val is not None:

1111 code.putln(

1112 "%s = %s;" % (

1113 Naming.retval_cname,

1114 err_val))

1115

1116 if is_getbuffer_slot:

1117 self.getbuffer_error_cleanup(code)

1118

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

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

1121 # whether this section is used.

1122 if buffers_present or is_getbuffer_slot:

1123 code.put_goto(code.return_from_error_cleanup_label)

1124

1125

1126 # ----- Non-error return cleanup

1127 # If you add anything here, remember to add a condition to the

1128 # if-test above in the error block (so that it can jump past this

1129 # block).

1130 code.put_label(code.return_label)

1131 for entry in lenv.buffer_entries:

1132 if entry.used:

1133 code.putln("%s;" % Buffer.get_release_buffer_code(entry))

1134 if is_getbuffer_slot:

1135 self.getbuffer_normal_cleanup(code)

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

1137 code.put_label(code.return_from_error_cleanup_label)

1138 if not Options.init_local_none:

1139 for entry in lenv.var_entries:

1140 if lenv.control_flow.get_state((entry.name, 'initalized')) is not True:

1141 entry.xdecref_cleanup = 1

1142 code.put_var_decrefs(lenv.var_entries, used_only = 1)

1143 # Decref any increfed args

1144 for entry in lenv.arg_entries:

1145 if entry.type.is_pyobject and lenv.control_flow.get_state((entry.name, 'source')) != 'arg':

1146 code.put_var_decref(entry)

1147

1148 # code.putln("/* TODO: decref scope object */")

1149 # ----- Return

1150 # This code is duplicated in ModuleNode.generate_module_init_func

1151 if not lenv.nogil:

1152 default_retval = self.return_type.default_value

1153 err_val = self.error_value()

1154 if err_val is None and default_retval:

1155 err_val = default_retval

1156 if self.return_type.is_pyobject:

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

1158

1159 code.put_finish_refcount_context()

1160

1161 if acquire_gil:

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

1163

1164 if not self.return_type.is_void:

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

1166

1167 code.putln("}")

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

1169 tempvardecl_code.put_temp_declarations(code.funcstate)

1170 # ----- Python version

1171 code.exit_cfunc_scope()

1172 if self.py_func:

1173 self.py_func.generate_function_definitions(env, code)

1174 self.generate_wrapper_functions(code)

1175

1176 def declare_argument(self, env, arg):

1177 if arg.type.is_void:

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

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

1180 error(arg.pos,

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

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

1183

1184 def generate_wrapper_functions(self, code):

1185 pass

1186

1187 def generate_execution_code(self, code):

1188 # Evaluate and store argument default values

1189 for arg in self.args:

1190 default = arg.default

1191 if default:

1192 if not default.is_literal:

1193 default.generate_evaluation_code(code)

1194 default.make_owned_reference(code)

1195 result = default.result_as(arg.type)

1196 code.putln(

1197 "%s = %s;" % (

1198 arg.calculate_default_value_code(code),

1199 result))

1200 if arg.type.is_pyobject:

1201 code.put_giveref(default.result())

1202 default.generate_post_assignment_code(code)

1203 default.free_temps(code)

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

1205 if self.assmt:

1206 self.assmt.generate_execution_code(code)

1207

1208 #

1209 # Special code for the __getbuffer__ function

1210 #

1211 def getbuffer_init(self, code):

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

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

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

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

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

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

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

1219

1220 def getbuffer_error_cleanup(self, code):

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

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

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

1224 (info, info))

1225

1226 def getbuffer_normal_cleanup(self, code):

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

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

1229 code.put_gotref("Py_None")

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

1231 code.putln("}")

1232

1233 class CFuncDefNode(FuncDefNode):

1234 # C function definition.

1235 #

1236 # modifiers ['inline']

1237 # visibility 'private' or 'public' or 'extern'

1238 # base_type CBaseTypeNode

1239 # declarator CDeclaratorNode

1240 # body StatListNode

1241 # api boolean

1242 # decorators [DecoratorNode] list of decorators

1243 #

1244 # with_gil boolean Acquire GIL around body

1245 # type CFuncType

1246 # py_func wrapper for calling from Python

1247 # overridable whether or not this is a cpdef function

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

1249

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

1251

1252 inline_in_pxd = False

1253 decorators = None

1254 directive_locals = {}

1255

1256 def unqualified_name(self):

1257 return self.entry.name

1258

1259 def analyse_declarations(self, env):

1260 if 'locals' in env.directives and env.directives['locals']:

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

1262 directive_locals = self.directive_locals

1263 base_type = self.base_type.analyse(env)

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

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

1266 if not type.is_cfunction:

1267 error(self.pos,

1268 "Suite attached to non-function declaration")

1269 # Remember the actual type according to the function header

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

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

1272 # from the base type of an extension type.

1273 self.type = type

1274 type.is_overridable = self.overridable

1275 declarator = self.declarator

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

1277 declarator = declarator.base

1278 self.args = declarator.args

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

1280 formal_arg.type = type_arg.type

1281 formal_arg.name = type_arg.name

1282 formal_arg.cname = type_arg.cname

1283 name = name_declarator.name

1284 cname = name_declarator.cname

1285 self.entry = env.declare_cfunction(

1286 name, type, self.pos,

1287 cname = cname, visibility = self.visibility,

1288 defining = self.body is not None,

1289 api = self.api, modifiers = self.modifiers)

1290 self.entry.inline_func_in_pxd = self.inline_in_pxd

1291 self.return_type = type.return_type

1292

1293 if self.overridable and not env.is_module_scope:

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

1295 # An error will be produced in the cdef function

1296 self.overridable = False

1297

1298 if self.overridable:

1299 import ExprNodes

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

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

1302 name = self.entry.name,

1303 args = self.args,

1304 star_arg = None,

1305 starstar_arg = None,

1306 doc = self.doc,

1307 body = py_func_body,

1308 is_wrapper = 1)

1309 self.py_func.is_module_scope = env.is_module_scope

1310 self.py_func.analyse_declarations(env)

1311 self.entry.as_variable = self.py_func.entry

1312 # Reset scope entry the above cfunction

1313 env.entries[name] = self.entry

1314 if not env.is_module_scope or Options.lookup_module_cpdef:

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

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

1317

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

1319 import ExprNodes

1320 args = self.type.args

1321 if omit_optional_args:

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

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

1324 if is_module_scope:

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

1326 else:

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

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

1329 skip_dispatch = not is_module_scope or Options.lookup_module_cpdef

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

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

1332

1333 def declare_arguments(self, env):

1334 for arg in self.type.args:

1335 if not arg.name:

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

1337 self.declare_argument(env, arg)

1338

1339 def need_gil_acquisition(self, lenv):

1340 return self.type.with_gil

1341

1342 def gil_check(self, env):

1343 type = self.type

1344 with_gil = type.with_gil

1345 if type.nogil and not with_gil:

1346 if type.return_type.is_pyobject:

1347 error(self.pos,

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

1349 for entry in env.var_entries:

1350 if entry.type.is_pyobject:

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

1352

1353 def analyse_expressions(self, env):

1354 self.local_scope.directives = env.directives

1355 if self.py_func is not None:

1356 # this will also analyse the default values

1357 self.py_func.analyse_expressions(env)

1358 else:

1359 self.analyse_default_values(env)

1360

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

1362 arg_decls = []

1363 type = self.type

1364 visibility = self.entry.visibility

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

1366 arg_decls.append(arg.declaration_code())

1367 if with_dispatch and self.overridable:

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

1369 if type.optional_arg_count and with_opt_args:

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

1371 if type.has_varargs:

1372 arg_decls.append("...")

1373 if not arg_decls:

1374 arg_decls = ["void"]

1375 if cname is None:

1376 cname = self.entry.func_cname

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

1378 if visibility == 'public':

1379 dll_linkage = "DL_EXPORT"

1380 else:

1381 dll_linkage = None

1382 header = self.return_type.declaration_code(entity,

1383 dll_linkage = dll_linkage)

1384 if visibility == 'extern':

1385 storage_class = "%s " % Naming.extern_c_macro

1386 elif visibility == 'public':

1387 storage_class = ""

1388 else:

1389 storage_class = "static "

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

1391 storage_class,

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

1393 header))

1394

1395 def generate_argument_declarations(self, env, code):

1396 for arg in self.args:

1397 if arg.default:

1398 result = arg.calculate_default_value_code(code)

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

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

1401

1402 def generate_keyword_list(self, code):

1403 pass

1404

1405 def generate_argument_parsing_code(self, env, code):

1406 i = 0

1407 if self.type.optional_arg_count:

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

1409 for arg in self.args:

1410 if arg.default:

1411 # FIXME: simple name prefixing doesn't work when

1412 # argument name mangling is in place

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

1414 declarator = arg.declarator

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

1416 declarator = declarator.base

1417 code.putln('%s = %s->%s;' % (arg.cname, Naming.optional_args_cname, declarator.name))

1418 i += 1

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

1420 code.putln('}')

1421 code.putln('}')

1422

1423 def generate_argument_conversion_code(self, code):

1424 pass

1425

1426 def generate_argument_type_tests(self, code):

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

1428 # class is a supertype of the declared type.

1429 for arg in self.type.args:

1430 if arg.needs_type_test:

1431 self.generate_arg_type_test(arg, code)

1432

1433 def generate_arg_type_test(self, arg, code):

1434 # Generate type test for one argument.

1435 if arg.type.typeobj_is_available():

1436 typeptr_cname = arg.type.typeptr_cname

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

1438 code.putln(

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

1440 arg_code,

1441 typeptr_cname,

1442 not arg.not_none,

1443 arg.name,

1444 type.is_builtin_type,

1445 code.error_goto(arg.pos)))

1446 else:

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

1448 "without type object name specification")

1449

1450 def error_value(self):

1451 if self.return_type.is_pyobject:

1452 return "0"

1453 else:

1454 #return None

1455 return self.entry.type.exception_value

1456

1457 def caller_will_check_exceptions(self):

1458 return self.entry.type.exception_check

1459

1460 def generate_wrapper_functions(self, code):

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

1462 # wrappers to put in the slots here.

1463 k = 0

1464 entry = self.entry

1465 func_type = entry.type

1466 while entry.prev_entry is not None:

1467 k += 1

1468 entry = entry.prev_entry

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

1470 code.putln()

1471 self.generate_function_header(code,

1472 0,

1473 with_dispatch = entry.type.is_overridable,

1474 with_opt_args = entry.type.optional_arg_count,

1475 cname = entry.func_cname)

1476 if not self.return_type.is_void:

1477 code.put('return ')

1478 args = self.type.args

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

1480 if entry.type.is_overridable:

1481 arglist.append(Naming.skip_dispatch_cname)

1482 elif func_type.is_overridable:

1483 arglist.append('0')

1484 if entry.type.optional_arg_count:

1485 arglist.append(Naming.optional_args_cname)

1486 elif func_type.optional_arg_count:

1487 arglist.append('NULL')

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

1489 code.putln('}')

1490

1491

1492 class PyArgDeclNode(Node):

1493 # Argument which must be a Python object (used

1494 # for * and ** arguments).

1495 #

1496 # name string

1497 # entry Symtab.Entry

1498 child_attrs = []

1499

1500

1501 class DecoratorNode(Node):

1502 # A decorator

1503 #

1504 # decorator NameNode or CallNode

1505 child_attrs = ['decorator']

1506

1507

1508 class DefNode(FuncDefNode):

1509 # A Python function definition.

1510 #

1511 # name string the Python name of the function

1512 # decorators [DecoratorNode] list of decorators

1513 # args [CArgDeclNode] formal arguments

1514 # star_arg PyArgDeclNode or None * argument

1515 # starstar_arg PyArgDeclNode or None ** argument

1516 # doc EncodedString or None

1517 # body StatListNode

1518 #

1519 # The following subnode is constructed internally

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

1521 #

1522 # assmt AssignmentNode Function construction/assignment

1523

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

1525

1526 assmt = None

1527 num_kwonly_args = 0

1528 num_required_kw_args = 0

1529 reqd_kw_flags_cname = "0"

1530 is_wrapper = 0

1531 decorators = None

1532 entry = None

1533

1534

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

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

1537 k = rk = r = 0

1538 for arg in self.args:

1539 if arg.kw_only:

1540 k += 1

1541 if not arg.default:

1542 rk += 1

1543 if not arg.default:

1544 r += 1

1545 self.num_kwonly_args = k

1546 self.num_required_kw_args = rk

1547 self.num_required_args = r

1548

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

1550 if self.star_arg:

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

1552 if self.starstar_arg:

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

1554 if cfunc is None:

1555 cfunc_args = []

1556 for formal_arg in self.args:

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

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

1559 cname = None,

1560 type = py_object_type,

1561 pos = formal_arg.pos))

1562 cfunc_type = PyrexTypes.CFuncType(return_type = py_object_type,

1563 args = cfunc_args,

1564 has_varargs = False,

1565 exception_value = None,

1566 exception_check = False,

1567 nogil = False,

1568 with_gil = False,

1569 is_overridable = True)

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

1571 else:

1572 cfunc_type = cfunc.type

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

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

1575 error(declarator.pos, "previous declaration here")

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

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

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

1579 formal_arg.type = type_arg.type

1580 formal_arg.name_declarator = name_declarator

1581 import ExprNodes

1582 if cfunc_type.exception_value is None:

1583 exception_value = None

1584 else:

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

1586 declarator = CFuncDeclaratorNode(self.pos,

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

1588 args = self.args,

1589 has_varargs = False,

1590 exception_check = cfunc_type.exception_check,

1591 exception_value = exception_value,

1592 with_gil = cfunc_type.with_gil,

1593 nogil = cfunc_type.nogil)

1594 return CFuncDefNode(self.pos,

1595 modifiers = [],

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

1597 declarator = declarator,

1598 body = self.body,

1599 doc = self.doc,

1600 overridable = cfunc_type.is_overridable,

1601 type = cfunc_type,

1602 with_gil = cfunc_type.with_gil,

1603 nogil = cfunc_type.nogil,

1604 visibility = 'private',

1605 api = False,

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

1607

1608 def analyse_declarations(self, env):

1609 if 'locals' in env.directives:

1610 directive_locals = env.directives['locals']

1611 else:

1612 directive_locals = {}

1613 self.directive_locals = directive_locals

1614 for arg in self.args:

1615 if hasattr(arg, 'name'):

1616 type = arg.type

1617 name_declarator = None

1618 else:

1619 base_type = arg.base_type.analyse(env)

1620 name_declarator, type = \

1621 arg.declarator.analyse(base_type, env)

1622 arg.name = name_declarator.name

1623 if arg.name in directive_locals:

1624 type_node = directive_locals[arg.name]

1625 other_type = type_node.analyse_as_type(env)

1626 if other_type is None:

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

1628 elif (type is not PyrexTypes.py_object_type

1629 and not type.same_as(other_type)):

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

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

1632 else:

1633 type = other_type

1634 if name_declarator and name_declarator.cname:

1635 error(self.pos,

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

1637 arg.type = type.as_argument_type()

1638 arg.hdr_type = None

1639 arg.needs_conversion = 0

1640 arg.needs_type_test = 0

1641 arg.is_generic = 1

1642 if arg.not_none and not arg.type.is_extension_type:

1643 error(self.pos,

1644 "Only extension type arguments can have 'not None'")

1645 self.declare_pyfunction(env)

1646 self.analyse_signature(env)

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

1648

1649 def analyse_signature(self, env):

1650 any_type_tests_needed = 0

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

1652 if not self.entry.is_special and not self.star_arg and not self.starstar_arg:

1653 if self.entry.signature is TypeSlots.pyfunction_signature and Options.optimize_simple_methods:

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

1655 self.entry.signature = TypeSlots.pyfunction_noargs

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

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

1658 self.entry.signature = TypeSlots.pyfunction_onearg

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

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

1661 self.entry.signature = TypeSlots.unaryfunc

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

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

1664 self.entry.signature = TypeSlots.ibinaryfunc

1665 elif self.entry.is_special:

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

1667 sig = self.entry.signature

1668 nfixed = sig.num_fixed_args()

1669 for i in range(nfixed):

1670 if i < len(self.args):

1671 arg = self.args[i]

1672 arg.is_generic = 0

1673 if sig.is_self_arg(i):

1674 arg.is_self_arg = 1

1675 arg.hdr_type = arg.type = env.parent_type

1676 arg.needs_conversion = 0

1677 else:

1678 arg.hdr_type = sig.fixed_arg_type(i)

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

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

1681 arg.needs_type_test = 1

1682 any_type_tests_needed = 1

1683 else:

1684 arg.needs_conversion = 1

1685 if arg.needs_conversion:

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

1687 else:

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

1689 else:

1690 self.bad_signature()

1691 return

1692 if nfixed < len(self.args):

1693 if not sig.has_generic_args:

1694 self.bad_signature()

1695 for arg in self.args:

1696 if arg.is_generic and \

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

1698 arg.needs_type_test = 1

1699 any_type_tests_needed = 1

1700 if any_type_tests_needed:

1701 env.use_utility_code(arg_type_test_utility_code)

1702

1703 def bad_signature(self):

1704 sig = self.entry.signature

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

1706 if sig.has_generic_args:

1707 expected_str = expected_str + " or more"

1708 name = self.name

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

1710 desc = "Special method"

1711 else:

1712 desc = "Method"

1713 error(self.pos,

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

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

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

1717

1718 def signature_has_nongeneric_args(self):

1719 argcount = len(self.args)

1720 if argcount == 0 or (argcount == 1 and self.args[0].is_self_arg):

1721 return 0

1722 return 1

1723

1724 def signature_has_generic_args(self):

1725 return self.entry.signature.has_generic_args

1726

1727 def declare_pyfunction(self, env):

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

1729 name = self.name

1730 entry = env.lookup_here(self.name)

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

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

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

1734 self.entry = entry

1735 prefix = env.scope_prefix

1736 entry.func_cname = \

1737 Naming.pyfunc_prefix + prefix + name

1738 entry.pymethdef_cname = \

1739 Naming.pymethdef_prefix + prefix + name

1740 if Options.docstrings:

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

1742 entry.doc_cname = \

1743 Naming.funcdoc_prefix + prefix + name

1744 else:

1745 entry.doc = None

1746

1747 def declare_arguments(self, env):

1748 for arg in self.args:

1749 if not arg.name:

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

1751 if arg.needs_conversion:

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

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

1754 env.control_flow.set_state((), (arg.name, 'initalized'), True)

1755 if arg.type.is_pyobject:

1756 arg.entry.init = "0"

1757 arg.entry.init_to_none = 0

1758 else:

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

1760 arg.entry.used = 1

1761 arg.entry.is_self_arg = arg.is_self_arg

1762 if arg.hdr_type:

1763 if arg.is_self_arg or \

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

1765 arg.entry.is_declared_generic = 1

1766 self.declare_python_arg(env, self.star_arg)

1767 self.declare_python_arg(env, self.starstar_arg)

1768

1769 def declare_python_arg(self, env, arg):

1770 if arg:

1771 entry = env.declare_var(arg.name,

1772 PyrexTypes.py_object_type, arg.pos)

1773 entry.used = 1

1774 entry.init = "0"

1775 entry.init_to_none = 0

1776 entry.xdecref_cleanup = 1

1777 arg.entry = entry

1778 env.control_flow.set_state((), (arg.name, 'initalized'), True)

1779

1780 def analyse_expressions(self, env):

1781 self.local_scope.directives = env.directives

1782 self.analyse_default_values(env)

1783 if env.is_py_class_scope:

1784 self.synthesize_assignment_node(env)

1785

1786 def synthesize_assignment_node(self, env):

1787 import ExprNodes

1788 self.assmt = SingleAssignmentNode(self.pos,

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

1790 rhs = ExprNodes.UnboundMethodNode(self.pos,

1791 function = ExprNodes.PyCFunctionNode(self.pos,

1792 pymethdef_cname = self.entry.pymethdef_cname)))

1793 self.assmt.analyse_declarations(env)

1794 self.assmt.analyse_expressions(env)

1795

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

1797 arg_code_list = []

1798 sig = self.entry.signature

1799 if sig.has_dummy_arg:

1800 arg_code_list.append(

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

1802 for arg in self.args:

1803 if not arg.is_generic:

1804 if arg.is_self_arg:

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

1806 else:

1807 arg_code_list.append(

1808 arg.hdr_type.declaration_code(arg.hdr_cname))

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

1810 arg_code_list.append("PyObject *unused")

1811 if sig.has_generic_args:

1812 arg_code_list.append(

1813 "PyObject *%s, PyObject *%s"

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

1815 arg_code = ", ".join(arg_code_list)

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

1817 header = "static %s(%s)" % (dc, arg_code)

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

1819 if proto_only:

1820 return

1821 if self.entry.doc and Options.docstrings:

1822 docstr = self.entry.doc

1823 if not isinstance(docstr, str):

1824 docstr = docstr.utf8encode()

1825 code.putln(

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

1827 self.entry.doc_cname,

1828 split_docstring(escape_byte_string(docstr))))

1829 if with_pymethdef:

1830 code.put(

1831 "static PyMethodDef %s = " %

1832 self.entry.pymethdef_cname)

1833 code.put_pymethoddef(self.entry, ";")

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

1835

1836 def generate_argument_declarations(self, env, code):

1837 for arg in self.args:

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

1839 if arg.needs_conversion:

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

1841 else:

1842 code.put_var_declaration(arg.entry)

1843

1844 def generate_keyword_list(self, code):

1845 if self.signature_has_generic_args() and \

1846 self.signature_has_nongeneric_args():

1847 code.put(

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

1849 Naming.pykwdlist_cname)

1850 for arg in self.args:

1851 if arg.is_generic:

1852 pystring_cname = code.intern_identifier(arg.name)

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

1854 code.putln("0};")

1855

1856 def generate_argument_parsing_code(self, env, code):

1857 # Generate PyArg_ParseTuple call for generic

1858 # arguments, if any.

1859 if self.entry.signature.has_dummy_arg:

1860 # get rid of unused argument warning

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

1862

1863 old_error_label = code.new_error_label()

1864 our_error_label = code.error_label

1865 end_label = code.new_label("argument_unpacking_done")

1866

1867 has_kwonly_args = self.num_kwonly_args > 0

1868 has_star_or_kw_args = self.star_arg is not None \

1869 or self.starstar_arg is not None or has_kwonly_args

1870

1871 if not self.signature_has_generic_args():

1872 if has_star_or_kw_args:

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

1874 self.generate_argument_conversion_code(code)

1875

1876 elif not self.signature_has_nongeneric_args():

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

1878 self.generate_stararg_copy_code(code)

1879

1880 else:

1881 positional_args = []

1882 kw_only_args = []

1883 default_seen = 0

1884 for arg in self.args:

1885 arg_entry = arg.entry

1886 if arg.is_generic:

1887 if arg.default:

1888 default_seen = 1

1889 if not arg.is_self_arg:

1890 if arg.kw_only:

1891 kw_only_args.append(arg)

1892 else:

1893 positional_args.append(arg)

1894 elif arg.kw_only:

1895 kw_only_args.append(arg)

1896 default_seen = 1

1897 elif default_seen:

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

1899 elif not arg.is_self_arg:

1900 positional_args.append(arg)

1901

1902 self.generate_tuple_and_keyword_parsing_code(

1903 positional_args, kw_only_args, end_label, code)

1904

1905 code.error_label = old_error_label

1906 if code.label_used(our_error_label):

1907 if not code.label_used(end_label):

1908 code.put_goto(end_label)

1909 code.put_label(our_error_label)

1910 if has_star_or_kw_args:

1911 self.generate_arg_decref(self.star_arg, code)

1912 if self.starstar_arg:

1913 if self.starstar_arg.entry.xdecref_cleanup:

1914 code.put_var_xdecref(self.starstar_arg.entry)

1915 else:

1916 code.put_var_decref(self.starstar_arg.entry)

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

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

1919 if code.label_used(end_label):

1920 code.put_label(end_label)

1921

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

1923 if arg.type.is_pyobject:

1924 if arg.is_generic:

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

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

1927 else:

1928 func = arg.type.from_py_function

1929 if func:

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

1931 arg.entry.cname,

1932 func,

1933 item,

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

1935 else:

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

1937

1938 def generate_arg_xdecref(self, arg, code):

1939 if arg:

1940 code.put_var_xdecref(arg.entry)

1941

1942 def generate_arg_decref(self, arg, code):

1943 if arg:

1944 code.put_var_decref(arg.entry)

1945

1946 def generate_stararg_copy_code(self, code):

1947 if not self.star_arg:

1948 code.globalstate.use_utility_code(raise_argtuple_invalid_utility_code)

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

1950 Naming.args_cname)

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

1952 self.name.utf8encode(), Naming.args_cname, self.error_value()))

1953 code.putln("}")

1954

1955 code.globalstate.use_utility_code(keyword_string_check_utility_code)

1956

1957 if self.starstar_arg:

1958 if self.star_arg:

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

1960 else:

1961 kwarg_check = "%s" % Naming.kwds_cname

1962 else:

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

1964 Naming.kwds_cname, Naming.kwds_cname)

1965 code.putln(

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

1967 kwarg_check, Naming.kwds_cname, self.name,

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

1969

1970 if self.starstar_arg:

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

1972 self.starstar_arg.entry.cname,

1973 Naming.kwds_cname,

1974 Naming.kwds_cname))

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

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

1977 self.starstar_arg.entry.xdecref_cleanup = 0

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

1979

1980

1981 if self.star_arg:

1982 code.put_incref(Naming.args_cname, py_object_type)

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

1984 self.star_arg.entry.cname,

1985 Naming.args_cname))

1986 self.star_arg.entry.xdecref_cleanup = 0

1987

1988 def generate_tuple_and_keyword_parsing_code(self, positional_args,

1989 kw_only_args, success_label, code):

1990 argtuple_error_label = code.new_label("argtuple_error")

1991

1992 min_positional_args = self.num_required_args - self.num_required_kw_args

1993 if len(self.args) > 0 and self.args[0].is_self_arg:

1994 min_positional_args -= 1

1995 max_positional_args = len(positional_args)

1996 has_fixed_positional_count = not self.star_arg and \

1997 min_positional_args == max_positional_args

1998

1999 code.globalstate.use_utility_code(raise_double_keywords_utility_code)

2000 code.globalstate.use_utility_code(raise_argtuple_invalid_utility_code)

2001 if self.num_required_kw_args:

2002 code.globalstate.use_utility_code(raise_keyword_required_utility_code)

2003

2004 if self.starstar_arg or self.star_arg:

2005 self.generate_stararg_init_code(max_positional_args, code)

2006

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

2008 if self.num_required_kw_args:

2009 likely_hint = "likely"

2010 else:

2011 likely_hint = "unlikely"

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

2013 self.generate_keyword_unpacking_code(

2014 min_positional_args, max_positional_args,

2015 has_fixed_positional_count,

2016 positional_args, kw_only_args, argtuple_error_label, code)

2017

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

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

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

2021 # check the length here

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

2023 compare = '!='

2024 else:

2025 compare = '<'

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

2027 Naming.args_cname, compare, min_positional_args))

2028 code.put_goto(argtuple_error_label)

2029

2030 if self.num_required_kw_args:

2031 # pure error case: keywords required but not passed

2032 if max_positional_args > min_positional_args and not self.star_arg:

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

2034 Naming.args_cname, max_positional_args))

2035 code.put_goto(argtuple_error_label)

2036 code.putln('} else {')

2037 for i, arg in enumerate(kw_only_args):

2038 if not arg.default:

2039 pystring_cname = code.intern_identifier(arg.name)

2040 # required keyword-only argument missing

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

2042 self.name.utf8encode(),

2043 pystring_cname))

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

2045 break

2046

2047 elif min_positional_args == max_positional_args:

2048 # parse the exact number of positional arguments from the

2049 # args tuple

2050 code.putln('} else {')

2051 for i, arg in enumerate(positional_args):

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

2053 self.generate_arg_assignment(arg, item, code)

2054 self.generate_arg_default_assignments(code)

2055

2056 else:

2057 # parse the positional arguments from the variable length

2058 # args tuple

2059 code.putln('} else {')

2060 self.generate_arg_default_assignments(code)

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

2062 if self.star_arg:

2063 code.putln('default:')

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

2065 for i, arg in reversed_args:

2066 if i >= min_positional_args-1:

2067 if min_positional_args > 1:

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

2069 else:

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

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

2072 self.generate_arg_assignment(arg, item, code)

2073 if min_positional_args == 0:

2074 code.put('case 0: ')

2075 code.putln('break;')

2076 if self.star_arg:

2077 if min_positional_args:

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

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

2080 code.put_goto(argtuple_error_label)

2081 else:

2082 code.put('default: ')

2083 code.put_goto(argtuple_error_label)

2084 code.putln('}')

2085

2086 code.putln('}')

2087

2088 if code.label_used(argtuple_error_label):

2089 code.put_goto(success_label)

2090 code.put_label(argtuple_error_label)

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

2092 self.name.utf8encode(), has_fixed_positional_count,

2093 min_positional_args, max_positional_args,

2094 Naming.args_cname))

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

2096

2097 def generate_arg_default_assignments(self, code):

2098 for arg in self.args:

2099 if arg.is_generic and arg.default:

2100 code.putln(

2101 "%s = %s;" % (

2102 arg.entry.cname,

2103 arg.calculate_default_value_code(code)))

2104

2105 def generate_stararg_init_code(self, max_positional_args, code):

2106 if self.starstar_arg:

2107 self.starstar_arg.entry.xdecref_cleanup = 0

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

2109 self.starstar_arg.entry.cname,

2110 self.starstar_arg.entry.cname,

2111 self.error_value()))

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

2113 if self.star_arg:

2114 self.star_arg.entry.xdecref_cleanup = 0

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

2116 Naming.args_cname,

2117 max_positional_args))

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

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

2120 max_positional_args, Naming.args_cname))

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

2122 if self.starstar_arg:

2123 code.putln("")

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

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

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

2127 code.putln('}')

2128 else:

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

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

2131 code.putln('} else {')

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

2133 code.put_incref(Naming.empty_tuple, py_object_type)

2134 code.putln('}')

2135

2136 def generate_keyword_unpacking_code(self, min_positional_args, max_positional_args,

2137 has_fixed_positional_count, positional_args,

2138 kw_only_args, argtuple_error_label, code):

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

2140 max_args = len(all_args)

2141

2142 default_args = []

2143 for i, arg in enumerate(all_args):

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

2145 default_value = arg.calculate_default_value_code(code)

2146 if arg.type is not PyrexTypes.py_object_type:

2147 default_value = "(PyObject*)"+default_value

2148 default_args.append((i, default_value))

2149

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

2151 Naming.kwds_cname)

2152 # it looks funny to separate the init-to-0 from setting the

2153 # default value, but C89 needs this

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

2155 max_args, ','.join(['0']*max_args)))

2156 for i, default_value in default_args:

2157 code.putln('values[%d] = %s;' % (i, default_value))

2158

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

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

2161 if self.star_arg:

2162 code.putln('default:')

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

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

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

2166 i, Naming.args_cname, i))

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

2168 if not self.star_arg:

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

2170 code.put_goto(argtuple_error_label)

2171 code.putln('}')

2172

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

2174 # from the kw dict

2175 if self.num_required_args or max_positional_args > 0:

2176 last_required_arg = -1

2177 for i, arg in enumerate(all_args):

2178 if not arg.default:

2179 last_required_arg = i

2180 if last_required_arg < max_positional_args:

2181 last_required_arg = max_positional_args-1

2182 num_required_args = self.num_required_args

2183 if max_positional_args > 0:

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

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

2186 if max_positional_args > 0 and i <= max_positional_args:

2187 if self.star_arg and i == max_positional_args:

2188 code.putln('default:')

2189 else:

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

2191 pystring_cname = code.intern_identifier(arg.name)

2192 if arg.default:

2193 if arg.kw_only:

2194 # handled separately below

2195 continue

2196 code.putln('if (kw_args > %d) {' % num_required_args)

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

2198 Naming.kwds_cname, pystring_cname))

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

2200 code.putln('}')

2201 else:

2202 num_required_args -= 1

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

2204 i, Naming.kwds_cname, pystring_cname))

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

2206 if i < min_positional_args:

2207 if i == 0:

2208 # special case: we know arg 0 is missing

2209 code.put('else ')

2210 code.put_goto(argtuple_error_label)

2211 else:

2212 # print the correct number of values (args or

2213 # kwargs) that were passed into positional

2214 # arguments up to this point

2215 code.putln('else {')

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

2217 self.name.utf8encode(), has_fixed_positional_count,

2218 min_positional_args, max_positional_args, i))

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

2220 code.putln('}')

2221 elif arg.kw_only:

2222 code.putln('else {')

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

2224 self.name.utf8encode(), pystring_cname))

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

2226 code.putln('}')

2227 if max_positional_args > 0:

2228 code.putln('}')

2229

2230 if kw_only_args and not self.starstar_arg:

2231 # unpack optional keyword-only arguments

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

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

2234 optional_args = []

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

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

2237 continue

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

2239 if optional_args:

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

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

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

2243 for i, arg in optional_args:

2244 pystring_cname = code.intern_identifier(arg.name)

2245 code.putln(

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

2247 Naming.kwds_cname, pystring_cname))

2248 code.putln(

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

2250 code.putln('break;')

2251 code.putln('}')

2252

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

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

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

2256 #

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

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

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

2260 # common cases above.

2261 if max_positional_args == 0:

2262 pos_arg_count = "0"

2263 elif self.star_arg:

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

2265 Naming.args_cname, max_positional_args,

2266 Naming.args_cname, max_positional_args))

2267 pos_arg_count = "used_pos_args"

2268 else:

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

2270 code.globalstate.use_utility_code(parse_keywords_utility_code)

2271 code.put(

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

2273 Naming.kwds_cname,

2274 Naming.pykwdlist_cname,

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

2276 pos_arg_count,

2277 self.name.utf8encode()))

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

2279 code.putln('}')

2280

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

2282 for i, arg in enumerate(all_args):

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

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

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

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

2287 code.putln('} else {')

2288 code.putln(

2289 "%s = %s;" % (

2290 arg.entry.cname,

2291 arg.calculate_default_value_code(code)))

2292 code.putln('}')

2293

2294 def generate_argument_conversion_code(self, code):

2295 # Generate code to convert arguments from

2296 # signature type to declared type, if needed.

2297 for arg in self.args:

2298 if arg.needs_conversion:

2299 self.generate_arg_conversion(arg, code)

2300

2301 def generate_arg_conversion(self, arg, code):

2302 # Generate conversion code for one argument.

2303 old_type = arg.hdr_type

2304 new_type = arg.type

2305 if old_type.is_pyobject:

2306 if arg.default:

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

2308 else:

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

2310 self.generate_arg_conversion_from_pyobject(arg, code)

2311 code.putln("}")

2312 elif new_type.is_pyobject:

2313 self.generate_arg_conversion_to_pyobject(arg, code)

2314 else:

2315 if new_type.assignable_from(old_type):

2316 code.putln(

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

2318 else:

2319 error(arg.pos,

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

2321 (old_type, new_type))

2322

2323 def generate_arg_conversion_from_pyobject(self, arg, code):

2324 new_type = arg.type

2325 func = new_type.from_py_function

2326 # copied from CoerceFromPyTypeNode

2327 if func:

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

2329 arg.entry.cname,

2330 func,

2331 arg.hdr_cname,

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

2333 else:

2334 error(arg.pos,

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

2336 % new_type)

2337

2338 def generate_arg_conversion_to_pyobject(self, arg, code):

2339 old_type = arg.hdr_type

2340 func = old_type.to_py_function

2341 if func:

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

2343 arg.entry.cname,

2344 func,

2345 arg.hdr_cname,

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

2347 code.put_var_gotref(arg.entry)

2348 else:

2349 error(arg.pos,

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

2351 % old_type)

2352

2353 def generate_argument_type_tests(self, code):

2354 # Generate type tests for args whose signature

2355 # type is PyObject * and whose declared type is

2356 # a subtype thereof.

2357 for arg in self.args:

2358 if arg.needs_type_test:

2359 self.generate_arg_type_test(arg, code)

2360

2361 def generate_arg_type_test(self, arg, code):

2362 # Generate type test for one argument.

2363 if arg.type.typeobj_is_available():

2364 typeptr_cname = arg.type.typeptr_cname

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

2366 code.putln(

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

2368 arg_code,

2369 typeptr_cname,

2370 not arg.not_none,

2371 arg.name,

2372 arg.type.is_builtin_type,

2373 code.error_goto(arg.pos)))

2374 else:

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

2376 "without type object name specification")

2377

2378 def error_value(self):

2379 return self.entry.signature.error_value

2380

2381 def caller_will_check_exceptions(self):

2382 return 1

2383

2384 class OverrideCheckNode(StatNode):

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

2386 # is overriden.

2387 #

2388 # py_func

2389 #

2390 # args

2391 # func_temp

2392 # body

2393

2394 child_attrs = ['body']

2395

2396 body = None

2397

2398 def analyse_expressions(self, env):

2399 self.args = env.arg_entries

2400 if self.py_func.is_module_scope:

2401 first_arg = 0

2402 else:

2403 first_arg = 1

2404 import ExprNodes

2405 self.func_node = ExprNodes.PyTempNode(self.pos, env)

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

2407 call_node = ExprNodes.SimpleCallNode(self.pos,

2408 function=self.func_node,

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

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

2411 self.body.analyse_expressions(env)

2412

2413 def generate_execution_code(self, code):

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

2415 # Check to see if we are an extension type

2416 if self.py_func.is_module_scope:

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

2418 else:

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

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

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

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

2423 if self.py_func.is_module_scope:

2424 code.putln("else {")

2425 else:

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

2427 self.func_node.allocate(code)

2428 err = code.error_goto_if_null(self.func_node.result(), self.pos)

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

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

2431 self.func_node.result(), self_arg, interned_attr_cname, err))

2432 code.put_gotref(self.func_node.py_result())

2433 is_builtin_function_or_method = 'PyCFunction_Check(%s)' % self.func_node.result()

2434 is_overridden = '(PyCFunction_GET_FUNCTION(%s) != (void *)&%s)' % (

2435 self.func_node.result(), self.py_func.entry.func_cname)

2436 code.putln('if (!%s || %s) {' % (is_builtin_function_or_method, is_overridden))

2437 self.body.generate_execution_code(code)

2438 code.putln('}')

2439 code.put_decref_clear(self.func_node.result(), PyrexTypes.py_object_type)

2440 code.putln("}")

2441 self.func_node.release(code)

2442

2443 class ClassDefNode(StatNode, BlockNode):

2444 pass

2445

2446 class PyClassDefNode(ClassDefNode):

2447 # A Python class definition.

2448 #

2449 # name EncodedString Name of the class

2450 # doc string or None

2451 # body StatNode Attribute definition code

2452 # entry Symtab.Entry

2453 # scope PyClassScope

2454 #

2455 # The following subnodes are constructed internally:

2456 #

2457 # dict DictNode Class dictionary

2458 # classobj ClassNode Class object

2459 # target NameNode Variable to assign class object to

2460

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

2462

2463 def __init__(self, pos, name, bases, doc, body):

2464 StatNode.__init__(self, pos)

2465 self.name = name

2466 self.doc = doc

2467 self.body = body

2468 import ExprNodes

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

2470 if self.doc and Options.docstrings:

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

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

2473 else:

2474 doc_node = None

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

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

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

2478

2479 def as_cclass(self):

2480 """

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

2482 """

2483 bases = self.classobj.bases.args

2484 if len(bases) == 0:

2485 base_class_name = None

2486 base_class_module = None

2487 elif len(bases) == 1:

2488 base = bases[0]

2489 path = []

2490 from ExprNodes import AttributeNode, NameNode

2491 while isinstance(base, AttributeNode):

2492 path.insert(0, base.attribute)

2493 base = base.obj

2494 if isinstance(base, NameNode):

2495 path.insert(0, base.name)

2496 base_class_name = path[-1]

2497 if len(path) > 1:

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

2499 else:

2500 base_class_module = None

2501 else:

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

2503 else:

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

2505 return None

2506

2507 return CClassDefNode(self.pos,

2508 visibility = 'private',

2509 module_name = None,

2510 class_name = self.name,

2511 base_class_module = base_class_module,

2512 base_class_name = base_class_name,

2513 body = self.body,

2514 in_pxd = False,

2515 doc = self.doc)

2516

2517 def create_scope(self, env):

2518 genv = env

2519 while env.is_py_class_scope or env.is_c_class_scope:

2520 env = env.outer_scope

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

2522 return cenv

2523

2524 def analyse_declarations(self, env):

2525 self.target.analyse_target_declaration(env)

2526 cenv = self.create_scope(env)

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

2528 self.body.analyse_declarations(cenv)

2529

2530 def analyse_expressions(self, env):

2531 self.dict.analyse_expressions(env)

2532 self.classobj.analyse_expressions(env)

2533 genv = env.global_scope()

2534 cenv = self.scope

2535 self.body.analyse_expressions(cenv)

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

2537

2538 def generate_function_definitions(self, env, code):

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

2540

2541 def generate_execution_code(self, code):

2542 code.pyclass_stack.append(self)

2543 cenv = self.scope

2544 self.dict.generate_evaluation_code(code)

2545 self.classobj.generate_evaluation_code(code)

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

2547 self.body.generate_execution_code(code)

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

2549 self.dict.generate_disposal_code(code)

2550 self.dict.free_temps(code)

2551 code.pyclass_stack.pop()

2552

2553

2554 class CClassDefNode(ClassDefNode):

2555 # An extension type definition.

2556 #

2557 # visibility 'private' or 'public' or 'extern'

2558 # typedef_flag boolean

2559 # api boolean

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

2561 # class_name string Unqualified name of class

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

2563 # base_class_module string or None Module containing the base class

2564 # base_class_name string or None Name of the base class

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

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

2567 # in_pxd boolean Is in a .pxd file

2568 # doc string or None

2569 # body StatNode or None

2570 # entry Symtab.Entry

2571 # base_type PyExtensionType or None

2572 # buffer_defaults_node DictNode or None Declares defaults for a buffer

2573 # buffer_defaults_pos

2574

2575 child_attrs = ["body"]

2576 buffer_defaults_node = None

2577 buffer_defaults_pos = None

2578 typedef_flag = False

2579 api = False

2580 objstruct_name = None

2581 typeobj_name = None

2582

2583 def analyse_declarations(self, env):

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

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

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

2587

2588 import Buffer

2589 if self.buffer_defaults_node:

2590 buffer_defaults = Buffer.analyse_buffer_options(self.buffer_defaults_pos,

2591 env, [], self.buffer_defaults_node,

2592 need_complete=False)

2593 else:

2594 buffer_defaults = None

2595

2596 if env.in_cinclude and not self.objstruct_name:

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

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

2599 self.base_type = None

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

2601 # import the modules for extern classes.

2602 if self.module_name:

2603 self.module = None

2604 for module in env.cimported_modules:

2605 if module.name == self.module_name:

2606 self.module = module

2607 if self.module is None:

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

2609 self.module.has_extern_class = 1

2610 env.add_imported_module(self.module)

2611

2612 if self.base_class_name:

2613 if self.base_class_module:

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

2615 else:

2616 base_class_scope = env

2617 if self.base_class_name == 'object':

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

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

2620 self.base_class_name = None

2621 self.base_class_module = None

2622 base_class_scope = None

2623 if base_class_scope:

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

2625 if base_class_entry:

2626 if not base_class_entry.is_type:

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

2628 elif not base_class_entry.type.is_extension_type:

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

2630 elif not base_class_entry.type.is_complete():

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

2632 else:

2633 self.base_type = base_class_entry.type

2634 has_body = self.body is not None

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

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

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

2638 if not home_scope:

2639 return

2640 else:

2641 home_scope = env

2642

2643 if self.visibility == 'extern':

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

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

2646

2647 self.entry = home_scope.declare_c_class(

2648 name = self.class_name,

2649 pos = self.pos,

2650 defining = has_body and self.in_pxd,

2651 implementing = has_body and not self.in_pxd,

2652 module_name = self.module_name,

2653 base_type = self.base_type,

2654 objstruct_cname = self.objstruct_name,

2655 typeobj_cname = self.typeobj_name,

2656 visibility = self.visibility,

2657 typedef_flag = self.typedef_flag,

2658 api = self.api,

2659 buffer_defaults = buffer_defaults)

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

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

2662 scope = self.entry.type.scope

2663

2664 if self.doc and Options.docstrings:

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

2666

2667 if has_body:

2668 self.body.analyse_declarations(scope)

2669 if self.in_pxd:

2670 scope.defined = 1

2671 else:

2672 scope.implemented = 1

2673 env.allocate_vtable_names(self.entry)

2674

2675 def analyse_expressions(self, env):

2676 if self.body:

2677 scope = self.entry.type.scope

2678 self.body.analyse_expressions(scope)

2679

2680 def generate_function_definitions(self, env, code):

2681 if self.body:

2682 self.body.generate_function_definitions(

2683 self.entry.type.scope, code)

2684

2685 def generate_execution_code(self, code):

2686 # This is needed to generate evaluation code for

2687 # default values of method arguments.

2688 if self.body:

2689 self.body.generate_execution_code(code)

2690

2691 def annotate(self, code):

2692 if self.body:

2693 self.body.annotate(code)

2694

2695

2696 class PropertyNode(StatNode):

2697 # Definition of a property in an extension type.

2698 #

2699 # name string

2700 # doc EncodedString or None Doc string

2701 # body StatListNode

2702

2703 child_attrs = ["body"]

2704

2705 def analyse_declarations(self, env):

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

2707 if entry:

2708 self.body.analyse_declarations(entry.scope)

2709

2710 def analyse_expressions(self, env):

2711 self.body.analyse_expressions(env)

2712

2713 def generate_function_definitions(self, env, code):

2714 self.body.generate_function_definitions(env, code)

2715

2716 def generate_execution_code(self, code):

2717 pass

2718

2719 def annotate(self, code):

2720 self.body.annotate(code)

2721

2722

2723 class GlobalNode(StatNode):

2724 # Global variable declaration.

2725 #

2726 # names [string]

2727

2728 child_attrs = []

2729

2730 def analyse_declarations(self, env):

2731 for name in self.names:

2732 env.declare_global(name, self.pos)

2733

2734 def analyse_expressions(self, env):

2735 pass

2736

2737 def generate_execution_code(self, code):

2738 pass

2739

2740

2741 class ExprStatNode(StatNode):

2742 # Expression used as a statement.

2743 #

2744 # expr ExprNode

2745

2746 child_attrs = ["expr"]

2747

2748 def analyse_declarations(self, env):

2749 import ExprNodes

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

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

2752 if func == u'declare':

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

2754 if len(args):

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

2756 for var, type_node in kwds.key_value_pairs:

2757 type = type_node.analyse_as_type(env)

2758 if type is None:

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

2760 else:

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

2762 self.__class__ = PassStatNode

2763

2764 def analyse_expressions(self, env):

2765 self.expr.analyse_expressions(env)

2766

2767 def generate_execution_code(self, code):

2768 self.expr.generate_evaluation_code(code)

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

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

2771 self.expr.generate_disposal_code(code)

2772 self.expr.free_temps(code)

2773

2774 def annotate(self, code):

2775 self.expr.annotate(code)

2776

2777

2778 class AssignmentNode(StatNode):

2779 # Abstract base class for assignment nodes.

2780 #

2781 # The analyse_expressions and generate_execution_code

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

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

2784 # parallel assignment to be evaluated before assigning

2785 # to any of the left hand sides.

2786

2787 def analyse_expressions(self, env):

2788 self.analyse_types(env)

2789

2790 # def analyse_expressions(self, env):

2791 # self.analyse_expressions_1(env)

2792 # self.analyse_expressions_2(env)

2793

2794 def generate_execution_code(self, code):

2795 self.generate_rhs_evaluation_code(code)

2796 self.generate_assignment_code(code)

2797

2798

2799 class SingleAssignmentNode(AssignmentNode):

2800 # The simplest case:

2801 #

2802 # a = b

2803 #

2804 # lhs ExprNode Left hand side

2805 # rhs ExprNode Right hand side

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

2807

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

2809 first = False

2810 declaration_only = False

2811

2812 def analyse_declarations(self, env):

2813 import ExprNodes

2814

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

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

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

2818 if func_name:

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

2820

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

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

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

2824 return

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

2826 if type is None:

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

2828 return

2829 lhs = self.lhs

2830 if func_name == 'declare':

2831 if isinstance(lhs, ExprNodes.NameNode):

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

2833 elif isinstance(lhs, ExprNodes.TupleNode):

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

2835 else:

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

2837 return

2838 for var, pos in vars:

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

2840 if len(args) == 2:

2841 # we have a value

2842 self.rhs = args[1]

2843 else:

2844 self.declaration_only = True

2845 else:

2846 self.declaration_only = True

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

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

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

2850

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

2852 self.declaration_only = True

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

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

2855 return

2856 members = []

2857 for member, type_node in kwds.key_value_pairs:

2858 type = type_node.analyse_as_type(env)

2859 if type is None:

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

2861 else:

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

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

2864 return

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

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

2867 name = self.lhs.name

2868 scope = StructOrUnionScope(name)

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

2870 for member, type, pos in members:

2871 scope.declare_var(member, type, pos)

2872

2873 if self.declaration_only:

2874 return

2875 else:

2876 self.lhs.analyse_target_declaration(env)

2877

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

2879 self.rhs.analyse_types(env)

2880 self.lhs.analyse_target_types(env)

2881 self.lhs.gil_assignment_check(env)

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

2883 if use_temp:

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

2885

2886 def generate_rhs_evaluation_code(self, code):

2887 self.rhs.generate_evaluation_code(code)

2888

2889 def generate_assignment_code(self, code):

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

2891

2892 def annotate(self, code):

2893 self.lhs.annotate(code)

2894 self.rhs.annotate(code)

2895

2896

2897 class CascadedAssignmentNode(AssignmentNode):

2898 # An assignment with multiple left hand sides:

2899 #

2900 # a = b = c

2901 #

2902 # lhs_list [ExprNode] Left hand sides

2903 # rhs ExprNode Right hand sides

2904 #

2905 # Used internally:

2906 #

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

2908

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

2910 coerced_rhs_list = None

2911

2912 def analyse_declarations(self, env):

2913 for lhs in self.lhs_list:

2914 lhs.analyse_target_declaration(env)

2915

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

2917 self.rhs.analyse_types(env)

2918 if use_temp:

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

2920 else:

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

2922 from ExprNodes import CloneNode

2923 self.coerced_rhs_list = []

2924 for lhs in self.lhs_list:

2925 lhs.analyse_target_types(env)

2926 lhs.gil_assignment_check(env)

2927 rhs = CloneNode(self.rhs)

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

2929 self.coerced_rhs_list.append(rhs)

2930

2931 def generate_rhs_evaluation_code(self, code):

2932 self.rhs.generate_evaluation_code(code)

2933

2934 def generate_assignment_code(self, code):

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

2936 lhs = self.lhs_list[i]

2937 rhs = self.coerced_rhs_list[i]

2938 rhs.generate_evaluation_code(code)

2939 lhs.generate_assignment_code(rhs, code)

2940 # Assignment has disposed of the cloned RHS

2941 self.rhs.generate_disposal_code(code)

2942 self.rhs.free_temps(code)

2943

2944 def annotate(self, code):

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

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

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

2948 self.rhs.annotate(code)

2949

2950

2951 class ParallelAssignmentNode(AssignmentNode):

2952 # A combined packing/unpacking assignment:

2953 #

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

2955 #

2956 # This has been rearranged by the parser into

2957 #

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

2959 #

2960 # but we must evaluate all the right hand sides

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

2962 #

2963 # stats [AssignmentNode] The constituent assignments

2964

2965 child_attrs = ["stats"]

2966

2967 def analyse_declarations(self, env):

2968 for stat in self.stats:

2969 stat.analyse_declarations(env)

2970

2971 def analyse_expressions(self, env):

2972 for stat in self.stats:

2973 stat.analyse_types(env, use_temp = 1)

2974

2975 # def analyse_expressions(self, env):

2976 # for stat in self.stats:

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

2978 # for stat in self.stats:

2979 # stat.analyse_expressions_2(env)

2980

2981 def generate_execution_code(self, code):

2982 for stat in self.stats:

2983 stat.generate_rhs_evaluation_code(code)

2984 for stat in self.stats:

2985 stat.generate_assignment_code(code)

2986

2987 def annotate(self, code):

2988 for stat in self.stats:

2989 stat.annotate(code)

2990

2991

2992 class InPlaceAssignmentNode(AssignmentNode):

2993 # An in place arithmatic operand:

2994 #

2995 # a += b

2996 # a -= b

2997 # ...

2998 #

2999 # lhs ExprNode Left hand side

3000 # rhs ExprNode Right hand side

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

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

3003 #

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

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

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

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

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

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

3010

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

3012 dup = None

3013

3014 def analyse_declarations(self, env):

3015 self.lhs.analyse_target_declaration(env)

3016

3017 def analyse_types(self, env):

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

3019 self.rhs.analyse_types(env)

3020 self.lhs.analyse_target_types(env)

3021 if Options.incref_local_binop and self.dup.type.is_pyobject:

3022 self.dup = self.dup.coerce_to_temp(env)

3023 import ExprNodes

3024 if self.lhs.type.is_pyobject:

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

3026 elif self.rhs.type.is_pyobject:

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

3028 if self.lhs.type.is_pyobject:

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

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

3031

3032 def generate_execution_code(self, code):

3033 import ExprNodes

3034 self.rhs.generate_evaluation_code(code)

3035 self.dup.generate_subexpr_evaluation_code(code)

3036 if self.dup.is_temp:

3037 self.dup.allocate_temp_result(code)

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

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

3040 extra = ", Py_None"

3041 else:

3042 extra = ""

3043 if self.lhs.type.is_pyobject:

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

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

3046 self.dup.generate_result_code(code)

3047 self.result_value_temp.allocate(code)

3048 code.putln(

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

3050 self.result_value.result(),

3051 self.py_operation_function(),

3052 self.dup.py_result(),

3053 self.rhs.py_result(),

3054 extra,

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

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

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

3058 self.rhs.generate_disposal_code(code)

3059 self.rhs.free_temps(code)

3060 self.dup.generate_disposal_code(code)

3061 self.dup.free_temps(code)

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

3063 self.result_value_temp.release(code)

3064 else:

3065 c_op = self.operator

3066 if c_op == "//":

3067 c_op = "/"

3068 elif c_op == "**":

3069 if self.lhs.type.is_int and self.rhs.type.is_int:

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

3071 else:

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

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

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

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

3076 else:

3077 self.dup.generate_result_code(code)

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

3079 self.rhs.generate_disposal_code(code)

3080 self.rhs.free_temps(code)

3081 if self.dup.is_temp:

3082 self.dup.generate_subexpr_disposal_code(code)

3083 self.dup.free_subexpr_temps(code)

3084

3085 def create_dup_node(self, env):

3086 import ExprNodes

3087 self.dup = self.lhs

3088 self.dup.analyse_types(env)

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

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

3091 name = self.dup.name,

3092 is_temp = self.dup.is_temp,

3093 entry = self.dup.entry)

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

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

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

3097 attribute = self.dup.attribute,

3098 is_temp = self.dup.is_temp)

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

3100 if self.lhs.index:

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

3102 else:

3103 index = None

3104 if self.lhs.indices:

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

3106 else:

3107 indices = []

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

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

3110 index = index,

3111 indices = indices,

3112 is_temp = self.dup.is_temp)

3113 else:

3114 assert False

3115 self.lhs = target_lhs

3116 return self.dup

3117

3118 def py_operation_function(self):

3119 return self.py_functions[self.operator]

3120

3121 py_functions = {

3122 "|": "PyNumber_InPlaceOr",

3123 "^": "PyNumber_InPlaceXor",

3124 "&": "PyNumber_InPlaceAnd",

3125 "+": "PyNumber_InPlaceAdd",

3126 "-": "PyNumber_InPlaceSubtract",

3127 "*": "PyNumber_InPlaceMultiply",

3128 "/": "PyNumber_InPlaceDivide",

3129 "%": "PyNumber_InPlaceRemainder",

3130 "<<": "PyNumber_InPlaceLshift",

3131 ">>": "PyNumber_InPlaceRshift",

3132 "**": "PyNumber_InPlacePower",

3133 "//": "PyNumber_InPlaceFloorDivide",

3134 }

3135

3136 def annotate(self, code):

3137 self.lhs.annotate(code)

3138 self.rhs.annotate(code)

3139 self.dup.annotate(code)

3140

3141

3142 class PrintStatNode(StatNode):

3143 # print statement

3144 #

3145 # arg_tuple TupleNode

3146 # append_newline boolean

3147

3148 child_attrs = ["arg_tuple"]

3149

3150 def analyse_expressions(self, env):

3151 self.arg_tuple.analyse_expressions(env)

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

3153 env.use_utility_code(printing_utility_code)

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

3155 env.use_utility_code(printing_one_utility_code)

3156

3157 gil_check = StatNode._gil_check

3158 gil_message = "Python print statement"

3159

3160 def generate_execution_code(self, code):

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

3162 arg = self.arg_tuple.args[0]

3163 arg.generate_evaluation_code(code)

3164

3165 code.putln(

3166 "if (__Pyx_PrintOne(%s) < 0) %s" % (

3167 arg.py_result(),

3168 code.error_goto(self.pos)))

3169 arg.generate_disposal_code(code)

3170 arg.free_temps(code)

3171 else:

3172 self.arg_tuple.generate_evaluation_code(code)

3173 code.putln(

3174 "if (__Pyx_Print(%s, %d) < 0) %s" % (

3175 self.arg_tuple.py_result(),

3176 self.append_newline,

3177 code.error_goto(self.pos)))

3178 self.arg_tuple.generate_disposal_code(code)

3179 self.arg_tuple.free_temps(code)

3180

3181 def annotate(self, code):

3182 self.arg_tuple.annotate(code)

3183

3184

3185 class ExecStatNode(StatNode):

3186 # exec statement

3187 #

3188 # args [ExprNode]

3189

3190 child_attrs = ["args"]

3191

3192 def analyse_expressions(self, env):

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

3194 arg.analyse_expressions(env)

3195 arg = arg.coerce_to_pyobject(env)

3196 self.args[i] = arg

3197 env.use_utility_code(Builtin.pyexec_utility_code)

3198

3199 gil_check = StatNode._gil_check

3200 gil_message = "Python exec statement"

3201

3202 def generate_execution_code(self, code):

3203 args = []

3204 for arg in self.args:

3205 arg.generate_evaluation_code(code)

3206 args.append( arg.py_result() )

3207 args = tuple(args + ['0', '0'][:3-len(args)])

3208 temp_result = code.funcstate.allocate_temp(PyrexTypes.py_object_type, manage_ref=True)

3209 code.putln("%s = __Pyx_PyRun(%s, %s, %s);" % (

3210 (temp_result,) + args))

3211 for arg in self.args:

3212 arg.generate_disposal_code(code)

3213 arg.free_temps(code)

3214 code.putln(

3215 code.error_goto_if_null(temp_result, self.pos))

3216 code.put_gotref(temp_result)

3217 code.put_decref_clear(temp_result, py_object_type)

3218 code.funcstate.release_temp(temp_result)

3219

3220 def annotate(self, code):

3221 for arg in self.args:

3222 arg.annotate(code)

3223

3224

3225 class DelStatNode(StatNode):

3226 # del statement

3227 #

3228 # args [ExprNode]

3229

3230 child_attrs = ["args"]

3231

3232 def analyse_declarations(self, env):

3233 for arg in self.args:

3234 arg.analyse_target_declaration(env)

3235

3236 def analyse_expressions(self, env):

3237 for arg in self.args:

3238 arg.analyse_target_expression(env, None)

3239 if not arg.type.is_pyobject:

3240 error(arg.pos, "Deletion of non-Python object")

3241 #arg.release_target_temp(env)

3242

3243 def gil_check(self, env):

3244 for arg in self.args:

3245 if arg.type.is_pyobject:

3246 self._gil_check(env)

3247

3248 gil_message = "Deleting Python object"

3249

3250 def generate_execution_code(self, code):

3251 for arg in self.args:

3252 if arg.type.is_pyobject:

3253 arg.generate_deletion_code(code)

3254 # else error reported earlier

3255

3256 def annotate(self, code):

3257 for arg in self.args:

3258 arg.annotate(code)

3259

3260

3261 class PassStatNode(StatNode):

3262 # pass statement

3263

3264 child_attrs = []

3265

3266 def analyse_expressions(self, env):

3267 pass

3268

3269 def generate_execution_code(self, code):

3270 pass

3271

3272

3273 class BreakStatNode(StatNode):

3274

3275 child_attrs = []

3276

3277 def analyse_expressions(self, env):

3278 pass

3279

3280 def generate_execution_code(self, code):

3281 if not code.break_label:

3282 error(self.pos, "break statement not inside loop")

3283 else:

3284 code.put_goto(code.break_label)

3285

3286

3287 class ContinueStatNode(StatNode):

3288

3289 child_attrs = []

3290

3291 def analyse_expressions(self, env):

3292 pass

3293

3294 def generate_execution_code(self, code):

3295 if code.funcstate.in_try_finally:

3296 error(self.pos, "continue statement inside try of try...finally")

3297 elif not code.continue_label:

3298 error(self.pos, "continue statement not inside loop")

3299 else:

3300 code.put_goto(code.continue_label)

3301

3302

3303 class ReturnStatNode(StatNode):

3304 # return statement

3305 #

3306 # value ExprNode or None

3307 # return_type PyrexType

3308

3309 child_attrs = ["value"]

3310

3311 def analyse_expressions(self, env):

3312 return_type = env.return_type

3313 self.return_type = return_type

3314 if not return_type:

3315 error(self.pos, "Return not inside a function body")

3316 return

3317 if self.value:

3318 self.value.analyse_types(env)

3319 if return_type.is_void or return_type.is_returncode:

3320 error(self.value.pos,

3321 "Return with value in void function")

3322 else:

3323 self.value = self.value.coerce_to(env.return_type, env)

3324 else:

3325 if (not return_type.is_void

3326 and not return_type.is_pyobject

3327 and not return_type.is_returncode):

3328 error(self.pos, "Return value required")

3329

3330 def gil_check(self, env):

3331 if self.return_type.is_pyobject:

3332 self._gil_check(env)

3333

3334 gil_message = "Returning Python object"

3335

3336 def generate_execution_code(self, code):

3337 code.mark_pos(self.pos)

3338 if not self.return_type:

3339 # error reported earlier

3340 return

3341 if self.return_type.is_pyobject:

3342 code.put_xdecref(Naming.retval_cname,

3343 self.return_type)

3344 if self.value:

3345 self.value.generate_evaluation_code(code)

3346 self.value.make_owned_reference(code)

3347 code.putln(

3348 "%s = %s;" % (

3349 Naming.retval_cname,

3350 self.value.result_as(self.return_type)))

3351 self.value.generate_post_assignment_code(code)

3352 self.value.free_temps(code)

3353 else:

3354 if self.return_type.is_pyobject:

3355 code.put_init_to_py_none(Naming.retval_cname, self.return_type)

3356 elif self.return_type.is_returncode:

3357 code.putln(

3358 "%s = %s;" % (

3359 Naming.retval_cname,

3360 self.return_type.default_value))

3361 for cname, type in code.funcstate.temps_holding_reference():

3362 code.put_decref_clear(cname, type)

3363 code.put_goto(code.return_label)

3364

3365 def annotate(self, code):

3366 if self.value:

3367 self.value.annotate(code)

3368

3369

3370 class RaiseStatNode(StatNode):

3371 # raise statement

3372 #

3373 # exc_type ExprNode or None

3374 # exc_value ExprNode or None

3375 # exc_tb ExprNode or None

3376

3377 child_attrs = ["exc_type", "exc_value", "exc_tb"]

3378

3379 def analyse_expressions(self, env):

3380 if self.exc_type:

3381 self.exc_type.analyse_types(env)

3382 self.exc_type = self.exc_type.coerce_to_pyobject(env)

3383 if self.exc_value:

3384 self.exc_value.analyse_types(env)

3385 self.exc_value = self.exc_value.coerce_to_pyobject(env)

3386 if self.exc_tb:

3387 self.exc_tb.analyse_types(env)

3388 self.exc_tb = self.exc_tb.coerce_to_pyobject(env)

3389 env.use_utility_code(raise_utility_code)

3390 env.use_utility_code(restore_exception_utility_code)

3391

3392 gil_check = StatNode._gil_check

3393 gil_message = "Raising exception"

3394

3395 def generate_execution_code(self, code):

3396 if self.exc_type:

3397 self.exc_type.generate_evaluation_code(code)

3398 type_code = self.exc_type.py_result()

3399 else:

3400 type_code = "0"

3401 if self.exc_value:

3402 self.exc_value.generate_evaluation_code(code)

3403 value_code = self.exc_value.py_result()

3404 else:

3405 value_code = "0"

3406 if self.exc_tb:

3407 self.exc_tb.generate_evaluation_code(code)

3408 tb_code = self.exc_tb.py_result()

3409 else:

3410 tb_code = "0"

3411 if self.exc_type or self.exc_value or self.exc_tb:

3412 code.putln(

3413 "__Pyx_Raise(%s, %s, %s);" % (

3414 type_code,

3415 value_code,

3416 tb_code))

3417 else:

3418 code.putln(

3419 "__Pyx_ReRaise();")

3420 for obj in (self.exc_type, self.exc_value, self.exc_tb):

3421 if obj:

3422 obj.generate_disposal_code(code)

3423 obj.free_temps(code)

3424 code.putln(

3425 code.error_goto(self.pos))

3426

3427 def annotate(self, code):

3428 if self.exc_type:

3429 self.exc_type.annotate(code)

3430 if self.exc_value:

3431 self.exc_value.annotate(code)

3432 if self.exc_tb:

3433 self.exc_tb.annotate(code)

3434

3435

3436 class ReraiseStatNode(StatNode):

3437

3438 child_attrs = []

3439

3440 def analyse_expressions(self, env):

3441 env.use_utility_code(raise_utility_code)

3442 env.use_utility_code(restore_exception_utility_code)

3443

3444 gil_check = StatNode._gil_check

3445 gil_message = "Raising exception"

3446

3447 def generate_execution_code(self, code):

3448 vars = code.funcstate.exc_vars

3449 if vars:

3450 code.putln("__Pyx_Raise(%s, %s, %s);" % tuple(vars))

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

3452 else:

3453 error(self.pos, "Reraise not inside except clause")

3454

3455

3456 class AssertStatNode(StatNode):

3457 # assert statement

3458 #

3459 # cond ExprNode

3460 # value ExprNode or None

3461

3462 child_attrs = ["cond", "value"]

3463

3464 def analyse_expressions(self, env):

3465 self.cond = self.cond.analyse_boolean_expression(env)

3466 if self.value:

3467 self.value.analyse_types(env)

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

3469

3470 gil_check = StatNode._gil_check

3471 gil_message = "Raising exception"

3472

3473 def generate_execution_code(self, code):

3474 code.putln("#ifndef PYREX_WITHOUT_ASSERTIONS")

3475 self.cond.generate_evaluation_code(code)

3476 code.putln(

3477 "if (unlikely(!%s)) {" %

3478 self.cond.result())

3479 if self.value:

3480 self.value.generate_evaluation_code(code)

3481 code.putln(

3482 "PyErr_SetObject(PyExc_AssertionError, %s);" %

3483 self.value.py_result())

3484 self.value.generate_disposal_code(code)

3485 self.value.free_temps(code)

3486 else:

3487 code.putln(

3488 "PyErr_SetNone(PyExc_AssertionError);")

3489 code.putln(

3490 code.error_goto(self.pos))

3491 code.putln(

3492 "}")

3493 self.cond.generate_disposal_code(code)

3494 self.cond.free_temps(code)

3495 code.putln("#endif")

3496

3497 def annotate(self, code):

3498 self.cond.annotate(code)

3499 if self.value:

3500 self.value.annotate(code)

3501

3502

3503 class IfStatNode(StatNode):

3504 # if statement

3505 #

3506 # if_clauses [IfClauseNode]

3507 # else_clause StatNode or None

3508

3509 child_attrs = ["if_clauses", "else_clause"]

3510

3511 def analyse_control_flow(self, env):

3512 env.start_branching(self.pos)

3513 for if_clause in self.if_clauses:

3514 if_clause.analyse_control_flow(env)

3515 env.next_branch(if_clause.end_pos())

3516 if self.else_clause:

3517 self.else_clause.analyse_control_flow(env)

3518 env.finish_branching(self.end_pos())

3519

3520 def analyse_declarations(self, env):

3521 for if_clause in self.if_clauses:

3522 if_clause.analyse_declarations(env)

3523 if self.else_clause:

3524 self.else_clause.analyse_declarations(env)

3525

3526 def analyse_expressions(self, env):

3527 for if_clause in self.if_clauses:

3528 if_clause.analyse_expressions(env)

3529 if self.else_clause:

3530 self.else_clause.analyse_expressions(env)

3531

3532 def generate_execution_code(self, code):

3533 code.mark_pos(self.pos)

3534 end_label = code.new_label()

3535 for if_clause in self.if_clauses:

3536 if_clause.generate_execution_code(code, end_label)

3537 if self.else_clause:

3538 code.putln("/*else*/ {")

3539 self.else_clause.generate_execution_code(code)

3540 code.putln("}")

3541 code.put_label(end_label)

3542

3543 def annotate(self, code):

3544 for if_clause in self.if_clauses:

3545 if_clause.annotate(code)

3546 if self.else_clause:

3547 self.else_clause.annotate(code)

3548

3549

3550 class IfClauseNode(Node):

3551 # if or elif clause in an if statement

3552 #

3553 # condition ExprNode

3554 # body StatNode

3555

3556 child_attrs = ["condition", "body"]

3557

3558 def analyse_control_flow(self, env):

3559 self.body.analyse_control_flow(env)

3560

3561 def analyse_declarations(self, env):

3562 self.condition.analyse_declarations(env)

3563 self.body.analyse_declarations(env)

3564

3565 def analyse_expressions(self, env):

3566 self.condition = \

3567 self.condition.analyse_temp_boolean_expression(env)

3568 self.body.analyse_expressions(env)

3569

3570 def generate_execution_code(self, code, end_label):

3571 self.condition.generate_evaluation_code(code)

3572 code.putln(

3573 "if (%s) {" %

3574 self.condition.result())

3575 self.condition.generate_disposal_code(code)

3576 self.condition.free_temps(code)

3577 self.body.generate_execution_code(code)

3578 #code.putln(

3579 # "goto %s;" %

3580 # end_label)

3581 code.put_goto(end_label)

3582 code.putln("}")

3583

3584 def annotate(self, code):

3585 self.condition.annotate(code)

3586 self.body.annotate(code)

3587

3588

3589 class SwitchCaseNode(StatNode):

3590 # Generated in the optimization of an if-elif-else node

3591 #

3592 # conditions [ExprNode]

3593 # body StatNode

3594

3595 child_attrs = ['conditions', 'body']

3596

3597 def generate_execution_code(self, code):

3598 for cond in self.conditions:

3599 code.mark_pos(cond.pos)

3600 cond.generate_evaluation_code(code)

3601 code.putln("case %s:" % cond.result())

3602 self.body.generate_execution_code(code)

3603 code.putln("break;")

3604

3605 def annotate(self, code):

3606 for cond in self.conditions:

3607 cond.annotate(code)

3608 self.body.annotate(code)

3609

3610 class SwitchStatNode(StatNode):

3611 # Generated in the optimization of an if-elif-else node

3612 #

3613 # test ExprNode

3614 # cases [SwitchCaseNode]

3615 # else_clause StatNode or None

3616

3617 child_attrs = ['test', 'cases', 'else_clause']

3618

3619 def generate_execution_code(self, code):

3620 code.putln("switch (%s) {" % self.test.result())

3621 for case in self.cases:

3622 case.generate_execution_code(code)

3623 if self.else_clause is not None:

3624 code.putln("default:")

3625 self.else_clause.generate_execution_code(code)

3626 code.putln("break;")

3627 code.putln("}")

3628

3629 def annotate(self, code):

3630 self.test.annotate(code)

3631 for case in self.cases:

3632 case.annotate(code)

3633 if self.else_clause is not None:

3634 self.else_clause.annotate(code)

3635

3636 class LoopNode(object):

3637

3638 def analyse_control_flow(self, env):

3639 env.start_branching(self.pos)

3640 self.body.analyse_control_flow(env)

3641 env.next_branch(self.body.end_pos())

3642 if self.else_clause:

3643 self.else_clause.analyse_control_flow(env)

3644 env.finish_branching(self.end_pos())

3645

3646

3647 class WhileStatNode(LoopNode, StatNode):

3648 # while statement

3649 #

3650 # condition ExprNode

3651 # body StatNode

3652 # else_clause StatNode

3653

3654 child_attrs = ["condition", "body", "else_clause"]

3655

3656 def analyse_declarations(self, env):

3657 self.body.analyse_declarations(env)

3658 if self.else_clause:

3659 self.else_clause.analyse_declarations(env)

3660

3661 def analyse_expressions(self, env):

3662 self.condition = \

3663 self.condition.analyse_temp_boolean_expression(env)

3664 self.body.analyse_expressions(env)

3665 if self.else_clause:

3666 self.else_clause.analyse_expressions(env)

3667

3668 def generate_execution_code(self, code):

3669 old_loop_labels = code.new_loop_labels()

3670 code.putln(

3671 "while (1) {")

3672 self.condition.generate_evaluation_code(code)

3673 self.condition.generate_disposal_code(code)

3674 code.putln(

3675 "if (!%s) break;" %

3676 self.condition.result())

3677 self.condition.free_temps(code)

3678 self.body.generate_execution_code(code)

3679 code.put_label(code.continue_label)

3680 code.putln("}")

3681 break_label = code.break_label

3682 code.set_loop_labels(old_loop_labels)

3683 if self.else_clause:

3684 code.putln("/*else*/ {")

3685 self.else_clause.generate_execution_code(code)

3686 code.putln("}")

3687 code.put_label(break_label)

3688

3689 def annotate(self, code):

3690 self.condition.annotate(code)

3691 self.body.annotate(code)

3692 if self.else_clause:

3693 self.else_clause.annotate(code)

3694

3695

3696 def ForStatNode(pos, **kw):

3697 if 'iterator' in kw:

3698 return ForInStatNode(pos, **kw)

3699 else:

3700 return ForFromStatNode(pos, **kw)

3701

3702 class ForInStatNode(LoopNode, StatNode):

3703 # for statement

3704 #

3705 # target ExprNode

3706 # iterator IteratorNode

3707 # body StatNode

3708 # else_clause StatNode

3709 # item NextNode used internally

3710

3711 child_attrs = ["target", "iterator", "body", "else_clause"]

3712 item = None

3713

3714 def analyse_declarations(self, env):

3715 self.target.analyse_target_declaration(env)

3716 self.body.analyse_declarations(env)

3717 if self.else_clause:

3718 self.else_clause.analyse_declarations(env)

3719

3720 def analyse_expressions(self, env):

3721 import ExprNodes

3722 self.target.analyse_target_types(env)

3723 self.iterator.analyse_expressions(env)

3724 self.item = ExprNodes.NextNode(self.iterator, env)

3725 self.item = self.item.coerce_to(self.target.type, env)

3726 self.body.analyse_expressions(env)

3727 if self.else_clause:

3728 self.else_clause.analyse_expressions(env)

3729

3730 def generate_execution_code(self, code):

3731 old_loop_labels = code.new_loop_labels()

3732 self.iterator.allocate_counter_temp(code)

3733 self.iterator.generate_evaluation_code(code)

3734 code.putln(

3735 "for (;;) {")

3736 self.item.generate_evaluation_code(code)

3737 self.target.generate_assignment_code(self.item, code)

3738 self.body.generate_execution_code(code)

3739 code.put_label(code.continue_label)

3740 code.putln(

3741 "}")

3742 break_label = code.break_label

3743 code.set_loop_labels(old_loop_labels)

3744 if self.else_clause:

3745 code.putln("/*else*/ {")

3746 self.else_clause.generate_execution_code(code)

3747 code.putln("}")

3748 code.put_label(break_label)

3749 self.iterator.release_counter_temp(code)

3750 self.iterator.generate_disposal_code(code)

3751 self.iterator.free_temps(code)

3752

3753 def annotate(self, code):

3754 self.target.annotate(code)

3755 self.iterator.annotate(code)

3756 self.body.annotate(code)

3757 if self.else_clause:

3758 self.else_clause.annotate(code)

3759 self.item.annotate(code)

3760

3761

3762 class ForFromStatNode(LoopNode, StatNode):

3763 # for name from expr rel name rel expr

3764 #

3765 # target NameNode

3766 # bound1 ExprNode

3767 # relation1 string

3768 # relation2 string

3769 # bound2 ExprNode

3770 # step ExprNode or None

3771 # body StatNode

3772 # else_clause StatNode or None

3773 #

3774 # Used internally:

3775 #

3776 # from_range bool

3777 # is_py_target bool

3778 # loopvar_node ExprNode (usually a NameNode or temp node)

3779 # py_loopvar_node PyTempNode or None

3780 child_attrs = ["target", "bound1", "bound2", "step", "body", "else_clause"]

3781

3782 is_py_target = False

3783 loopvar_node = None

3784 py_loopvar_node = None

3785 from_range = False

3786

3787 def analyse_declarations(self, env):

3788 self.target.analyse_target_declaration(env)

3789 self.body.analyse_declarations(env)

3790 if self.else_clause:

3791 self.else_clause.analyse_declarations(env)

3792

3793 def analyse_expressions(self, env):

3794 import ExprNodes

3795 self.target.analyse_target_types(env)

3796 self.bound1.analyse_types(env)

3797 self.bound2.analyse_types(env)

3798 if self.step is not None:

3799 if isinstance(self.step, ExprNodes.UnaryMinusNode):

3800 warning(self.step.pos, "Probable infinite loop in for-from-by statment. Consider switching the directions of the relations.", 2)

3801 self.step.analyse_types(env)

3802

3803 target_type = self.target.type

3804 if self.target.type.is_numeric:

3805 loop_type = self.target.type

3806 else:

3807 loop_type = PyrexTypes.c_int_type

3808 if not self.bound1.type.is_pyobject:

3809 loop_type = PyrexTypes.widest_numeric_type(loop_type, self.bound1.type)

3810 if not self.bound2.type.is_pyobject:

3811 loop_type = PyrexTypes.widest_numeric_type(loop_type, self.bound2.type)

3812 if self.step is not None and not self.step.type.is_pyobject:

3813 loop_type = PyrexTypes.widest_numeric_type(loop_type, self.step.type)

3814 self.bound1 = self.bound1.coerce_to(loop_type, env)

3815 self.bound2 = self.bound2.coerce_to(loop_type, env)

3816 if not self.bound2.is_literal:

3817 self.bound2 = self.bound2.coerce_to_temp(env)

3818 if self.step is not None:

3819 self.step = self.step.coerce_to(loop_type, env)

3820 if not self.step.is_literal:

3821 self.step = self.step.coerce_to_temp(env)

3822

3823 target_type = self.target.type

3824 if not (target_type.is_pyobject or target_type.is_numeric):

3825 error(self.target.pos,

3826 "for-from loop variable must be c numeric type or Python object")

3827 if target_type.is_numeric:

3828 self.is_py_target = False

3829 if isinstance(self.target, ExprNodes.IndexNode) and self.target.is_buffer_access:

3830 raise error(self.pos, "Buffer indexing not allowed as for loop target.")

3831 self.loopvar_node = self.target

3832 self.py_loopvar_node = None

3833 else:

3834 self.is_py_target = True

3835 c_loopvar_node = ExprNodes.TempNode(self.pos, loop_type, env)

3836 self.loopvar_node = c_loopvar_node

3837 self.py_loopvar_node = \

3838 ExprNodes.CloneNode(c_loopvar_node).coerce_to_pyobject(env)

3839 self.body.analyse_expressions(env)

3840 if self.else_clause:

3841 self.else_clause.analyse_expressions(env)

3842

3843 def generate_execution_code(self, code):

3844 old_loop_labels = code.new_loop_labels()

3845 from_range = self.from_range

3846 self.bound1.generate_evaluation_code(code)

3847 self.bound2.generate_evaluation_code(code)

3848 offset, incop = self.relation_table[self.relation1]

3849 if self.step is not None:

3850 self.step.generate_evaluation_code(code)

3851 step = self.step.result()

3852 incop = "%s=%s" % (incop[0], step)

3853 import ExprNodes

3854 if isinstance(self.loopvar_node, ExprNodes.TempNode):

3855 self.loopvar_node.allocate(code)

3856 if isinstance(self.py_loopvar_node, ExprNodes.TempNode):

3857 self.py_loopvar_node.allocate(code)

3858 if from_range:

3859 loopvar_name = code.funcstate.allocate_temp(self.target.type, False)

3860 else:

3861 loopvar_name = self.loopvar_node.result()

3862 code.putln(

3863 "for (%s = %s%s; %s %s %s; %s%s) {" % (

3864 loopvar_name,

3865 self.bound1.result(), offset,

3866 loopvar_name, self.relation2, self.bound2.result(),

3867 loopvar_name, incop))

3868 if self.py_loopvar_node:

3869 self.py_loopvar_node.generate_evaluation_code(code)

3870 self.target.generate_assignment_code(self.py_loopvar_node, code)

3871 elif from_range:

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

3873 self.target.result(), loopvar_name))

3874 self.body.generate_execution_code(code)

3875 code.put_label(code.continue_label)

3876 if self.py_loopvar_node:

3877 # Reassign py variable to loop var here.

3878 # (For consistancy, should rarely come up in practice.)

3879 import ExprNodes

3880 from_py_node = ExprNodes.CoerceFromPyTypeNode(self.loopvar_node.type, self.target, None)

3881 from_py_node.temp_code = loopvar_name

3882 from_py_node.generate_result_code(code)

3883 code.putln("}")

3884 if self.py_loopvar_node:

3885 # This is potentially wasteful, but we don't want the semantics to

3886 # depend on whether or not the loop is a python type.

3887 self.py_loopvar_node.generate_evaluation_code(code)

3888 self.target.generate_assignment_code(self.py_loopvar_node, code)

3889 break_label = code.break_label

3890 code.set_loop_labels(old_loop_labels)

3891 if self.else_clause:

3892 code.putln("/*else*/ {")

3893 self.else_clause.generate_execution_code(code)

3894 code.putln("}")

3895 code.put_label(break_label)

3896 self.bound1.generate_disposal_code(code)

3897 self.bound1.free_temps(code)

3898 self.bound2.generate_disposal_code(code)

3899 self.bound2.free_temps(code)

3900 if isinstance(self.loopvar_node, ExprNodes.TempNode):

3901 self.loopvar_node.release(code)

3902 if isinstance(self.py_loopvar_node, ExprNodes.TempNode):

3903 self.py_loopvar_node.release(code)

3904 if self.step is not None:

3905 self.step.generate_disposal_code(code)

3906 self.step.free_temps(code)

3907

3908 relation_table = {

3909 # {relop : (initial offset, increment op)}

3910 '<=': ("", "++"),

3911 '<' : ("+1", "++"),

3912 '>=': ("", "--"),

3913 '>' : ("-1", "--")

3914 }

3915

3916 def annotate(self, code):

3917 self.target.annotate(code)

3918 self.bound1.annotate(code)

3919 self.bound2.annotate(code)

3920 if self.step:

3921 self.bound2.annotate(code)

3922 self.body.annotate(code)

3923 if self.else_clause:

3924 self.else_clause.annotate(code)

3925

3926

3927 class WithStatNode(StatNode):

3928 """

3929 Represents a Python with statement.

3930

3931 This is only used at parse tree level; and is not present in

3932 analysis or generation phases.

3933 """

3934 # manager The with statement manager object

3935 # target Node (lhs expression)

3936 # body StatNode

3937 child_attrs = ["manager", "target", "body"]

3938

3939 class TryExceptStatNode(StatNode):

3940 # try .. except statement

3941 #

3942 # body StatNode

3943 # except_clauses [ExceptClauseNode]

3944 # else_clause StatNode or None

3945

3946 child_attrs = ["body", "except_clauses", "else_clause"]

3947

3948 def analyse_control_flow(self, env):

3949 env.start_branching(self.pos)

3950 self.body.analyse_control_flow(env)

3951 successful_try = env.control_flow # grab this for later

3952 env.next_branch(self.body.end_pos())

3953 env.finish_branching(self.body.end_pos())

3954

3955 env.start_branching(self.except_clauses[0].pos)

3956 for except_clause in self.except_clauses:

3957 except_clause.analyse_control_flow(env)

3958 env.next_branch(except_clause.end_pos())

3959

3960 # the else cause it executed only when the try clause finishes

3961 env.control_flow.incoming = successful_try

3962 if self.else_clause:

3963 self.else_clause.analyse_control_flow(env)

3964 env.finish_branching(self.end_pos())

3965

3966 def analyse_declarations(self, env):

3967 self.body.analyse_declarations(env)

3968 for except_clause in self.except_clauses:

3969 except_clause.analyse_declarations(env)

3970 if self.else_clause:

3971 self.else_clause.analyse_declarations(env)

3972 env.use_utility_code(reset_exception_utility_code)