1 #

2 # Pyrex - Parse tree nodes

3 #

4

5 import string, 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

21 from DebugFlags import debug_disposal_code

22

23 absolute_path_length = 0

24

25 def relative_position(pos):

26 """

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

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

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

30 e.g,. when distributing binaries.)

31

32 INPUT:

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

34

35 OUTPUT:

36 relative filename

37 line number

38

39 AUTHOR: William Stein

40 """

41 global absolute_path_length

42 if absolute_path_length==0:

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

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

45

46 def embed_position(pos, docstring):

47 if not Options.embed_pos_in_docstring:

48 return docstring

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

50 if docstring is None:

51 # unicode string

52 return EncodedString(pos_line)

53

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

55 # otherwise make the docstring a unicode string

56 encoding = docstring.encoding

57 if encoding is not None:

58 try:

59 encoded_bytes = pos_line.encode(encoding)

60 except UnicodeEncodeError:

61 encoding = None

62

63 if not docstring:

64 # reuse the string encoding of the original docstring

65 doc = EncodedString(pos_line)

66 else:

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

68 doc.encoding = encoding

69 return doc

70

71 class Node(object):

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

73 # is_name boolean Is a NameNode

74 # is_literal boolean Is a ConstNode

75

76 is_name = 0

77 is_literal = 0

78 temps = None

79

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

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

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

83 child_attrs = None

84

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

86 self.pos = pos

87 self.__dict__.update(kw)

88

89 gil_message = "Operation"

90

91 def gil_check(self, env):

92 if env.nogil:

93 self.gil_error()

94

95 def gil_error(self):

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

97

98 def clone_node(self):

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

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

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

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

103 level in the tree."""

104 result = copy.copy(self)

105 for attrname in result.child_attrs:

106 value = getattr(result, attrname)

107 if isinstance(value, list):

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

109 return result

110

111

112 #

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

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

115 #

116 # (0) analyse_control_flow

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

118 # queried.

119 #

120 # (1) analyse_declarations

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

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

123 # to an otherwise undeclared name).

124 #

125 # (2) analyse_expressions

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

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

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

129 # Allocate temporary locals for intermediate results. Fill

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

131 # fragment.

132 #

133 # (3) generate_code

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

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

136 # functions.

137 #

138

139 def analyse_control_flow(self, env):

140 pass

141

142 def analyse_declarations(self, env):

143 pass

144

145 def analyse_expressions(self, env):

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

147 self.__class__.__name__)

148

149 def generate_code(self, code):

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

151 self.__class__.__name__)

152

153 def annotate(self, code):

154 # mro does the wrong thing

155 if isinstance(self, BlockNode):

156 self.body.annotate(code)

157

158 def end_pos(self):

159 if not self.child_attrs:

160 return self.pos

161 try:

162 return self._end_pos

163 except AttributeError:

164 pos = self.pos

165 for attr in self.child_attrs:

166 child = getattr(self, attr)

167 # Sometimes lists, sometimes nodes

168 if child is None:

169 pass

170 elif isinstance(child, list):

171 for c in child:

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

173 else:

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

175 self._end_pos = pos

176 return pos

177

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

179 if cutoff == 0:

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

181 if encountered is None:

182 encountered = set()

183 if id(self) in encountered:

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

185 encountered.add(id(self))

186

187 def dump_child(x, level):

188 if isinstance(x, Node):

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

190 elif isinstance(x, list):

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

192 else:

193 return repr(x)

194

195

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

197 if len(attrs) == 0:

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

199 else:

200 indent = " " * level

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

202 for key, value in attrs:

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

204 res += "%s>" % indent

205 return res

206

207 class CompilerDirectivesNode(Node):

208 """

209 Sets compiler directives for the children nodes

210 """

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

212 # *all* possible directives.

213 # body Node

214 child_attrs = ["body"]

215

216 def analyse_control_flow(self, env):

217 old = env.directives

218 env.directives = self.directives

219 self.body.analyse_control_flow(env)

220 env.directives = old

221

222 def analyse_declarations(self, env):

223 old = env.directives

224 env.directives = self.directives

225 self.body.analyse_declarations(env)

226 env.directives = old

227

228 def analyse_expressions(self, env):

229 old = env.directives

230 env.directives = self.directives

231 self.body.analyse_expressions(env)

232 env.directives = old

233

234 def generate_function_definitions(self, env, code):

235 env_old = env.directives

236 code_old = code.globalstate.directives

237 code.globalstate.directives = self.directives

238 self.body.generate_function_definitions(env, code)

239 env.directives = env_old

240 code.globalstate.directives = code_old

241

242 def generate_execution_code(self, code):

243 old = code.globalstate.directives

244 code.globalstate.directives = self.directives

245 self.body.generate_execution_code(code)

246 code.globalstate.directives = old

247

248 def annotate(self, code):

249 old = code.globalstate.directives

250 code.globalstate.directives = self.directives

251 self.body.annotate(code)

252 code.globalstate.directives = old

253

254 class BlockNode:

255 # Mixin class for nodes representing a declaration block.

256

257 def generate_const_definitions(self, env, code):

258 if env.const_entries:

259 for entry in env.const_entries:

260 if not entry.is_interned:

261 code.globalstate.add_const_definition(entry)

262

263 def generate_interned_string_decls(self, env, code):

264 entries = env.global_scope().new_interned_string_entries

265 if entries:

266 for entry in entries:

267 code.globalstate.add_interned_string_decl(entry)

268 del entries[:]

269

270 def generate_py_string_decls(self, env, code):

271 if env is None:

272 return # earlier error

273 entries = env.pystring_entries

274 if entries:

275 for entry in entries:

276 if not entry.is_interned:

277 code.globalstate.add_py_string_decl(entry)

278

279 def generate_interned_num_decls(self, env, code):

280 # Flush accumulated interned nums from the global scope

281 # and generate declarations for them.

282 genv = env.global_scope()

283 entries = genv.interned_nums

284 if entries:

285 for entry in entries:

286 code.globalstate.add_interned_num_decl(entry)

287 del entries[:]

288

289 def generate_cached_builtins_decls(self, env, code):

290 entries = env.global_scope().undeclared_cached_builtins

291 for entry in entries:

292 code.globalstate.add_cached_builtin_decl(entry)

293 del entries[:]

294

295

296 class StatListNode(Node):

297 # stats a list of StatNode

298

299 child_attrs = ["stats"]

300

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

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

303 return node # No node-specific analysis necesarry

304 create_analysed = staticmethod(create_analysed)

305

306 def analyse_control_flow(self, env):

307 for stat in self.stats:

308 stat.analyse_control_flow(env)

309

310 def analyse_declarations(self, env):

311 #print "StatListNode.analyse_declarations" ###

312 for stat in self.stats:

313 stat.analyse_declarations(env)

314

315 def analyse_expressions(self, env):

316 #print "StatListNode.analyse_expressions" ###

317 for stat in self.stats:

318 stat.analyse_expressions(env)

319

320 def generate_function_definitions(self, env, code):

321 #print "StatListNode.generate_function_definitions" ###

322 for stat in self.stats:

323 stat.generate_function_definitions(env, code)

324

325 def generate_execution_code(self, code):

326 #print "StatListNode.generate_execution_code" ###

327 for stat in self.stats:

328 code.mark_pos(stat.pos)

329 stat.generate_execution_code(code)

330

331 def annotate(self, code):

332 for stat in self.stats:

333 stat.annotate(code)

334

335

336 class StatNode(Node):

337 #

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

339 #

340 # (1) generate_function_definitions

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

342 # unions, enums and functions defined in the current

343 # scope-block.

344 #

345 # (2) generate_execution_code

346 # Emit C code for executable statements.

347 #

348

349 def generate_function_definitions(self, env, code):

350 pass

351

352 def generate_execution_code(self, code):

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

354 self.__class__.__name__)

355

356

357 class CDefExternNode(StatNode):

358 # include_file string or None

359 # body StatNode

360

361 child_attrs = ["body"]

362

363 def analyse_declarations(self, env):

364 if self.include_file:

365 env.add_include_file(self.include_file)

366 old_cinclude_flag = env.in_cinclude

367 env.in_cinclude = 1

368 self.body.analyse_declarations(env)

369 env.in_cinclude = old_cinclude_flag

370

371 def analyse_expressions(self, env):

372 pass

373

374 def generate_execution_code(self, code):

375 pass

376

377 def annotate(self, code):

378 self.body.annotate(code)

379

380

381 class CDeclaratorNode(Node):

382 # Part of a C declaration.

383 #

384 # Processing during analyse_declarations phase:

385 #

386 # analyse

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

388 # CNameDeclaratorNode of the name being declared

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

390 #

391 # calling_convention string Calling convention of CFuncDeclaratorNode

392 # for which this is a base

393

394 child_attrs = []

395

396 calling_convention = ""

397

398

399 class CNameDeclaratorNode(CDeclaratorNode):

400 # name string The Pyrex name being declared

401 # cname string or None C name, if specified

402 # default ExprNode or None the value assigned on declaration

403

404 child_attrs = ['default']

405

406 default = None

407

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

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

410 # May have mistaken the name for the type.

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

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

413 elif base_type.is_void:

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

415 else:

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

417 base_type = py_object_type

418 self.type = base_type

419 return self, base_type

420

421 class CPtrDeclaratorNode(CDeclaratorNode):

422 # base CDeclaratorNode

423

424 child_attrs = ["base"]

425

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

427 if base_type.is_pyobject:

428 error(self.pos,

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

430 ptr_type = PyrexTypes.c_ptr_type(base_type)

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

432

433 class CArrayDeclaratorNode(CDeclaratorNode):

434 # base CDeclaratorNode

435 # dimension ExprNode

436

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

438

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

440 if self.dimension:

441 self.dimension.analyse_const_expression(env)

442 if not self.dimension.type.is_int:

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

444 size = self.dimension.result()

445 try:

446 size = int(size)

447 except ValueError:

448 # runtime constant?

449 pass

450 else:

451 size = None

452 if not base_type.is_complete():

453 error(self.pos,

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

455 if base_type.is_pyobject:

456 error(self.pos,

457 "Array element cannot be a Python object")

458 if base_type.is_cfunction:

459 error(self.pos,

460 "Array element cannot be a function")

461 array_type = PyrexTypes.c_array_type(base_type, size)

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

463

464

465 class CFuncDeclaratorNode(CDeclaratorNode):

466 # base CDeclaratorNode

467 # args [CArgDeclNode]

468 # has_varargs boolean

469 # exception_value ConstNode

470 # exception_check boolean True if PyErr_Occurred check needed

471 # nogil boolean Can be called without gil

472 # with_gil boolean Acquire gil around function body

473

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

475

476 overridable = 0

477 optional_arg_count = 0

478

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

480 if nonempty:

481 nonempty -= 1

482 func_type_args = []

483 for arg_node in self.args:

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

485 name = name_declarator.name

486 if name_declarator.cname:

487 error(self.pos,

488 "Function argument cannot have C name specification")

489 # Turn *[] argument into **

490 if type.is_array:

491 type = PyrexTypes.c_ptr_type(type.base_type)

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

493 if type.is_void:

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

495 # if type.is_pyobject and self.nogil:

496 # error(self.pos,

497 # "Function with Python argument cannot be declared nogil")

498 func_type_args.append(

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

500 if arg_node.default:

501 self.optional_arg_count += 1

502 elif self.optional_arg_count:

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

504

505 if self.optional_arg_count:

506 scope = StructOrUnionScope()

507 scope.declare_var('%sn' % Naming.pyrex_prefix, PyrexTypes.c_int_type, self.pos)

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

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

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

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

512 kind = 'struct',

513 scope = scope,

514 typedef_flag = 0,

515 pos = self.pos,

516 cname = struct_cname)

517 self.op_args_struct.defined_in_pxd = 1

518 self.op_args_struct.used = 1

519

520 exc_val = None

521 exc_check = 0

522 if return_type.is_pyobject \

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

524 and self.exception_check != '+':

525 error(self.pos,

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

527 else:

528 if self.exception_value:

529 self.exception_value.analyse_const_expression(env)

530 if self.exception_check == '+':

531 exc_val_type = self.exception_value.type

532 if not exc_val_type.is_error and \

533 not exc_val_type.is_pyobject and \

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

535 error(self.exception_value.pos,

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

537 exc_val = self.exception_value

538 else:

539 exc_val = self.exception_value.result()

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

541 error(self.exception_value.pos,

542 "Exception value incompatible with function return type")

543 exc_check = self.exception_check

544 if return_type.is_array:

545 error(self.pos,

546 "Function cannot return an array")

547 if return_type.is_cfunction:

548 error(self.pos,

549 "Function cannot return a function")

550 func_type = PyrexTypes.CFuncType(

551 return_type, func_type_args, self.has_varargs,

552 optional_arg_count = self.optional_arg_count,

553 exception_value = exc_val, exception_check = exc_check,

554 calling_convention = self.base.calling_convention,

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

556 if self.optional_arg_count:

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

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

559

560

561 class CArgDeclNode(Node):

562 # Item in a function declaration argument list.

563 #

564 # base_type CBaseTypeNode

565 # declarator CDeclaratorNode

566 # not_none boolean Tagged with 'not None'

567 # default ExprNode or None

568 # default_entry Symtab.Entry Entry for the variable holding the default value

569 # default_result_code string cname or code fragment for default value

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

571 # is_kw_only boolean Is a keyword-only argument

572

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

574

575 is_self_arg = 0

576 is_generic = 1

577 type = None

578 name_declarator = None

579

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

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

582 if self.type is None:

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

584 # We fix that here.

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

586 if nonempty:

587 self.declarator.name = self.base_type.name

588 self.base_type.name = None

589 self.base_type.is_basic_c_type = False

590 could_be_name = True

591 else:

592 could_be_name = False

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

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

595 self.declarator.name = self.base_type.arg_name

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

597 else:

598 return self.name_declarator, self.type

599

600 def annotate(self, code):

601 if self.default:

602 self.default.annotate(code)

603

604

605 class CBaseTypeNode(Node):

606 # Abstract base class for C base type nodes.

607 #

608 # Processing during analyse_declarations phase:

609 #

610 # analyse

611 # Returns the type.

612

613 pass

614

615 class CAnalysedBaseTypeNode(Node):

616 # type type

617

618 child_attrs = []

619

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

621 return self.type

622

623 class CSimpleBaseTypeNode(CBaseTypeNode):

624 # name string

625 # module_path [string] Qualifying name components

626 # is_basic_c_type boolean

627 # signed boolean

628 # longness integer

629 # is_self_arg boolean Is self argument of C method

630

631 child_attrs = []

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

633

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

635 # Return type descriptor.

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

637 type = None

638 if self.is_basic_c_type:

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

640 if not type:

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

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

643 type = py_object_type

644 elif self.name is None:

645 if self.is_self_arg and env.is_c_class_scope:

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

647 type = env.parent_type

648 else:

649 type = py_object_type

650 else:

651 if self.module_path:

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

653 else:

654 scope = env

655 if scope:

656 if scope.is_c_class_scope:

657 scope = scope.global_scope()

658 entry = scope.lookup(self.name)

659 if entry and entry.is_type:

660 type = entry.type

661 elif could_be_name:

662 if self.is_self_arg and env.is_c_class_scope:

663 type = env.parent_type

664 else:

665 type = py_object_type

666 self.arg_name = self.name

667 else:

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

669 if type:

670 return type

671 else:

672 return PyrexTypes.error_type

673

674 class CBufferAccessTypeNode(CBaseTypeNode):

675 # After parsing:

676 # positional_args [ExprNode] List of positional arguments

677 # keyword_args DictNode Keyword arguments

678 # base_type_node CBaseTypeNode

679

680 # After analysis:

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

682

683

684 child_attrs = ["base_type_node", "positional_args",

685 "keyword_args", "dtype_node"]

686

687 dtype_node = None

688

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

690 base_type = self.base_type_node.analyse(env)

691 if base_type.is_error: return base_type

692 import Buffer

693

694 options = Buffer.analyse_buffer_options(

695 self.pos,

696 env,

697 self.positional_args,

698 self.keyword_args,

699 base_type.buffer_defaults)

700

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

702 return self.type

703

704 class CComplexBaseTypeNode(CBaseTypeNode):

705 # base_type CBaseTypeNode

706 # declarator CDeclaratorNode

707

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

709

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

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

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

713 return type

714

715

716 class CVarDefNode(StatNode):

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

718 #

719 # visibility 'private' or 'public' or 'extern'

720 # base_type CBaseTypeNode

721 # declarators [CDeclaratorNode]

722 # in_pxd boolean

723 # api boolean

724 # need_properties [entry]

725 # pxd_locals [CVarDefNode] (used for functions declared in pxd)

726

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

728 need_properties = ()

729 pxd_locals = []

730

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

732 if not dest_scope:

733 dest_scope = env

734 self.dest_scope = dest_scope

735 base_type = self.base_type.analyse(env)

736 if (dest_scope.is_c_class_scope

737 and self.visibility == 'public'

738 and base_type.is_pyobject

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

740 self.need_properties = []

741 need_property = True

742 visibility = 'private'

743 else:

744 need_property = False

745 visibility = self.visibility

746

747 for declarator in self.declarators:

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

749 if not type.is_complete():

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

751 error(declarator.pos,

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

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

754 error(declarator.pos,

755 "Python object cannot be declared extern")

756 name = name_declarator.name

757 cname = name_declarator.cname

758 if name == '':

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

760 return

761 if type.is_cfunction:

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

763 cname = cname, visibility = self.visibility, in_pxd = self.in_pxd,

764 api = self.api)

765 if entry is not None:

766 entry.pxd_locals = self.pxd_locals

767 else:

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

769 error(self.pos,

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

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

772 cname = cname, visibility = visibility, is_cdef = 1)

773 if need_property:

774 self.need_properties.append(entry)

775 entry.needs_property = 1

776

777

778 class CStructOrUnionDefNode(StatNode):

779 # name string

780 # cname string or None

781 # kind "struct" or "union"

782 # typedef_flag boolean

783 # visibility "public" or "private"

784 # in_pxd boolean

785 # attributes [CVarDefNode] or None

786 # entry Entry

787

788 child_attrs = ["attributes"]

789

790 def analyse_declarations(self, env):

791 scope = None

792 if self.attributes is not None:

793 scope = StructOrUnionScope(self.name)

794 self.entry = env.declare_struct_or_union(

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

796 self.cname, visibility = self.visibility)

797 if self.attributes is not None:

798 if self.in_pxd and not env.in_cinclude:

799 self.entry.defined_in_pxd = 1

800 for attr in self.attributes:

801 attr.analyse_declarations(env, scope)

802 if self.visibility != 'extern':

803 need_typedef_indirection = False

804 for attr in scope.var_entries:

805 type = attr.type

806 while type.is_array:

807 type = type.base_type

808 if type == self.entry.type:

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

810 if self.typedef_flag:

811 while type.is_ptr:

812 type = type.base_type

813 if type == self.entry.type:

814 need_typedef_indirection = True

815 if need_typedef_indirection:

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

817 struct_entry = self.entry

818 cname = env.new_const_cname()

819 self.entry = env.declare_typedef(self.name, struct_entry.type, self.pos, cname = self.cname, visibility='ignore')

820 struct_entry.type.typedef_flag = False

821 struct_entry.cname = struct_entry.type.cname = env.new_const_cname()

822

823 def analyse_expressions(self, env):

824 pass

825

826 def generate_execution_code(self, code):

827 pass

828

829

830 class CEnumDefNode(StatNode):

831 # name string or None

832 # cname string or None

833 # items [CEnumDefItemNode]

834 # typedef_flag boolean

835 # visibility "public" or "private"

836 # in_pxd boolean

837 # entry Entry

838

839 child_attrs = ["items"]

840

841 def analyse_declarations(self, env):

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

843 cname = self.cname, typedef_flag = self.typedef_flag,

844 visibility = self.visibility)

845 if self.items is not None:

846 if self.in_pxd and not env.in_cinclude:

847 self.entry.defined_in_pxd = 1

848 for item in self.items:

849 item.analyse_declarations(env, self.entry)

850

851 def analyse_expressions(self, env):

852 if self.visibility == 'public':

853 self.temp = env.allocate_temp_pyobject()

854 env.release_temp(self.temp)

855

856 def generate_execution_code(self, code):

857 if self.visibility == 'public':

858 for item in self.entry.enum_values:

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

860 self.temp,

861 item.cname,

862 code.error_goto_if_null(self.temp, item.pos)))

863 code.putln('if (PyObject_SetAttrString(%s, "%s", %s) < 0) %s' % (

864 Naming.module_cname,

865 item.name,

866 self.temp,

867 code.error_goto(item.pos)))

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

869

870

871 class CEnumDefItemNode(StatNode):

872 # name string

873 # cname string or None

874 # value ExprNode or None

875

876 child_attrs = ["value"]

877

878 def analyse_declarations(self, env, enum_entry):

879 if self.value:

880 self.value.analyse_const_expression(env)

881 if not self.value.type.is_int:

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

883 self.value.analyse_const_expression(env)

884 value = self.value.result()

885 else:

886 value = self.name

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

888 value, self.pos, cname = self.cname, visibility = enum_entry.visibility)

889 enum_entry.enum_values.append(entry)

890

891

892 class CTypeDefNode(StatNode):

893 # base_type CBaseTypeNode

894 # declarator CDeclaratorNode

895 # visibility "public" or "private"

896 # in_pxd boolean

897

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

899

900 def analyse_declarations(self, env):

901 base = self.base_type.analyse(env)

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

903 name = name_declarator.name

904 cname = name_declarator.cname

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

906 cname = cname, visibility = self.visibility)

907 if self.in_pxd and not env.in_cinclude:

908 entry.defined_in_pxd = 1

909

910 def analyse_expressions(self, env):

911 pass

912 def generate_execution_code(self, code):

913 pass

914

915

916 class FuncDefNode(StatNode, BlockNode):

917 # Base class for function definition nodes.

918 #

919 # return_type PyrexType

920 # #filename string C name of filename string const

921 # entry Symtab.Entry

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

923 # pxd_locals [CVarDefNode] locals defined in the pxd

924

925 py_func = None

926 assmt = None

927 needs_closure = False

928 pxd_locals = []

929

930 def analyse_default_values(self, env):

931 genv = env.global_scope()

932 for arg in self.args:

933 if arg.default:

934 if arg.is_generic:

935 if not hasattr(arg, 'default_entry'):

936 arg.default.analyse_types(env)

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

938 if arg.default.is_literal:

939 arg.default_entry = arg.default

940 arg.default_result_code = arg.default.calculate_result_code()

941 if arg.default.type != arg.type and not arg.type.is_int:

942 arg.default_result_code = arg.type.cast_code(arg.default_result_code)

943 else:

944 arg.default.allocate_temps(genv)

945 arg.default_entry = genv.add_default_value(arg.type)

946 arg.default_entry.used = 1

947 arg.default_result_code = arg.default_entry.cname

948 else:

949 error(arg.pos,

950 "This argument cannot have a default value")

951 arg.default = None

952

953 def need_gil_acquisition(self, lenv):

954 return 0

955

956 def create_local_scope(self, env):

957 genv = env

958 while env.is_py_class_scope or env.is_c_class_scope:

959 env = env.outer_scope

960 if self.needs_closure:

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

962 else:

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

964 lenv.return_type = self.return_type

965 type = self.entry.type

966 if type.is_cfunction:

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

968 self.local_scope = lenv

969 return lenv

970

971 def generate_function_definitions(self, env, code):

972 import Buffer

973

974 lenv = self.local_scope

975

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

977 self.entry.scope.is_c_class_scope)

978

979 # Generate C code for header and body of function

980 code.enter_cfunc_scope()

981 code.return_from_error_cleanup_label = code.new_label()

982

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

984 code.mark_pos(self.pos)

985 self.generate_interned_num_decls(lenv, code)

986 self.generate_interned_string_decls(lenv, code)

987 self.generate_py_string_decls(lenv, code)

988 self.generate_cached_builtins_decls(lenv, code)

989 #code.putln("")

990 #code.put_var_declarations(lenv.const_entries, static = 1)

991 self.generate_const_definitions(lenv, code)

992 # ----- Function header

993 code.putln("")

994 if self.py_func:

995 self.py_func.generate_function_header(code,

996 with_pymethdef = env.is_py_class_scope,

997 proto_only=True)

998 self.generate_function_header(code,

999 with_pymethdef = env.is_py_class_scope)

1000 # ----- Local variable declarations

1001 lenv.mangle_closure_cnames(Naming.cur_scope_cname)

1002 self.generate_argument_declarations(lenv, code)

1003 if self.needs_closure:

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

1005 code.put_var_declarations(lenv.var_entries)

1006 init = ""

1007 if not self.return_type.is_void:

1008 code.putln(

1009 "%s%s;" %

1010 (self.return_type.declaration_code(

1011 Naming.retval_cname),

1012 init))

1013 tempvardecl_code = code.insertion_point()

1014 self.generate_keyword_list(code)

1015 # ----- Extern library function declarations

1016 lenv.generate_library_function_declarations(code)

1017 # ----- GIL acquisition

1018 acquire_gil = self.need_gil_acquisition(lenv)

1019 if acquire_gil:

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

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

1022 if is_getbuffer_slot:

1023 self.getbuffer_init(code)

1024 # ----- Fetch arguments

1025 self.generate_argument_parsing_code(env, code)

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

1027 # incref it to properly keep track of refcounts.

1028 for entry in lenv.arg_entries:

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

1030 code.put_var_incref(entry)

1031 # ----- Initialise local variables

1032 for entry in lenv.var_entries:

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

1034 code.put_init_var_to_py_none(entry)

1035 # ----- Initialise local buffer auxiliary variables

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

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

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

1039 # ----- Check and convert arguments

1040 self.generate_argument_type_tests(code)

1041 # ----- Acquire buffer arguments

1042 for entry in lenv.arg_entries:

1043 if entry.type.is_buffer:

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

1045 # ----- Function body

1046 self.body.generate_execution_code(code)

1047 # ----- Default return value

1048 code.putln("")

1049 if self.return_type.is_pyobject:

1050 #if self.return_type.is_extension_type:

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

1052 #else:

1053 lhs = Naming.retval_cname

1054 code.put_init_to_py_none(lhs, self.return_type)

1055 else:

1056 val = self.return_type.default_value

1057 if val:

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

1059 # ----- Error cleanup

1060 if code.error_label in code.labels_used:

1061 code.put_goto(code.return_label)

1062 code.put_label(code.error_label)

1063 # cleanup temps the old way

1064 code.put_var_xdecrefs(lenv.temp_entries)

1065 # cleanup temps the new way

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

1067 code.put_xdecref(cname, type)

1068

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

1070 # so need to save and restore error state

1071 buffers_present = len(lenv.buffer_entries) > 0

1072 if buffers_present:

1073 code.globalstate.use_utility_code(restore_exception_utility_code)

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

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

1076 for entry in lenv.buffer_entries:

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

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

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

1080

1081 err_val = self.error_value()

1082 exc_check = self.caller_will_check_exceptions()

1083 if err_val is not None or exc_check:

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

1085 else:

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

1087 % self.entry.qualified_name, 0)

1088 code.putln(

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

1090 self.entry.qualified_name)

1091 env.use_utility_code(unraisable_exception_utility_code)

1092 env.use_utility_code(restore_exception_utility_code)

1093 default_retval = self.return_type.default_value

1094 if err_val is None and default_retval:

1095 err_val = default_retval

1096 if err_val is not None:

1097 code.putln(

1098 "%s = %s;" % (

1099 Naming.retval_cname,

1100 err_val))

1101

1102 if is_getbuffer_slot:

1103 self.getbuffer_error_cleanup(code)

1104

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

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

1107 # whether this section is used.

1108 if buffers_present or is_getbuffer_slot:

1109 code.put_goto(code.return_from_error_cleanup_label)

1110

1111

1112 # ----- Non-error return cleanup

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

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

1115 # block).

1116 code.put_label(code.return_label)

1117 for entry in lenv.buffer_entries:

1118 if entry.used:

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

1120 if is_getbuffer_slot:

1121 self.getbuffer_normal_cleanup(code)

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

1123 code.put_label(code.return_from_error_cleanup_label)

1124 if not Options.init_local_none:

1125 for entry in lenv.var_entries:

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

1127 entry.xdecref_cleanup = 1

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

1129 # Decref any increfed args

1130 for entry in lenv.arg_entries:

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

1132 code.put_var_decref(entry)

1133 if acquire_gil:

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

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

1136 # ----- Return

1137 if not self.return_type.is_void:

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

1139 code.putln("}")

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

1141 tempvardecl_code.put_var_declarations(lenv.temp_entries)

1142 tempvardecl_code.put_temp_declarations(code.funcstate)

1143 # ----- Python version

1144 code.exit_cfunc_scope()

1145 if self.py_func:

1146 self.py_func.generate_function_definitions(env, code)

1147 self.generate_wrapper_functions(code)

1148

1149 def declare_argument(self, env, arg):

1150 if arg.type.is_void:

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

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

1153 error(arg.pos,

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

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

1156

1157 def generate_wrapper_functions(self, code):

1158 pass

1159

1160 def generate_execution_code(self, code):

1161 # Evaluate and store argument default values

1162 for arg in self.args:

1163 default = arg.default

1164 if default:

1165 if not default.is_literal:

1166 default.generate_evaluation_code(code)

1167 default.make_owned_reference(code)

1168 code.putln(

1169 "%s = %s;" % (

1170 arg.default_entry.cname,

1171 default.result_as(arg.default_entry.type)))

1172 if default.is_temp and default.type.is_pyobject:

1173 code.putln(

1174 "%s = 0;" %

1175 default.result())

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

1177 if self.assmt:

1178 self.assmt.generate_execution_code(code)

1179

1180 #

1181 # Special code for the __getbuffer__ function

1182 #

1183 def getbuffer_init(self, code):

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

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

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

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

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

1189 code.putln("%s->obj = Py_None; Py_INCREF(Py_None);" % info)

1190

1191 def getbuffer_error_cleanup(self, code):

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

1193 code.putln("Py_DECREF(%s->obj); %s->obj = NULL;" %

1194 (info, info))

1195

1196 def getbuffer_normal_cleanup(self, code):

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

1198 code.putln("if (%s->obj == Py_None) { Py_DECREF(Py_None); %s->obj = NULL; }" %

1199 (info, info))

1200

1201 class CFuncDefNode(FuncDefNode):

1202 # C function definition.

1203 #

1204 # modifiers ['inline']

1205 # visibility 'private' or 'public' or 'extern'

1206 # base_type CBaseTypeNode

1207 # declarator CDeclaratorNode

1208 # body StatListNode

1209 # api boolean

1210 #

1211 # with_gil boolean Acquire GIL around body

1212 # type CFuncType

1213 # py_func wrapper for calling from Python

1214 # overridable whether or not this is a cpdef function

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

1216

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

1218

1219 inline_in_pxd = False

1220

1221 def unqualified_name(self):

1222 return self.entry.name

1223

1224 def analyse_declarations(self, env):

1225 if 'locals' in env.directives:

1226 directive_locals = env.directives['locals']

1227 else:

1228 directive_locals = {}

1229 self.directive_locals = directive_locals

1230 base_type = self.base_type.analyse(env)

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

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

1233 if not type.is_cfunction:

1234 error(self.pos,

1235 "Suite attached to non-function declaration")

1236 # Remember the actual type according to the function header

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

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

1239 # from the base type of an extension type.

1240 self.type = type

1241 type.is_overridable = self.overridable

1242 declarator = self.declarator

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

1244 declarator = declarator.base

1245 self.args = declarator.args

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

1247 formal_arg.type = type_arg.type

1248 formal_arg.name = type_arg.name

1249 formal_arg.cname = type_arg.cname

1250 name = name_declarator.name

1251 cname = name_declarator.cname

1252 self.entry = env.declare_cfunction(

1253 name, type, self.pos,

1254 cname = cname, visibility = self.visibility,

1255 defining = self.body is not None,

1256 api = self.api, modifiers = self.modifiers)

1257 self.entry.inline_func_in_pxd = self.inline_in_pxd

1258 self.return_type = type.return_type

1259

1260 if self.overridable:

1261 import ExprNodes

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

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

1264 name = self.entry.name,

1265 args = self.args,

1266 star_arg = None,

1267 starstar_arg = None,

1268 doc = self.doc,

1269 body = py_func_body,

1270 is_wrapper = 1)

1271 self.py_func.is_module_scope = env.is_module_scope

1272 self.py_func.analyse_declarations(env)

1273 self.entry.as_variable = self.py_func.entry

1274 # Reset scope entry the above cfunction

1275 env.entries[name] = self.entry

1276 self.py_func.interned_attr_cname = env.intern_identifier(

1277 self.py_func.entry.name)

1278 if not env.is_module_scope or Options.lookup_module_cpdef:

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

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

1281

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

1283 import ExprNodes

1284 args = self.type.args

1285 if omit_optional_args:

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

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

1288 if is_module_scope:

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

1290 else:

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

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

1293 skip_dispatch = not is_module_scope or Options.lookup_module_cpdef

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

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

1296

1297 def declare_arguments(self, env):

1298 for arg in self.type.args:

1299 if not arg.name:

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

1301 self.declare_argument(env, arg)

1302

1303 def need_gil_acquisition(self, lenv):

1304 type = self.type

1305 with_gil = self.type.with_gil

1306 if type.nogil and not with_gil:

1307 if type.return_type.is_pyobject:

1308 error(self.pos,

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

1310 for entry in lenv.var_entries + lenv.temp_entries:

1311 if entry.type.is_pyobject:

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

1313 return with_gil

1314

1315 def analyse_expressions(self, env):

1316 self.analyse_default_values(env)

1317 if self.overridable:

1318 self.py_func.analyse_expressions(env)

1319

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

1321 arg_decls = []

1322 type = self.type

1323 visibility = self.entry.visibility

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

1325 arg_decls.append(arg.declaration_code())

1326 if with_dispatch and self.overridable:

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

1328 if type.optional_arg_count and with_opt_args:

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

1330 if type.has_varargs:

1331 arg_decls.append("...")

1332 if not arg_decls:

1333 arg_decls = ["void"]

1334 if cname is None:

1335 cname = self.entry.func_cname

1336 entity = type.function_header_code(cname, string.join(arg_decls, ", "))

1337 if visibility == 'public':

1338 dll_linkage = "DL_EXPORT"

1339 else:

1340 dll_linkage = None

1341 header = self.return_type.declaration_code(entity,

1342 dll_linkage = dll_linkage)

1343 if visibility == 'extern':

1344 storage_class = "%s " % Naming.extern_c_macro

1345 elif visibility == 'public':

1346 storage_class = ""

1347 else:

1348 storage_class = "static "

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

1350 storage_class,

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

1352 header))

1353

1354 def generate_argument_declarations(self, env, code):

1355 for arg in self.args:

1356 if arg.default:

1357 code.putln('%s = %s;' % (arg.type.declaration_code(arg.cname), arg.default_result_code))

1358

1359 def generate_keyword_list(self, code):

1360 pass

1361

1362 def generate_argument_parsing_code(self, env, code):

1363 i = 0

1364 if self.type.optional_arg_count:

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

1366 for arg in self.args:

1367 if arg.default:

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

1369 declarator = arg.declarator

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

1371 declarator = declarator.base

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

1373 i += 1

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

1375 code.putln('}')

1376 code.putln('}')

1377

1378 def generate_argument_conversion_code(self, code):

1379 pass

1380

1381 def generate_argument_type_tests(self, code):

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

1383 # class is a supertype of the declared type.

1384 for arg in self.type.args:

1385 if arg.needs_type_test:

1386 self.generate_arg_type_test(arg, code)

1387

1388 def generate_arg_type_test(self, arg, code):

1389 # Generate type test for one argument.

1390 if arg.type.typeobj_is_available():

1391 typeptr_cname = arg.type.typeptr_cname

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

1393 code.putln(

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

1395 arg_code,

1396 typeptr_cname,

1397 not arg.not_none,

1398 arg.name,

1399 type.is_builtin_type,

1400 code.error_goto(arg.pos)))

1401 else:

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

1403 "without type object name specification")

1404

1405 def error_value(self):

1406 if self.return_type.is_pyobject:

1407 return "0"

1408 else:

1409 #return None

1410 return self.entry.type.exception_value

1411

1412 def caller_will_check_exceptions(self):

1413 return self.entry.type.exception_check

1414

1415 def generate_wrapper_functions(self, code):

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

1417 # wrappers to put in the slots here.

1418 k = 0

1419 entry = self.entry

1420 func_type = entry.type

1421 while entry.prev_entry is not None:

1422 k += 1

1423 entry = entry.prev_entry

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

1425 code.putln()

1426 self.generate_function_header(code,

1427 0,

1428 with_dispatch = entry.type.is_overridable,

1429 with_opt_args = entry.type.optional_arg_count,

1430 cname = entry.func_cname)

1431 if not self.return_type.is_void:

1432 code.put('return ')

1433 args = self.type.args

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

1435 if entry.type.is_overridable:

1436 arglist.append(Naming.skip_dispatch_cname)

1437 elif func_type.is_overridable:

1438 arglist.append('0')

1439 if entry.type.optional_arg_count:

1440 arglist.append(Naming.optional_args_cname)

1441 elif func_type.optional_arg_count:

1442 arglist.append('NULL')

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

1444 code.putln('}')

1445

1446

1447 class PyArgDeclNode(Node):

1448 # Argument which must be a Python object (used

1449 # for * and ** arguments).

1450 #

1451 # name string

1452 # entry Symtab.Entry

1453 child_attrs = []

1454

1455

1456 class DecoratorNode(Node):

1457 # A decorator

1458 #

1459 # decorator NameNode or CallNode

1460 child_attrs = ['decorator']

1461

1462

1463 class DefNode(FuncDefNode):

1464 # A Python function definition.

1465 #

1466 # name string the Python name of the function

1467 # decorators [DecoratorNode] list of decorators

1468 # args [CArgDeclNode] formal arguments

1469 # star_arg PyArgDeclNode or None * argument

1470 # starstar_arg PyArgDeclNode or None ** argument

1471 # doc EncodedString or None

1472 # body StatListNode

1473 #

1474 # The following subnode is constructed internally

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

1476 #

1477 # assmt AssignmentNode Function construction/assignment

1478

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

1480

1481 assmt = None

1482 num_kwonly_args = 0

1483 num_required_kw_args = 0

1484 reqd_kw_flags_cname = "0"

1485 is_wrapper = 0

1486 decorators = None

1487 entry = None

1488

1489

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

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

1492 k = rk = r = 0

1493 for arg in self.args:

1494 if arg.kw_only:

1495 k += 1

1496 if not arg.default:

1497 rk += 1

1498 if not arg.default:

1499 r += 1

1500 self.num_kwonly_args = k

1501 self.num_required_kw_args = rk

1502 self.num_required_args = r

1503

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

1505 if self.star_arg:

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

1507 if self.starstar_arg:

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

1509 if cfunc is None:

1510 cfunc_args = []

1511 for formal_arg in self.args:

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

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

1514 cname = None,

1515 type = py_object_type,

1516 pos = formal_arg.pos))

1517 cfunc_type = PyrexTypes.CFuncType(return_type = py_object_type,

1518 args = cfunc_args,

1519 has_varargs = False,

1520 exception_value = None,

1521 exception_check = False,

1522 nogil = False,

1523 with_gil = False,

1524 is_overridable = True)

1525 cfunc = CVarDefNode(self.pos, type=cfunc_type, pxd_locals=[])

1526 else:

1527 cfunc_type = cfunc.type

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

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

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

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

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

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

1534 formal_arg.type = type_arg.type

1535 formal_arg.name_declarator = name_declarator

1536 import ExprNodes

1537 if cfunc_type.exception_value is None:

1538 exception_value = None

1539 else:

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

1541 declarator = CFuncDeclaratorNode(self.pos,

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

1543 args = self.args,

1544 has_varargs = False,

1545 exception_check = cfunc_type.exception_check,

1546 exception_value = exception_value,

1547 with_gil = cfunc_type.with_gil,

1548 nogil = cfunc_type.nogil)

1549 return CFuncDefNode(self.pos,

1550 modifiers = [],

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

1552 declarator = declarator,

1553 body = self.body,

1554 doc = self.doc,

1555 overridable = cfunc_type.is_overridable,

1556 type = cfunc_type,

1557 with_gil = cfunc_type.with_gil,

1558 nogil = cfunc_type.nogil,

1559 visibility = 'private',

1560 api = False,

1561 pxd_locals = cfunc.pxd_locals)

1562

1563 def analyse_declarations(self, env):

1564 if 'locals' in env.directives:

1565 directive_locals = env.directives['locals']

1566 else:

1567 directive_locals = {}

1568 self.directive_locals = directive_locals

1569 for arg in self.args:

1570 if hasattr(arg, 'name'):

1571 type = arg.type

1572 name_declarator = None

1573 else:

1574 base_type = arg.base_type.analyse(env)

1575 name_declarator, type = \

1576 arg.declarator.analyse(base_type, env)

1577 arg.name = name_declarator.name

1578 if arg.name in directive_locals:

1579 type_node = directive_locals[arg.name]

1580 other_type = type_node.analyse_as_type(env)

1581 if other_type is None:

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

1583 elif (type is not PyrexTypes.py_object_type

1584 and not type.same_as(other_type)):

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

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

1587 else:

1588 type = other_type

1589 if name_declarator and name_declarator.cname:

1590 error(self.pos,

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

1592 arg.type = type.as_argument_type()

1593 arg.hdr_type = None

1594 arg.needs_conversion = 0

1595 arg.needs_type_test = 0

1596 arg.is_generic = 1

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

1598 error(self.pos,

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

1600 self.declare_pyfunction(env)

1601 self.analyse_signature(env)

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

1603

1604 def analyse_signature(self, env):

1605 any_type_tests_needed = 0

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

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

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

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

1610 self.entry.signature = TypeSlots.pyfunction_noargs

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

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

1613 self.entry.signature = TypeSlots.pyfunction_onearg

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

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

1616 self.entry.signature = TypeSlots.unaryfunc

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

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

1619 self.entry.signature = TypeSlots.ibinaryfunc

1620 elif self.entry.is_special:

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

1622 sig = self.entry.signature

1623 nfixed = sig.num_fixed_args()

1624 for i in range(nfixed):

1625 if i < len(self.args):

1626 arg = self.args[i]

1627 arg.is_generic = 0

1628 if sig.is_self_arg(i):

1629 arg.is_self_arg = 1

1630 arg.hdr_type = arg.type = env.parent_type

1631 arg.needs_conversion = 0

1632 else:

1633 arg.hdr_type = sig.fixed_arg_type(i)

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

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

1636 arg.needs_type_test = 1

1637 any_type_tests_needed = 1

1638 else:

1639 arg.needs_conversion = 1

1640 if arg.needs_conversion:

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

1642 else:

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

1644 else:

1645 self.bad_signature()

1646 return

1647 if nfixed < len(self.args):

1648 if not sig.has_generic_args:

1649 self.bad_signature()

1650 for arg in self.args:

1651 if arg.is_generic and \

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

1653 arg.needs_type_test = 1

1654 any_type_tests_needed = 1

1655 elif arg.type is PyrexTypes.c_py_ssize_t_type:

1656 # Want to use __index__ rather than __int__ method

1657 # that PyArg_ParseTupleAndKeywords calls

1658 arg.needs_conversion = 1

1659 arg.hdr_type = PyrexTypes.py_object_type

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

1661 if any_type_tests_needed:

1662 env.use_utility_code(arg_type_test_utility_code)

1663

1664 def bad_signature(self):

1665 sig = self.entry.signature

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

1667 if sig.has_generic_args:

1668 expected_str = expected_str + " or more"

1669 name = self.name

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

1671 desc = "Special method"

1672 else:

1673 desc = "Method"

1674 error(self.pos,

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

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

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

1678

1679 def signature_has_nongeneric_args(self):

1680 argcount = len(self.args)

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

1682 return 0

1683 return 1

1684

1685 def signature_has_generic_args(self):

1686 return self.entry.signature.has_generic_args

1687

1688 def declare_pyfunction(self, env):

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

1690 name = self.name

1691 entry = env.lookup_here(self.name)

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

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

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

1695 self.entry = entry

1696 prefix = env.scope_prefix

1697 entry.func_cname = \

1698 Naming.pyfunc_prefix + prefix + name

1699 entry.pymethdef_cname = \

1700 Naming.pymethdef_prefix + prefix + name

1701 if Options.docstrings:

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

1703 entry.doc_cname = \

1704 Naming.funcdoc_prefix + prefix + name

1705 else:

1706 entry.doc = None

1707

1708 def declare_arguments(self, env):

1709 for arg in self.args:

1710 if not arg.name:

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

1712 if arg.needs_conversion:

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

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

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

1716 if arg.type.is_pyobject:

1717 arg.entry.init = "0"

1718 arg.entry.init_to_none = 0

1719 else:

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

1721 arg.entry.used = 1

1722 arg.entry.is_self_arg = arg.is_self_arg

1723 if not arg.is_self_arg:

1724 arg.name_entry = env.get_string_const(

1725 arg.name, identifier = True)

1726 env.add_py_string(arg.name_entry, identifier = True)

1727 if arg.hdr_type:

1728 if arg.is_self_arg or \

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

1730 arg.entry.is_declared_generic = 1

1731 self.declare_python_arg(env, self.star_arg)

1732 self.declare_python_arg(env, self.starstar_arg)

1733

1734 def declare_python_arg(self, env, arg):

1735 if arg:

1736 entry = env.declare_var(arg.name,

1737 PyrexTypes.py_object_type, arg.pos)

1738 entry.used = 1

1739 entry.init = "0"

1740 entry.init_to_none = 0

1741 entry.xdecref_cleanup = 1

1742 arg.entry = entry

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

1744

1745 def analyse_expressions(self, env):

1746 self.analyse_default_values(env)

1747 if env.is_py_class_scope:

1748 self.synthesize_assignment_node(env)

1749

1750 def synthesize_assignment_node(self, env):

1751 import ExprNodes

1752 self.assmt = SingleAssignmentNode(self.pos,

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

1754 rhs = ExprNodes.UnboundMethodNode(self.pos,

1755 class_cname = env.class_obj_cname,

1756 function = ExprNodes.PyCFunctionNode(self.pos,

1757 pymethdef_cname = self.entry.pymethdef_cname)))

1758 self.assmt.analyse_declarations(env)

1759 self.assmt.analyse_expressions(env)

1760

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

1762 arg_code_list = []

1763 sig = self.entry.signature

1764 if sig.has_dummy_arg:

1765 arg_code_list.append(

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

1767 for arg in self.args:

1768 if not arg.is_generic:

1769 if arg.is_self_arg:

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

1771 else:

1772 arg_code_list.append(

1773 arg.hdr_type.declaration_code(arg.hdr_cname))

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

1775 arg_code_list.append("PyObject *unused")

1776 if sig.has_generic_args:

1777 arg_code_list.append(

1778 "PyObject *%s, PyObject *%s"

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

1780 arg_code = ", ".join(arg_code_list)

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

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

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

1784 if proto_only:

1785 return

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

1787 docstr = self.entry.doc

1788 if not isinstance(docstr, str):

1789 docstr = docstr.utf8encode()

1790 code.putln(

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

1792 self.entry.doc_cname,

1793 split_docstring(escape_byte_string(docstr))))

1794 if with_pymethdef:

1795 code.put(

1796 "static PyMethodDef %s = " %

1797 self.entry.pymethdef_cname)

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

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

1800

1801 def generate_argument_declarations(self, env, code):

1802 for arg in self.args:

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

1804 if arg.needs_conversion:

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

1806 else:

1807 code.put_var_declaration(arg.entry)

1808

1809 def generate_keyword_list(self, code):

1810 if self.signature_has_generic_args() and \

1811 self.signature_has_nongeneric_args():

1812 code.put(

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

1814 Naming.pykwdlist_cname)

1815 for arg in self.args:

1816 if arg.is_generic:

1817 code.put('&%s,' % arg.name_entry.pystring_cname)

1818 code.putln("0};")

1819

1820 def generate_argument_parsing_code(self, env, code):

1821 # Generate PyArg_ParseTuple call for generic

1822 # arguments, if any.

1823 if self.entry.signature.has_dummy_arg:

1824 # get rid of unused argument warning

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

1826

1827 old_error_label = code.new_error_label()

1828 our_error_label = code.error_label

1829 end_label = code.new_label("argument_unpacking_done")

1830

1831 has_kwonly_args = self.num_kwonly_args > 0

1832 has_star_or_kw_args = self.star_arg is not None \

1833 or self.starstar_arg is not None or has_kwonly_args

1834

1835 if not self.signature_has_generic_args():

1836 if has_star_or_kw_args:

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

1838 self.generate_argument_conversion_code(code)

1839

1840 elif not self.signature_has_nongeneric_args():

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

1842 self.generate_stararg_copy_code(code)

1843

1844 else:

1845 positional_args = []

1846 kw_only_args = []

1847 default_seen = 0

1848 for arg in self.args:

1849 arg_entry = arg.entry

1850 if arg.is_generic:

1851 if arg.default:

1852 code.putln(

1853 "%s = %s;" % (

1854 arg_entry.cname,

1855 arg.default_result_code))

1856 default_seen = 1

1857 if not arg.is_self_arg:

1858 if arg.kw_only:

1859 kw_only_args.append(arg)

1860 else:

1861 positional_args.append(arg)

1862 elif arg.kw_only:

1863 kw_only_args.append(arg)

1864 default_seen = 1

1865 elif default_seen:

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

1867 elif not arg.is_self_arg:

1868 positional_args.append(arg)

1869 if arg.needs_conversion:

1870 format = arg.hdr_type.parsetuple_format

1871 else:

1872 format = arg_entry.type.parsetuple_format

1873 if not format:

1874 error(arg.pos,

1875 "Cannot convert Python object argument to type '%s' (when parsing input arguments)"

1876 % arg.type)

1877

1878 self.generate_tuple_and_keyword_parsing_code(

1879 positional_args, kw_only_args, end_label, code)

1880

1881 code.error_label = old_error_label

1882 if code.label_used(our_error_label):

1883 if not code.label_used(end_label):

1884 code.put_goto(end_label)

1885 code.put_label(our_error_label)

1886 if has_star_or_kw_args:

1887 self.generate_arg_decref(self.star_arg, code)

1888 if self.starstar_arg:

1889 if self.starstar_arg.entry.xdecref_cleanup:

1890 code.put_var_xdecref(self.starstar_arg.entry)

1891 else:

1892 code.put_var_decref(self.starstar_arg.entry)

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

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

1895 if code.label_used(end_label):

1896 code.put_label(end_label)

1897

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

1899 if arg.type.is_pyobject:

1900 if arg.is_generic:

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

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

1903 else:

1904 func = arg.type.from_py_function

1905 if func:

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

1907 arg.entry.cname,

1908 func,

1909 item,

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

1911 else:

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

1913

1914 def generate_arg_xdecref(self, arg, code):

1915 if arg:

1916 code.put_var_xdecref(arg.entry)

1917

1918 def generate_arg_decref(self, arg, code):

1919 if arg:

1920 code.put_var_decref(arg.entry)

1921

1922 def generate_stararg_copy_code(self, code):

1923 if not self.star_arg:

1924 code.globalstate.use_utility_code(raise_argtuple_invalid_utility_code)

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

1926 Naming.args_cname)

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

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

1929 code.putln("}")

1930

1931 code.globalstate.use_utility_code(keyword_string_check_utility_code)

1932

1933 if self.starstar_arg:

1934 if self.star_arg:

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

1936 else:

1937 kwarg_check = "%s" % Naming.kwds_cname

1938 else:

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

1940 Naming.kwds_cname, Naming.kwds_cname)

1941 code.putln(

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

1943 kwarg_check, Naming.kwds_cname, self.name,

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

1945

1946 if self.starstar_arg:

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

1948 self.starstar_arg.entry.cname,

1949 Naming.kwds_cname,

1950 Naming.kwds_cname))

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

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

1953 self.starstar_arg.entry.xdecref_cleanup = 0

1954

1955 if self.star_arg:

1956 code.put_incref(Naming.args_cname, py_object_type)

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

1958 self.star_arg.entry.cname,

1959 Naming.args_cname))

1960 self.star_arg.entry.xdecref_cleanup = 0

1961

1962 def generate_tuple_and_keyword_parsing_code(self, positional_args,

1963 kw_only_args, success_label, code):

1964 argtuple_error_label = code.new_label("argtuple_error")

1965

1966 min_positional_args = self.num_required_args - self.num_required_kw_args

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

1968 min_positional_args -= 1

1969 max_positional_args = len(positional_args)

1970 has_fixed_positional_count = not self.star_arg and \

1971 min_positional_args == max_positional_args

1972

1973 code.globalstate.use_utility_code(raise_double_keywords_utility_code)

1974 code.globalstate.use_utility_code(raise_argtuple_invalid_utility_code)

1975 if self.num_required_kw_args:

1976 code.globalstate.use_utility_code(raise_keyword_required_utility_code)

1977

1978 if self.starstar_arg or self.star_arg:

1979 self.generate_stararg_init_code(max_positional_args, code)

1980

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

1982 if self.num_required_kw_args:

1983 likely_hint = "likely"

1984 else:

1985 likely_hint = "unlikely"

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

1987 self.generate_keyword_unpacking_code(

1988 min_positional_args, max_positional_args,

1989 has_fixed_positional_count,

1990 positional_args, kw_only_args, argtuple_error_label, code)

1991

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

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

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

1995 # check the length here

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

1997 compare = '!='

1998 else:

1999 compare = '<'

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

2001 Naming.args_cname, compare, min_positional_args))

2002 code.put_goto(argtuple_error_label)

2003

2004 if self.num_required_kw_args:

2005 # pure error case: keywords required but not passed

2006 if max_positional_args > min_positional_args and not self.star_arg:

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

2008 Naming.args_cname, max_positional_args))

2009 code.put_goto(argtuple_error_label)

2010 code.putln('} else {')

2011 for i, arg in enumerate(kw_only_args):

2012 if not arg.default:

2013 # required keyword-only argument missing

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

2015 self.name.utf8encode(),

2016 arg.name_entry.pystring_cname))

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

2018 break

2019

2020 elif min_positional_args == max_positional_args:

2021 # parse the exact number of positional arguments from the

2022 # args tuple

2023 code.putln('} else {')

2024 for i, arg in enumerate(positional_args):

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

2026 self.generate_arg_assignment(arg, item, code)

2027

2028 else:

2029 # parse the positional arguments from the variable length

2030 # args tuple

2031 code.putln('} else {')

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

2033 if self.star_arg:

2034 code.putln('default:')

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

2036 for i, arg in reversed_args:

2037 if i >= min_positional_args-1:

2038 if min_positional_args > 1:

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

2040 else:

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

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

2043 self.generate_arg_assignment(arg, item, code)

2044 if min_positional_args == 0:

2045 code.put('case 0: ')

2046 code.putln('break;')

2047 if self.star_arg:

2048 if min_positional_args:

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

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

2051 code.put_goto(argtuple_error_label)

2052 else:

2053 code.put('default: ')

2054 code.put_goto(argtuple_error_label)

2055 code.putln('}')

2056

2057 code.putln('}')

2058

2059 if code.label_used(argtuple_error_label):

2060 code.put_goto(success_label)

2061 code.put_label(argtuple_error_label)

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

2063 self.name.utf8encode(), has_fixed_positional_count,

2064 min_positional_args, max_positional_args,

2065 Naming.args_cname))

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

2067

2068 def generate_stararg_init_code(self, max_positional_args, code):

2069 if self.starstar_arg:

2070 self.starstar_arg.entry.xdecref_cleanup = 0

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

2072 self.starstar_arg.entry.cname,

2073 self.starstar_arg.entry.cname,

2074 self.error_value()))

2075 if self.star_arg:

2076 self.star_arg.entry.xdecref_cleanup = 0

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

2078 Naming.args_cname,

2079 max_positional_args))

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

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

2082 max_positional_args, Naming.args_cname))

2083 if self.starstar_arg:

2084 code.putln("")

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

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

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

2088 code.putln('}')

2089 else:

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

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

2092 code.putln('} else {')

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

2094 code.put_incref(Naming.empty_tuple, py_object_type)

2095 code.putln('}')

2096

2097 def generate_keyword_unpacking_code(self, min_positional_args, max_positional_args,

2098 has_fixed_positional_count, positional_args,

2099 kw_only_args, argtuple_error_label, code):

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

2101 max_args = len(all_args)

2102

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

2104 max_args, ('0,'*max_args)[:-1]))

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

2106 Naming.kwds_cname)

2107

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

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

2110 if self.star_arg:

2111 code.putln('default:')

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

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

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

2115 i, Naming.args_cname, i))

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

2117 if not self.star_arg:

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

2119 code.put_goto(argtuple_error_label)

2120 code.putln('}')

2121

2122 # now fill up the required arguments with values from the kw dict

2123 last_required_arg = -1

2124 for i, arg in enumerate(all_args):

2125 if not arg.default:

2126 last_required_arg = i

2127 if last_required_arg >= 0:

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

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

2130 if i <= max_positional_args:

2131 if self.star_arg and i == max_positional_args:

2132 code.putln('default:')

2133 else:

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

2135 if arg.default:

2136 # handled in ParseOptionalKeywords() below

2137 continue

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

2139 i, Naming.kwds_cname, arg.name_entry.pystring_cname))

2140 if i < min_positional_args:

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

2142 if i == 0:

2143 # special case: we know arg 0 is missing

2144 code.put('else ')

2145 code.put_goto(argtuple_error_label)

2146 else:

2147 # print the correct number of values (args or

2148 # kwargs) that were passed into positional

2149 # arguments up to this point

2150 code.putln('else {')

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

2152 self.name.utf8encode(), has_fixed_positional_count,

2153 min_positional_args, max_positional_args, i))

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

2155 code.putln('}')

2156 else:

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

2158 if arg.kw_only and not arg.default:

2159 code.putln('else {')

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

2161 self.name.utf8encode(), arg.name_entry.pystring_cname))

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

2163 code.putln('}')

2164 code.putln('}')

2165

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

2167 # non-positional kw args left in dict: default args, **kwargs or error

2168 if self.star_arg:

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

2170 Naming.args_cname, max_positional_args,

2171 Naming.args_cname, max_positional_args))

2172 pos_arg_count = "used_pos_args"

2173 else:

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

2175 code.globalstate.use_utility_code(parse_keywords_utility_code)

2176 code.put(

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

2178 Naming.kwds_cname,

2179 Naming.pykwdlist_cname,

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

2181 pos_arg_count,

2182 self.name.utf8encode()))

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

2184 code.putln('}')

2185

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

2187 for i, arg in enumerate(all_args):

2188 if arg.default:

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

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

2191 if arg.default:

2192 code.putln('}')

2193

2194 def generate_argument_conversion_code(self, code):

2195 # Generate code to convert arguments from

2196 # signature type to declared type, if needed.

2197 for arg in self.args:

2198 if arg.needs_conversion:

2199 self.generate_arg_conversion(arg, code)

2200

2201 def generate_arg_conversion(self, arg, code):

2202 # Generate conversion code for one argument.

2203 old_type = arg.hdr_type

2204 new_type = arg.type

2205 if old_type.is_pyobject:

2206 if arg.default:

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

2208 else:

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

2210 self.generate_arg_conversion_from_pyobject(arg, code)

2211 code.putln("}")

2212 elif new_type.is_pyobject:

2213 self.generate_arg_conversion_to_pyobject(arg, code)

2214 else:

2215 if new_type.assignable_from(old_type):

2216 code.putln(

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

2218 else:

2219 error(arg.pos,

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

2221 (old_type, new_type))

2222

2223 def generate_arg_conversion_from_pyobject(self, arg, code):

2224 new_type = arg.type

2225 func = new_type.from_py_function

2226 # copied from CoerceFromPyTypeNode

2227 if func:

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

2229 arg.entry.cname,

2230 func,

2231 arg.hdr_cname,

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

2233 else:

2234 error(arg.pos,

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

2236 % new_type)

2237

2238 def generate_arg_conversion_to_pyobject(self, arg, code):

2239 old_type = arg.hdr_type

2240 func = old_type.to_py_function

2241 if func:

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

2243 arg.entry.cname,

2244 func,

2245 arg.hdr_cname,

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

2247 else:

2248 error(arg.pos,

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

2250 % old_type)

2251

2252 def generate_argument_type_tests(self, code):

2253 # Generate type tests for args whose signature

2254 # type is PyObject * and whose declared type is

2255 # a subtype thereof.

2256 for arg in self.args:

2257 if arg.needs_type_test:

2258 self.generate_arg_type_test(arg, code)

2259

2260 def generate_arg_type_test(self, arg, code):

2261 # Generate type test for one argument.

2262 if arg.type.typeobj_is_available():

2263 typeptr_cname = arg.type.typeptr_cname

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

2265 code.putln(

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

2267 arg_code,

2268 typeptr_cname,

2269 not arg.not_none,

2270 arg.name,

2271 arg.type.is_builtin_type,

2272 code.error_goto(arg.pos)))

2273 else:

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

2275 "without type object name specification")

2276

2277 def error_value(self):

2278 return self.entry.signature.error_value

2279

2280 def caller_will_check_exceptions(self):

2281 return 1

2282

2283 class OverrideCheckNode(StatNode):

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

2285 # is overriden.

2286 #

2287 # py_func

2288 #

2289 # args

2290 # func_temp

2291 # body

2292

2293 child_attrs = ['body']

2294

2295 body = None

2296

2297 def analyse_expressions(self, env):

2298 self.args = env.arg_entries

2299 if self.py_func.is_module_scope:

2300 first_arg = 0

2301 else:

2302 first_arg = 1

2303 import ExprNodes

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

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

2306 call_node = ExprNodes.SimpleCallNode(self.pos,

2307 function=self.func_node,

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

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

2310 self.body.analyse_expressions(env)

2311

2312 def generate_execution_code(self, code):

2313 # Check to see if we are an extension type

2314 if self.py_func.is_module_scope:

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

2316 else:

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

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

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

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

2321 if self.py_func.is_module_scope:

2322 code.putln("else {")

2323 else:

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

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

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

2327 code.putln("%s = PyObject_GetAttr(%s, %s); %s" % (self.func_node.result(), self_arg, self.py_func.interned_attr_cname, err))

2328 # It appears that this type is not anywhere exposed in the Python/C API

2329 is_builtin_function_or_method = '(strcmp(Py_TYPE(%s)->tp_name, "builtin_function_or_method") == 0)' % self.func_node.result()

2330 is_overridden = '(PyCFunction_GET_FUNCTION(%s) != (void *)&%s)' % (self.func_node.result(), self.py_func.entry.func_cname)

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

2332 self.body.generate_execution_code(code)

2333 code.putln('}')

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

2335 code.putln("}")

2336

2337 class ClassDefNode(StatNode, BlockNode):

2338 pass

2339

2340 class PyClassDefNode(ClassDefNode):

2341 # A Python class definition.

2342 #

2343 # name EncodedString Name of the class

2344 # doc string or None

2345 # body StatNode Attribute definition code

2346 # entry Symtab.Entry

2347 # scope PyClassScope

2348 #

2349 # The following subnodes are constructed internally:

2350 #

2351 # dict DictNode Class dictionary

2352 # classobj ClassNode Class object

2353 # target NameNode Variable to assign class object to

2354

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

2356

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

2358 StatNode.__init__(self, pos)

2359 self.name = name

2360 self.doc = doc

2361 self.body = body

2362 import ExprNodes

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

2364 if self.doc and Options.docstrings:

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

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

2367 else:

2368 doc_node = None

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

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

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

2372

2373 def as_cclass(self):

2374 """

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

2376 """

2377 bases = self.classobj.bases.args

2378 if len(bases) == 0:

2379 base_class_name = None

2380 base_class_module = None

2381 elif len(bases) == 1:

2382 base = bases[0]

2383 path = []

2384 from ExprNodes import AttributeNode, NameNode

2385 while isinstance(base, AttributeNode):

2386 path.insert(0, base.attribute)

2387 base = base.obj

2388 if isinstance(base, NameNode):

2389 path.insert(0, base.name)

2390 base_class_name = path[-1]

2391 if len(path) > 1:

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

2393 else:

2394 base_class_module = None

2395 else:

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

2397 else:

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

2399 return None

2400

2401 return CClassDefNode(self.pos,

2402 visibility = 'private',

2403 module_name = None,

2404 class_name = self.name,

2405 base_class_module = base_class_module,

2406 base_class_name = base_class_name,

2407 body = self.body,

2408 in_pxd = False,

2409 doc = self.doc)

2410

2411 def create_scope(self, env):

2412 genv = env

2413 while env.is_py_class_scope or env.is_c_class_scope:

2414 env = env.outer_scope

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

2416 return cenv

2417

2418 def analyse_declarations(self, env):

2419 self.target.analyse_target_declaration(env)

2420 cenv = self.create_scope(env)

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

2422 self.body.analyse_declarations(cenv)

2423

2424 def analyse_expressions(self, env):

2425 self.dict.analyse_expressions(env)

2426 self.classobj.analyse_expressions(env)

2427 genv = env.global_scope()

2428 cenv = self.scope

2429 cenv.class_dict_cname = self.dict.result()

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

2431 self.body.analyse_expressions(cenv)

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

2433 self.dict.release_temp(env)

2434 #self.classobj.release_temp(env)

2435 #self.target.release_target_temp(env)

2436

2437 def generate_function_definitions(self, env, code):

2438 self.generate_py_string_decls(self.scope, code)

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

2440

2441 def generate_execution_code(self, code):

2442 self.dict.generate_evaluation_code(code)

2443 self.classobj.generate_evaluation_code(code)

2444 self.body.generate_execution_code(code)

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

2446 self.dict.generate_disposal_code(code)

2447

2448

2449 class CClassDefNode(ClassDefNode):

2450 # An extension type definition.

2451 #

2452 # visibility 'private' or 'public' or 'extern'

2453 # typedef_flag boolean

2454 # api boolean

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

2456 # class_name string Unqualified name of class

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

2458 # base_class_module string or None Module containing the base class

2459 # base_class_name string or None Name of the base class

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

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

2462 # in_pxd boolean Is in a .pxd file

2463 # doc string or None

2464 # body StatNode or None

2465 # entry Symtab.Entry

2466 # base_type PyExtensionType or None

2467 # buffer_defaults_node DictNode or None Declares defaults for a buffer

2468 # buffer_defaults_pos

2469

2470 child_attrs = ["body"]

2471 buffer_defaults_node = None

2472 buffer_defaults_pos = None

2473 typedef_flag = False

2474 api = False

2475 objstruct_name = None

2476 typeobj_name = None

2477

2478 def analyse_declarations(self, env):

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

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

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

2482

2483 import Buffer

2484 if self.buffer_defaults_node:

2485 buffer_defaults = Buffer.analyse_buffer_options(self.buffer_defaults_pos,

2486 env, [], self.buffer_defaults_node,

2487 need_complete=False)

2488 else:

2489 buffer_defaults = None

2490

2491 if env.in_cinclude and not self.objstruct_name:

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

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

2494 self.base_type = None

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

2496 # import the modules for extern classes.

2497 if self.module_name:

2498 self.module = None

2499 for module in env.cimported_modules:

2500 if module.name == self.module_name:

2501 self.module = module

2502 if self.module is None:

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

2504 self.module.has_extern_class = 1

2505 env.cimported_modules.append(self.module)

2506

2507 if self.base_class_name:

2508 if self.base_class_module:

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

2510 else:

2511 base_class_scope = env

2512 if base_class_scope:

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

2514 if base_class_entry:

2515 if not base_class_entry.is_type:

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

2517 elif not base_class_entry.type.is_extension_type:

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

2519 elif not base_class_entry.type.is_complete():

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

2521 else:

2522 self.base_type = base_class_entry.type

2523 has_body = self.body is not None

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

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

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

2527 if not home_scope:

2528 return

2529 else:

2530 home_scope = env

2531 self.entry = home_scope.declare_c_class(

2532 name = self.class_name,

2533 pos = self.pos,

2534 defining = has_body and self.in_pxd,

2535 implementing = has_body and not self.in_pxd,

2536 module_name = self.module_name,

2537 base_type = self.base_type,

2538 objstruct_cname = self.objstruct_name,

2539 typeobj_cname = self.typeobj_name,

2540 visibility = self.visibility,

2541 typedef_flag = self.typedef_flag,

2542 api = self.api,

2543 buffer_defaults = buffer_defaults)

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

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

2546 scope = self.entry.type.scope

2547

2548 if self.doc and Options.docstrings:

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

2550

2551 if has_body:

2552 self.body.analyse_declarations(scope)

2553 if self.in_pxd:

2554 scope.defined = 1

2555 else:

2556 scope.implemented = 1

2557 env.allocate_vtable_names(self.entry)

2558

2559 def analyse_expressions(self, env):

2560 if self.body:

2561 scope = self.entry.type.scope

2562 self.body.analyse_expressions(scope)

2563

2564 def generate_function_definitions(self, env, code):

2565 self.generate_py_string_decls(self.entry.type.scope, code)

2566 if self.body:

2567 self.body.generate_function_definitions(

2568 self.entry.type.scope, code)

2569

2570 def generate_execution_code(self, code):

2571 # This is needed to generate evaluation code for

2572 # default values of method arguments.

2573 if self.body:

2574 self.body.generate_execution_code(code)

2575

2576 def annotate(self, code):

2577 if self.body:

2578 self.body.annotate(code)

2579

2580

2581 class PropertyNode(StatNode):

2582 # Definition of a property in an extension type.

2583 #

2584 # name string

2585 # doc EncodedString or None Doc string

2586 # body StatListNode

2587

2588 child_attrs = ["body"]

2589

2590 def analyse_declarations(self, env):

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

2592 if entry:

2593 if self.doc and Options.docstrings:

2594 doc_entry = env.get_string_const(

2595 self.doc, identifier = False)

2596 entry.doc_cname = doc_entry.cname

2597 self.body.analyse_declarations(entry.scope)

2598

2599 def analyse_expressions(self, env):

2600 self.body.analyse_expressions(env)

2601

2602 def generate_function_definitions(self, env, code):

2603 self.body.generate_function_definitions(env, code)

2604

2605 def generate_execution_code(self, code):

2606 pass

2607

2608 def annotate(self, code):

2609 self.body.annotate(code)

2610

2611

2612 class GlobalNode(StatNode):

2613 # Global variable declaration.

2614 #

2615 # names [string]

2616

2617 child_attrs = []

2618

2619 def analyse_declarations(self, env):

2620 for name in self.names:

2621 env.declare_global(name, self.pos)

2622

2623 def analyse_expressions(self, env):

2624 pass

2625

2626 def generate_execution_code(self, code):

2627 pass

2628

2629

2630 class ExprStatNode(StatNode):

2631 # Expression used as a statement.

2632 #

2633 # expr ExprNode

2634

2635 child_attrs = ["expr"]

2636

2637 def analyse_declarations(self, env):

2638 import ExprNodes

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

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

2641 if func == u'declare':

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

2643 if len(args):

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

2645 for var, type_node in kwds.key_value_pairs:

2646 type = type_node.analyse_as_type(env)

2647 if type is None:

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

2649 else:

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

2651 self.__class__ = PassStatNode

2652

2653 def analyse_expressions(self, env):

2654 self.expr.analyse_expressions(env)

2655 self.expr.release_temp(env)

2656

2657 def generate_execution_code(self, code):

2658 self.expr.generate_evaluation_code(code)

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

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

2661 self.expr.generate_disposal_code(code)

2662

2663 def annotate(self, code):

2664 self.expr.annotate(code)

2665

2666

2667 class AssignmentNode(StatNode):

2668 # Abstract base class for assignment nodes.

2669 #

2670 # The analyse_expressions and generate_execution_code

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

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

2673 # parallel assignment to be evaluated before assigning

2674 # to any of the left hand sides.

2675

2676 def analyse_expressions(self, env):

2677 self.analyse_types(env)

2678 self.allocate_rhs_temps(env)

2679 self.allocate_lhs_temps(env)

2680

2681 # def analyse_expressions(self, env):

2682 # self.analyse_expressions_1(env)

2683 # self.analyse_expressions_2(env)

2684

2685 def generate_execution_code(self, code):

2686 self.generate_rhs_evaluation_code(code)

2687 self.generate_assignment_code(code)

2688

2689

2690 class SingleAssignmentNode(AssignmentNode):

2691 # The simplest case:

2692 #

2693 # a = b

2694 #

2695 # lhs ExprNode Left hand side

2696 # rhs ExprNode Right hand side

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

2698

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

2700 first = False

2701 declaration_only = False

2702

2703 def analyse_declarations(self, env):

2704 import ExprNodes

2705

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

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

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

2709 if func_name:

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

2711

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

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

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

2715 return

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

2717 if type is None:

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

2719 return

2720 lhs = self.lhs

2721 if func_name == 'declare':

2722 if isinstance(lhs, ExprNodes.NameNode):

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

2724 elif isinstance(lhs, ExprNodes.TupleNode):

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

2726 else:

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

2728 return

2729 for var, pos in vars:

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

2731 if len(args) == 2:

2732 # we have a value

2733 self.rhs = args[1]

2734 else:

2735 self.declaration_only = True

2736 else:

2737 self.declaration_only = True

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

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

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

2741

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

2743 self.declaration_only = True

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

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

2746 return

2747 members = []

2748 for member, type_node in kwds.key_value_pairs:

2749 type = type_node.analyse_as_type(env)

2750 if type is None:

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

2752 else:

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

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

2755 return

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

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

2758 name = self.lhs.name

2759 scope = StructOrUnionScope(name)

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

2761 for member, type, pos in members:

2762 scope.declare_var(member, type, pos)

2763

2764 if self.declaration_only:

2765 return

2766 else:

2767 self.lhs.analyse_target_declaration(env)

2768

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

2770 self.rhs.analyse_types(env)

2771 self.lhs.analyse_target_types(env)

2772 self.lhs.gil_assignment_check(env)

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

2774 if use_temp:

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

2776

2777 def allocate_rhs_temps(self, env):

2778 self.rhs.allocate_temps(env)

2779

2780 def allocate_lhs_temps(self, env):

2781 self.lhs.allocate_target_temps(env, self.rhs)

2782 #self.lhs.release_target_temp(env)

2783 #self.rhs.release_temp(env)

2784

2785 # def analyse_expressions_1(self, env, use_temp = 0):

2786 # self.rhs.analyse_types(env)

2787 # self.lhs.analyse_target_types(env)

2788 # self.rhs = self.rhs.coerce_to(self.lhs.type, env)

2789 # if use_temp:

2790 # self.rhs = self.rhs.coerce_to_temp(env)

2791 # self.rhs.allocate_temps(env)

2792 #

2793 # def analyse_expressions_2(self, env):

2794 # self.lhs.allocate_target_temps(env)

2795 # self.lhs.release_target_temp(env)

2796 # self.rhs.release_temp(env)

2797

2798 def generate_rhs_evaluation_code(self, code):

2799 self.rhs.generate_evaluation_code(code)

2800

2801 def generate_assignment_code(self, code):

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

2803

2804 def annotate(self, code):

2805 self.lhs.annotate(code)

2806 self.rhs.annotate(code)

2807

2808

2809 class CascadedAssignmentNode(AssignmentNode):

2810 # An assignment with multiple left hand sides:

2811 #

2812 # a = b = c

2813 #

2814 # lhs_list [ExprNode] Left hand sides

2815 # rhs ExprNode Right hand sides

2816 #

2817 # Used internally:

2818 #

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

2820

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

2822 coerced_rhs_list = None

2823

2824 def analyse_declarations(self, env):

2825 for lhs in self.lhs_list:

2826 lhs.analyse_target_declaration(env)

2827

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

2829 self.rhs.analyse_types(env)

2830 if use_temp:

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

2832 else:

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

2834 from ExprNodes import CloneNode

2835 self.coerced_rhs_list = []

2836 for lhs in self.lhs_list:

2837 lhs.analyse_target_types(env)

2838 lhs.gil_assignment_check(env)

2839 rhs = CloneNode(self.rhs)

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

2841 self.coerced_rhs_list.append(rhs)

2842

2843 def allocate_rhs_temps(self, env):

2844 self.rhs.allocate_temps(env)

2845

2846 def allocate_lhs_temps(self, env):

2847 for lhs, rhs in zip(self.lhs_list, self.coerced_rhs_list):

2848 rhs.allocate_temps(env)

2849 lhs.allocate_target_temps(env, rhs)

2850 #lhs.release_target_temp(env)

2851 #rhs.release_temp(env)

2852 self.rhs.release_temp(env)

2853

2854 # def analyse_expressions_1(self, env, use_temp = 0):

2855 # self.rhs.analyse_types(env)

2856 # if use_temp:

2857 # self.rhs = self.rhs.coerce_to_temp(env)

2858 # else:

2859 # self.rhs = self.rhs.coerce_to_simple(env)

2860 # self.rhs.allocate_temps(env)

2861 #

2862 # def analyse_expressions_2(self, env):

2863 # from ExprNodes import CloneNode

2864 # self.coerced_rhs_list = []

2865 # for lhs in self.lhs_list:

2866 # lhs.analyse_target_types(env)

2867 # rhs = CloneNode(self.rhs)

2868 # rhs = rhs.coerce_to(lhs.type, env)

2869 # self.coerced_rhs_list.append(rhs)

2870 # rhs.allocate_temps(env)

2871 # lhs.allocate_target_temps(env)

2872 # lhs.release_target_temp(env)

2873 # rhs.release_temp(env)

2874 # self.rhs.release_temp(env)

2875

2876 def generate_rhs_evaluation_code(self, code):

2877 self.rhs.generate_evaluation_code(code)

2878

2879 def generate_assignment_code(self, code):

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

2881 lhs = self.lhs_list[i]

2882 rhs = self.coerced_rhs_list[i]

2883 rhs.generate_evaluation_code(code)

2884 lhs.generate_assignment_code(rhs, code)

2885 # Assignment has disposed of the cloned RHS

2886 self.rhs.generate_disposal_code(code)

2887

2888 def annotate(self, code):

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

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

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

2892 self.rhs.annotate(code)

2893

2894

2895 class ParallelAssignmentNode(AssignmentNode):

2896 # A combined packing/unpacking assignment:

2897 #

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

2899 #

2900 # This has been rearranged by the parser into

2901 #

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

2903 #

2904 # but we must evaluate all the right hand sides

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

2906 #

2907 # stats [AssignmentNode] The constituent assignments

2908

2909 child_attrs = ["stats"]

2910

2911 def analyse_declarations(self, env):

2912 for stat in self.stats:

2913 stat.analyse_declarations(env)

2914

2915 def analyse_expressions(self, env):

2916 for stat in self.stats:

2917 stat.analyse_types(env, use_temp = 1)

2918 stat.allocate_rhs_temps(env)

2919 for stat in self.stats:

2920 stat.allocate_lhs_temps(env)

2921

2922 # def analyse_expressions(self, env):

2923 # for stat in self.stats:

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

2925 # for stat in self.stats:

2926 # stat.analyse_expressions_2(env)

2927

2928 def generate_execution_code(self, code):

2929 for stat in self.stats:

2930 stat.generate_rhs_evaluation_code(code)

2931 for stat in self.stats:

2932 stat.generate_assignment_code(code)

2933

2934 def annotate(self, code):

2935 for stat in self.stats:

2936 stat.annotate(code)

2937

2938

2939 class InPlaceAssignmentNode(AssignmentNode):

2940 # An in place arithmatic operand:

2941 #

2942 # a += b

2943 # a -= b

2944 # ...

2945 #

2946 # lhs ExprNode Left hand side

2947 # rhs ExprNode Right hand side

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

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

2950 #

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

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

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

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

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

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

2957

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

2959 dup = None

2960

2961 def analyse_declarations(self, env):

2962 self.lhs.analyse_target_declaration(env)

2963

2964 def analyse_types(self, env):

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

2966 self.rhs.analyse_types(env)

2967 self.lhs.analyse_target_types(env)

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

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

2970

2971 def allocate_rhs_temps(self, env):

2972 import ExprNodes

2973 if self.lhs.type.is_pyobject:

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

2975 elif self.rhs.type.is_pyobject:

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

2977 if self.lhs.type.is_pyobject:

2978 self.result_value = ExprNodes.PyTempNode(self.pos, env).coerce_to(self.lhs.type, env)

2979 self.result_value.allocate_temps(env)

2980 # if use_temp:

2981 # self.rhs = self.rhs.coerce_to_temp(env)

2982 self.rhs.allocate_temps(env)

2983 self.dup.allocate_subexpr_temps(env)

2984 self.dup.allocate_temp(env)

2985

2986 def allocate_lhs_temps(self, env):

2987 self.lhs.allocate_target_temps(env, self.rhs)

2988 # self.lhs.release_target_temp(env)

2989 self.dup.release_temp(env)

2990 if self.dup.is_temp:

2991 self.dup.release_subexpr_temps(env)

2992 # self.rhs.release_temp(env)

2993 if self.lhs.type.is_pyobject:

2994 self.result_value.release_temp(env)

2995

2996 def generate_execution_code(self, code):

2997 self.rhs.generate_evaluation_code(code)

2998 self.dup.generate_subexpr_evaluation_code(code)

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

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

3001 extra = ", Py_None"

3002 else:

3003 extra = ""

3004 import ExprNodes

3005 if self.lhs.type.is_pyobject:

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

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

3008 self.dup.generate_result_code(code)

3009 code.putln(

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

3011 self.result_value.result(),

3012 self.py_operation_function(),

3013 self.dup.py_result(),

3014 self.rhs.py_result(),

3015 extra,

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

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

3018 self.rhs.generate_disposal_code(code)

3019 self.dup.generate_disposal_code(code)

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

3021 else:

3022 c_op = self.operator

3023 if c_op == "//":

3024 c_op = "/"

3025 elif c_op == "**":

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

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

3028 else:

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

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

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

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

3033 else:

3034 self.dup.generate_result_code(code)

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

3036 self.rhs.generate_disposal_code(code)

3037 if self.dup.is_temp:

3038 self.dup.generate_subexpr_disposal_code(code)

3039

3040 def create_dup_node(self, env):

3041 import ExprNodes

3042 self.dup = self.lhs

3043 self.dup.analyse_types(env)

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

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

3046 name = self.dup.name,

3047 is_temp = self.dup.is_temp,

3048 entry = self.dup.entry)

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

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

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

3052 attribute = self.dup.attribute,

3053 is_temp = self.dup.is_temp)

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

3055 if self.lhs.index:

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

3057 else:

3058 index = None

3059 if self.lhs.indices:

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

3061 else:

3062 indices = []

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

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

3065 index = index,

3066 indices = indices,

3067 is_temp = self.dup.is_temp)

3068 self.lhs = target_lhs

3069 return self.dup

3070

3071 def py_operation_function(self):

3072 return self.py_functions[self.operator]

3073

3074 py_functions = {

3075 "|": "PyNumber_InPlaceOr",

3076 "^": "PyNumber_InPlaceXor",

3077 "&": "PyNumber_InPlaceAnd",

3078 "+": "PyNumber_InPlaceAdd",

3079 "-": "PyNumber_InPlaceSubtract",

3080 "*": "PyNumber_InPlaceMultiply",

3081 "/": "PyNumber_InPlaceDivide",

3082 "%": "PyNumber_InPlaceRemainder",

3083 "<<": "PyNumber_InPlaceLshift",

3084 ">>": "PyNumber_InPlaceRshift",

3085 "**": "PyNumber_InPlacePower",

3086 "//": "PyNumber_InPlaceFloorDivide",

3087 }

3088

3089 def annotate(self, code):

3090 self.lhs.annotate(code)

3091 self.rhs.annotate(code)

3092 self.dup.annotate(code)

3093

3094

3095 class PrintStatNode(StatNode):

3096 # print statement

3097 #

3098 # arg_tuple TupleNode

3099 # append_newline boolean

3100

3101 child_attrs = ["arg_tuple"]

3102

3103 def analyse_expressions(self, env):

3104 self.arg_tuple.analyse_expressions(env)

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

3106 self.arg_tuple.release_temp(env)

3107 env.use_utility_code(printing_utility_code)

3108 self.gil_check(env)

3109

3110 gil_message = "Python print statement"

3111

3112 def generate_execution_code(self, code):

3113 self.arg_tuple.generate_evaluation_code(code)

3114 code.putln(

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

3116 self.arg_tuple.py_result(),

3117 self.append_newline,

3118 code.error_goto(self.pos)))

3119 self.arg_tuple.generate_disposal_code(code)

3120

3121 def annotate(self, code):

3122 self.arg_tuple.annotate(code)

3123

3124

3125 class ExecStatNode(StatNode):

3126 # exec statement

3127 #

3128 # args [ExprNode]

3129

3130 child_attrs = ["args"]

3131

3132 def analyse_expressions(self, env):

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

3134 arg.analyse_expressions(env)

3135 arg = arg.coerce_to_pyobject(env)

3136 arg.release_temp(env)

3137 self.args[i] = arg

3138 self.temp_result = env.allocate_temp_pyobject()

3139 env.release_temp(self.temp_result)

3140 env.use_utility_code(Builtin.pyexec_utility_code)

3141 self.gil_check(env)

3142

3143 gil_message = "Python exec statement"

3144

3145 def generate_execution_code(self, code):

3146 args = []

3147 for arg in self.args:

3148 arg.generate_evaluation_code(code)

3149 args.append( arg.py_result() )

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

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

3152 (self.temp_result,) + args))

3153 for arg in self.args:

3154 arg.generate_disposal_code(code)

3155 code.putln(

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

3157 code.put_decref_clear(self.temp_result, py_object_type)

3158

3159 def annotate(self, code):

3160 for arg in self.args:

3161 arg.annotate(code)

3162

3163

3164 class DelStatNode(StatNode):

3165 # del statement

3166 #

3167 # args [ExprNode]

3168

3169 child_attrs = ["args"]

3170

3171 def analyse_declarations(self, env):

3172 for arg in self.args:

3173 arg.analyse_target_declaration(env)

3174

3175 def analyse_expressions(self, env):

3176 for arg in self.args:

3177 arg.analyse_target_expression(env, None)

3178 if arg.type.is_pyobject:

3179 self.gil_check(env)

3180 else:

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

3182 #arg.release_target_temp(env)

3183

3184 gil_message = "Deleting Python object"

3185

3186 def generate_execution_code(self, code):

3187 for arg in self.args:

3188 if arg.type.is_pyobject:

3189 arg.generate_deletion_code(code)

3190 # else error reported earlier

3191

3192 def annotate(self, code):

3193 for arg in self.args:

3194 arg.annotate(code)

3195

3196

3197 class PassStatNode(StatNode):

3198 # pass statement

3199

3200 child_attrs = []

3201

3202 def analyse_expressions(self, env):

3203 pass

3204

3205 def generate_execution_code(self, code):

3206 pass

3207

3208

3209 class BreakStatNode(StatNode):

3210

3211 child_attrs = []

3212

3213 def analyse_expressions(self, env):

3214 pass

3215

3216 def generate_execution_code(self, code):

3217 if not code.break_label:

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

3219 else:

3220 #code.putln(

3221 # "goto %s;" %

3222 # code.break_label)

3223 code.put_goto(code.break_label)

3224

3225

3226 class ContinueStatNode(StatNode):

3227

3228 child_attrs = []

3229

3230 def analyse_expressions(self, env):

3231 pass

3232

3233 def generate_execution_code(self, code):

3234 if code.funcstate.in_try_finally:

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

3236 elif not code.continue_label:

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

3238 else:

3239 code.put_goto(code.continue_label)

3240

3241

3242 class ReturnStatNode(StatNode):

3243 # return statement

3244 #

3245 # value ExprNode or None

3246 # return_type PyrexType

3247 # temps_in_use [Entry] Temps in use at time of return

3248

3249 child_attrs = ["value"]

3250

3251 def analyse_expressions(self, env):

3252 return_type = env.return_type

3253 self.return_type = return_type

3254 self.temps_in_use = env.temps_in_use()

3255 if not return_type:

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

3257 return

3258 if self.value:

3259 self.value.analyse_types(env)

3260 if return_type.is_void or return_type.is_returncode:

3261 error(self.value.pos,

3262 "Return with value in void function")

3263 else:

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

3265 self.value.allocate_temps(env)

3266 self.value.release_temp(env)

3267 else:

3268 if (not return_type.is_void

3269 and not return_type.is_pyobject

3270 and not return_type.is_returncode):

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

3272 if return_type.is_pyobject:

3273 self.gil_check(env)

3274

3275 gil_message = "Returning Python object"

3276

3277 def generate_execution_code(self, code):

3278 code.mark_pos(self.pos)

3279 if not self.return_type:

3280 # error reported earlier

3281 return

3282 if self.value:

3283 self.value.generate_evaluation_code(code)

3284 self.value.make_owned_reference(code)

3285 code.putln(

3286 "%s = %s;" % (

3287 Naming.retval_cname,

3288 self.value.result_as(self.return_type)))

3289 self.value.generate_post_assignment_code(code)

3290 else:

3291 if self.return_type.is_pyobject:

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

3293 elif self.return_type.is_returncode:

3294 code.putln(

3295 "%s = %s;" % (

3296 Naming.retval_cname,

3297 self.return_type.default_value))

3298 # free temps the old way

3299 for entry in self.temps_in_use:

3300 code.put_var_decref_clear(entry)

3301 # free temps the new way

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

3303 code.put_decref_clear(cname, type)

3304 #code.putln(

3305 # "goto %s;" %

3306 # code.return_label)

3307 code.put_goto(code.return_label)

3308

3309 def annotate(self, code):

3310 if self.value:

3311 self.value.annotate(code)

3312

3313

3314 class RaiseStatNode(StatNode):

3315 # raise statement

3316 #

3317 # exc_type ExprNode or None

3318 # exc_value ExprNode or None

3319 # exc_tb ExprNode or None

3320

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

3322

3323 def analyse_expressions(self, env):

3324 if self.exc_type:

3325 self.exc_type.analyse_types(env)

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

3327 self.exc_type.allocate_temps(env)

3328 if self.exc_value:

3329 self.exc_value.analyse_types(env)

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

3331 self.exc_value.allocate_temps(env)

3332 if self.exc_tb:

3333 self.exc_tb.analyse_types(env)

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

3335 self.exc_tb.allocate_temps(env)

3336 if self.exc_type:

3337 self.exc_type.release_temp(env)

3338 if self.exc_value:

3339 self.exc_value.release_temp(env)

3340 if self.exc_tb:

3341 self.exc_tb.release_temp(env)

3342 env.use_utility_code(raise_utility_code)

3343 env.use_utility_code(restore_exception_utility_code)

3344 self.gil_check(env)

3345

3346 gil_message = "Raising exception"

3347

3348 def generate_execution_code(self, code):

3349 if self.exc_type:

3350 self.exc_type.generate_evaluation_code(code)

3351 type_code = self.exc_type.py_result()

3352 else:

3353 type_code = 0

3354 if self.exc_value:

3355 self.exc_value.generate_evaluation_code(code)

3356 value_code = self.exc_value.py_result()

3357 else:

3358 value_code = "0"

3359 if self.exc_tb:

3360 self.exc_tb.generate_evaluation_code(code)

3361 tb_code = self.exc_tb.py_result()

3362 else:

3363 tb_code = "0"

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

3365 code.putln(

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

3367 type_code,

3368 value_code,

3369 tb_code))

3370 else:

3371 code.putln(

3372 "__Pyx_ReRaise();")

3373 if self.exc_type:

3374 self.exc_type.generate_disposal_code(code)

3375 if self.exc_value:

3376 self.exc_value.generate_disposal_code(code)

3377 if self.exc_tb:

3378 self.exc_tb.generate_disposal_code(code)

3379 code.putln(

3380 code.error_goto(self.pos))

3381

3382 def annotate(self, code):

3383 if self.exc_type:

3384 self.exc_type.annotate(code)

3385 if self.exc_value:

3386 self.exc_value.annotate(code)

3387 if self.exc_tb:

3388 self.exc_tb.annotate(code)

3389

3390

3391 class ReraiseStatNode(StatNode):

3392

3393 child_attrs = []

3394

3395 def analyse_expressions(self, env):

3396 self.gil_check(env)

3397 env.use_utility_code(raise_utility_code)

3398 env.use_utility_code(restore_exception_utility_code)

3399

3400 gil_message = "Raising exception"

3401

3402 def generate_execution_code(self, code):

3403 vars = code.funcstate.exc_vars

3404 if vars:

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

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

3407 else:

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

3409

3410

3411 class AssertStatNode(StatNode):

3412 # assert statement

3413 #

3414 # cond ExprNode

3415 # value ExprNode or None

3416

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

3418

3419 def analyse_expressions(self, env):

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

3421 if self.value:

3422 self.value.analyse_types(env)

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

3424 self.value.allocate_temps(env)

3425 self.cond.release_temp(env)

3426 if self.value:

3427 self.value.release_temp(env)

3428 self.gil_check(env)

3429 #env.recycle_pending_temps() # TEMPORARY

3430

3431 gil_message = "Raising exception"

3432

3433 def generate_execution_code(self, code):

3434 code.putln("#ifndef PYREX_WITHOUT_ASSERTIONS")

3435 self.cond.generate_evaluation_code(code)

3436 code.putln(

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

3438 self.cond.result())

3439 if self.value:

3440 self.value.generate_evaluation_code(code)

3441 code.putln(

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

3443 self.value.py_result())

3444 self.value.generate_disposal_code(code)

3445 else:

3446 code.putln(

3447 "PyErr_SetNone(PyExc_AssertionError);")

3448 code.putln(

3449 code.error_goto(self.pos))

3450 code.putln(

3451 "}")

3452 self.cond.generate_disposal_code(code)

3453 code.putln("#endif")

3454

3455 def annotate(self, code):

3456 self.cond.annotate(code)

3457 if self.value:

3458 self.value.annotate(code)

3459

3460

3461 class IfStatNode(StatNode):

3462 # if statement

3463 #

3464 # if_clauses [IfClauseNode]

3465 # else_clause StatNode or None

3466

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

3468

3469 def analyse_control_flow(self, env):

3470 env.start_branching(self.pos)

3471 for if_clause in self.if_clauses:

3472 if_clause.analyse_control_flow(env)

3473 env.next_branch(if_clause.end_pos())

3474 if self.else_clause:

3475 self.else_clause.analyse_control_flow(env)

3476 env.finish_branching(self.end_pos())

3477

3478 def analyse_declarations(self, env):

3479 for if_clause in self.if_clauses:

3480 if_clause.analyse_declarations(env)

3481 if self.else_clause:

3482 self.else_clause.analyse_declarations(env)

3483

3484 def analyse_expressions(self, env):

3485 for if_clause in self.if_clauses:

3486 if_clause.analyse_expressions(env)

3487 if self.else_clause:

3488 self.else_clause.analyse_expressions(env)

3489

3490 def generate_execution_code(self, code):

3491 code.mark_pos(self.pos)

3492 end_label = code.new_label()

3493 for if_clause in self.if_clauses:

3494 if_clause.generate_execution_code(code, end_label)

3495 if self.else_clause:

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

3497 self.else_clause.generate_execution_code(code)

3498 code.putln("}")

3499 code.put_label(end_label)

3500

3501 def annotate(self, code):

3502 for if_clause in self.if_clauses:

3503 if_clause.annotate(code)

3504 if self.else_clause:

3505 self.else_clause.annotate(code)

3506

3507

3508 class IfClauseNode(Node):

3509 # if or elif clause in an if statement

3510 #

3511 # condition ExprNode

3512 # body StatNode

3513

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

3515

3516 def analyse_control_flow(self, env):

3517 self.body.analyse_control_flow(env)

3518

3519 def analyse_declarations(self, env):

3520 self.condition.analyse_declarations(env)

3521 self.body.analyse_declarations(env)

3522

3523 def analyse_expressions(self, env):

3524 self.condition = \

3525 self.condition.analyse_temp_boolean_expression(env)

3526 self.condition.release_temp(env)

3527 self.body.analyse_expressions(env)

3528

3529 def generate_execution_code(self, code, end_label):

3530 self.condition.generate_evaluation_code(code)

3531 code.putln(

3532 "if (%s) {" %

3533 self.condition.result())

3534 self.body.generate_execution_code(code)

3535 #code.putln(

3536 # "goto %s;" %

3537 # end_label)

3538 code.put_goto(end_label)

3539 code.putln("}")

3540

3541 def annotate(self, code):

3542 self.condition.annotate(code)

3543 self.body.annotate(code)

3544

3545

3546 class SwitchCaseNode(StatNode):

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

3548 #

3549 # conditions [ExprNode]

3550 # body StatNode

3551

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

3553

3554 def generate_execution_code(self, code):

3555 for cond in self.conditions:

3556 code.putln("case %s:" % cond.calculate_result_code())

3557 self.body.generate_execution_code(code)

3558 code.putln("break;")

3559

3560 def annotate(self, code):

3561 for cond in self.conditions:

3562 cond.annotate(code)

3563 self.body.annotate(code)

3564

3565 class SwitchStatNode(StatNode):

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

3567 #

3568 # test ExprNode

3569 # cases [SwitchCaseNode]

3570 # else_clause StatNode or None

3571

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

3573

3574 def generate_execution_code(self, code):

3575 code.putln("switch (%s) {" % self.test.calculate_result_code())

3576 for case in self.cases:

3577 case.generate_execution_code(code)

3578 if self.else_clause is not None:

3579 code.putln("default:")

3580 self.else_clause.generate_execution_code(code)

3581 code.putln("break;")

3582 code.putln("}")

3583

3584 def annotate(self, code):

3585 self.test.annotate(code)

3586 for case in self.cases:

3587 case.annotate(code)

3588 if self.else_clause is not None:

3589 self.else_clause.annotate(code)

3590

3591 class LoopNode:

3592

3593 def analyse_control_flow(self, env):

3594 env.start_branching(self.pos)

3595 self.body.analyse_control_flow(env)

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

3597 if self.else_clause:

3598 self.else_clause.analyse_control_flow(env)

3599 env.finish_branching(self.end_pos())

3600

3601

3602 class WhileStatNode(LoopNode, StatNode):

3603 # while statement

3604 #

3605 # condition ExprNode

3606 # body StatNode

3607 # else_clause StatNode

3608

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

3610

3611 def analyse_declarations(self, env):

3612 self.body.analyse_declarations(env)

3613 if self.else_clause:

3614 self.else_clause.analyse_declarations(env)

3615

3616 def analyse_expressions(self, env):

3617 self.condition = \

3618 self.condition.analyse_temp_boolean_expression(env)

3619 self.condition.release_temp(env)

3620 #env.recycle_pending_temps() # TEMPORARY

3621 self.body.analyse_expressions(env)

3622 if self.else_clause:

3623 self.else_clause.analyse_expressions(env)

3624

3625 def generate_execution_code(self, code):

3626 old_loop_labels = code.new_loop_labels()

3627 code.putln(

3628 "while (1) {")

3629 self.condition.generate_evaluation_code(code)

3630 code.putln(

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

3632 self.condition.result())

3633 self.body.generate_execution_code(code)

3634 code.put_label(code.continue_label)

3635 code.putln("}")

3636 break_label = code.break_label

3637 code.set_loop_labels(old_loop_labels)

3638 if self.else_clause:

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

3640 self.else_clause.generate_execution_code(code)

3641 code.putln("}")

3642 code.put_label(break_label)

3643

3644 def annotate(self, code):

3645 self.condition.annotate(code)

3646 self.body.annotate(code)

3647 if self.else_clause:

3648 self.else_clause.annotate(code)

3649

3650

3651 def ForStatNode(pos, **kw):

3652 if kw.has_key('iterator'):

3653 return ForInStatNode(pos, **kw)

3654 else:

3655 return ForFromStatNode(pos, **kw)

3656

3657 class ForInStatNode(LoopNode, StatNode):

3658 # for statement

3659 #

3660 # target ExprNode

3661 # iterator IteratorNode

3662 # body StatNode

3663 # else_clause StatNode

3664 # item NextNode used internally

3665

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

3667 item = None

3668

3669 def analyse_declarations(self, env):

3670 self.target.analyse_target_declaration(env)

3671 self.body.analyse_declarations(env)

3672 if self.else_clause:

3673 self.else_clause.analyse_declarations(env)

3674

3675 def analyse_range_step(self, args):

3676 import ExprNodes

3677 # The direction must be determined at compile time to set relations.

3678 # Otherwise, return False.

3679 if len(args) < 3:

3680 self.step = ExprNodes.IntNode(pos = args[0].pos, value='1')

3681 self.relation1 = '<='

3682 self.relation2 = '<'

3683 return True

3684 else:

3685 step = args[2]

3686 if isinstance(step, ExprNodes.UnaryMinusNode) and isinstance(step.operand, ExprNodes.IntNode):

3687 step = ExprNodes.IntNode(pos = step.pos, value=str(-int(step.operand.value, 0)))

3688 if isinstance(step, ExprNodes.IntNode):

3689 step_value = int(step.value, 0)

3690 if step_value > 0:

3691 self.step = step

3692 self.relation1 = '<='

3693 self.relation2 = '<'

3694 return True

3695 elif step_value < 0:

3696 self.step = ExprNodes.IntNode(pos = step.pos, value=str(-step_value))

3697 self.relation1 = '>='

3698 self.relation2 = '>'

3699 return True

3700 return False

3701

3702

3703 def analyse_expressions(self, env):

3704 import ExprNodes

3705 self.target.analyse_target_types(env)

3706 if Options.convert_range and self.target.type.is_int:

3707 sequence = self.iterator.sequence

3708 if isinstance(sequence, ExprNodes.SimpleCallNode) \

3709 and sequence.self is None \

3710 and isinstance(sequence.function, ExprNodes.NameNode) \

3711 and (sequence.function.name == 'range' or sequence.function.name == 'xrange'):

3712 args = sequence.args

3713 # Make sure we can determine direction from step

3714 if self.analyse_range_step(args):

3715 # Mutate to ForFrom loop type

3716 self.__class__ = ForFromStatNode

3717 if len(args) == 1:

3718 self.bound1 = ExprNodes.IntNode(pos = sequence.pos, value='0')

3719 self.bound2 = args[0]

3720 else:

3721 self.bound1 = args[0]

3722 self.bound2 = args[1]

3723 ForFromStatNode.analyse_expressions(self, env)

3724 return

3725

3726 self.iterator.analyse_expressions(env)

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

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

3729 self.item.allocate_temps(env)

3730 self.target.allocate_target_temps(env, self.item)

3731 #self.item.release_temp(env)

3732 #self.target.release_target_temp(env)

3733 self.body.analyse_expressions(env)

3734 if self.else_clause:

3735 self.else_clause.analyse_expressions(env)

3736 self.iterator.release_temp(env)

3737

3738 def generate_execution_code(self, code):

3739 old_loop_labels = code.new_loop_labels()

3740 self.iterator.generate_evaluation_code(code)

3741 code.putln(

3742 "for (;;) {")

3743 self.item.generate_evaluation_code(code)

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

3745 self.body.generate_execution_code(code)

3746 code.put_label(code.continue_label)

3747 code.putln(

3748 "}")

3749 break_label = code.break_label

3750 code.set_loop_labels(old_loop_labels)

3751 if self.else_clause:

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

3753 self.else_clause.generate_execution_code(code)

3754 code.putln("}")

3755 code.put_label(break_label)

3756 self.iterator.generate_disposal_code(code)

3757

3758 def annotate(self, code):

3759 self.target.annotate(code)

3760 self.iterator.annotate(code)

3761 self.body.annotate(code)

3762 if self.else_clause:

3763 self.else_clause.annotate(code)

3764 self.item.annotate(code)

3765

3766

3767 class ForFromStatNode(LoopNode, StatNode):

3768 # for name from expr rel name rel expr

3769 #

3770 # target NameNode

3771 # bound1 ExprNode

3772 # relation1 string

3773 # relation2 string

3774 # bound2 ExprNode

3775 # step ExprNode or None

3776 # body StatNode

3777 # else_clause StatNode or None

3778 #

3779 # Used internally:

3780 #

3781 # is_py_target bool

3782 # loopvar_name string

3783 # py_loopvar_node PyTempNode or None

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

3785

3786 def analyse_declarations(self, env):

3787 self.target.analyse_target_declaration(env)

3788 self.body.analyse_declarations(env)

3789 if self.else_clause:

3790 self.else_clause.analyse_declarations(env)

3791

3792 def analyse_expressions(self, env):

3793 import ExprNodes

3794 self.target.analyse_target_types(env)

3795 self.bound1.analyse_types(env)

3796 self.bound2.analyse_types(env)

3797 if self.target.type.is_numeric:

3798 self.bound1 = self.bound1.coerce_to(self.target.type, env)

3799 self.bound2 = self.bound2.coerce_to(self.target.type, env)

3800 else:

3801 self.bound1 = self.bound1.coerce_to_integer(env)

3802 self.bound2 = self.bound2.coerce_to_integer(env)

3803 if self.step is not None:

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

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

3806 self.step.analyse_types(env)

3807 self.step = self.step.coerce_to_integer(env)

3808 if not (self.bound2.is_name or self.bound2.is_literal):

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

3810 target_type = self.target.type

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

3812 error(self.target.pos,

3813 "Integer for-loop variable must be of type int or Python object")

3814 #if not (target_type.is_pyobject

3815 # or target_type.assignable_from(PyrexTypes.c_int_type)):

3816 # error(self.target.pos,

3817 # "Cannot assign integer to variable of type '%s'" % target_type)

3818 if target_type.is_numeric:

3819 self.is_py_target = 0

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

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

3822 self.loopvar_name = self.target.entry.cname

3823 self.py_loopvar_node = None

3824 else:

3825 self.is_py_target = 1

3826 c_loopvar_node = ExprNodes.TempNode(self.pos,

3827 PyrexTypes.c_long_type, env)

3828 c_loopvar_node.allocate_temps(env)

3829 self.loopvar_name = c_loopvar_node.result()

3830 self.py_loopvar_node = \

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

3832 self.bound1.allocate_temps(env)

3833 self.bound2.allocate_temps(env)

3834 if self.step is not None:

3835 self.step.allocate_temps(env)

3836 if self.is_py_target:

3837 self.py_loopvar_node.allocate_temps(env)

3838 self.target.allocate_target_temps(env, self.py_loopvar_node)

3839 #self.target.release_target_temp(env)

3840 #self.py_loopvar_node.release_temp(env)

3841 self.body.analyse_expressions(env)

3842 if self.is_py_target:

3843 c_loopvar_node.release_temp(env)

3844 if self.else_clause:

3845 self.else_clause.analyse_expressions(env)

3846 self.bound1.release_temp(env)

3847 self.bound2.release_temp(env)

3848 if self.step is not None:

3849 self.step.release_temp(env)

3850

3851 def generate_execution_code(self, code):

3852 old_loop_labels = code.new_loop_labels()

3853 self.bound1.generate_evaluation_code(code)

3854 self.bound2.generate_evaluation_code(code)

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

3856 if self.step is not None:

3857 self.step.generate_evaluation_code(code)

3858 incop = "%s=%s" % (incop[0], self.step.result())

3859 code.putln(

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

3861 self.loopvar_name,

3862 self.bound1.result(), offset,

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

3864 self.loopvar_name, incop))

3865 if self.py_loopvar_node:

3866 self.py_loopvar_node.generate_evaluation_code(code)

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

3868 self.body.generate_execution_code(code)

3869 code.put_label(code.continue_label)

3870 code.putln("}")

3871 break_label = code.break_label

3872 code.set_loop_labels(old_loop_labels)

3873 if self.else_clause:

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

3875 self.else_clause.generate_execution_code(code)

3876 code.putln("}")

3877 code.put_label(break_label)

3878 self.bound1.generate_disposal_code(code)

3879 self.bound2.generate_disposal_code(code)

3880 if self.step is not None:

3881 self.step.generate_disposal_code(code)

3882

3883 relation_table = {

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

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

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

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

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

3889 }

3890

3891 def annotate(self, code):

3892 self.target.annotate(code)

3893 self.bound1.annotate(code)

3894 self.bound2.annotate(code)

3895 if self.step:

3896 self.bound2.annotate(code)

3897 self.body.annotate(code)

3898 if self.else_clause:

3899 self.else_clause.annotate(code)

3900

3901

3902 class WithStatNode(StatNode):

3903 """

3904 Represents a Python with statement.

3905

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

3907 analysis or generation phases.

3908 """

3909 # manager The with statement manager object

3910 # target Node (lhs expression)

3911 # body StatNode

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

3913

3914 class TryExceptStatNode(StatNode):

3915 # try .. except statement

3916 #

3917 # body StatNode

3918 # except_clauses [ExceptClauseNode]

3919 # else_clause StatNode or None

3920 # cleanup_list [Entry] temps to clean up on error

3921

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

3923

3924 def analyse_control_flow(self, env):

3925 env.start_branching(self.pos)

3926 self.body.analyse_control_flow(env)

3927 successful_try = env.control_flow # grab this for later

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

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

3930

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

3932 for except_clause in self.except_clauses:

3933 except_clause.analyse_control_flow(env)

3934 env.next_branch(except_clause.end_pos())

3935

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

3937 env.control_flow.incoming = successful_try

3938 if self.else_clause:

3939 self.else_clause.analyse_control_flow(env)

3940 env.finish_branching(self.end_pos())

3941

3942 def analyse_declarations(self, env):

3943 self.body.analyse_declarations(env)

3944 for except_clause in self.except_clauses:

3945 except_clause.analyse_declarations(env)

3946 if self.else_clause:

3947 self.else_clause.analyse_declarations(env)

3948 self.gil_check(env)

3949 env.use_utility_code(reset_exception_utility_code)

3950

3951 def analyse_expressions(self, env):

3952 self.body.analyse_expressions(env)

3953 self.cleanup_list = env.free_temp_entries[:]

3954 default_clause_seen = 0

3955 for except_clause in self.except_clauses:

3956 except_clause.analyse_expressions(env)

3957 if default_clause_seen:

3958 error(except_clause.pos, "default 'except:' must be last")

3959 if not except_clause.pattern:

3960 default_clause_seen = 1

3961 self.has_default_clause = default_clause_seen

3962 if self.else_clause:

3963 self.else_clause.analyse_expressions(env)

3964 self.gil_check(env)

3965

3966 gil_message = "Try-except statement"

3967

3968 def generate_execution_code(self, code):

3969 old_return_label = code.return_label

3970 old_error_label = code.new_error_label()

3971 our_error_label = code.error_label

3972 except_end_label = code.new_label('exception_handled')