1 #

2 # Pyrex - Parse tree nodes

3 #

4

5 import sys, os, time, copy

6

7 import Code

8 import Builtin

9 from Errors import error, warning, InternalError

10 import Naming

11 import PyrexTypes

12 import TypeSlots

13 from PyrexTypes import py_object_type, error_type, CTypedefType, CFuncType

14 from Symtab import ModuleScope, LocalScope, GeneratorLocalScope, \

15 StructOrUnionScope, PyClassScope, CClassScope

16 from Cython.Utils import open_new_file, replace_suffix

17 from Code import UtilityCode

18 from StringEncoding import EncodedString, escape_byte_string, split_docstring

19 import Options

20 import ControlFlow

21 import DebugFlags

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

72 from Code import CCodeWriter

73 from types import FunctionType

74

75 def write_func_call(func):

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

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

78 # here we annotate the code with this function call

79 # but only if new code is generated

80 node, code = args[:2]

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

82 ' ' * code.call_level,

83 node.__class__.__name__,

84 func.__name__,

85 node.pos[1:])

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

87 code.putln(marker)

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

89 code.call_level += 4

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

91 code.call_level -= 4

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

93 code.buffer.stream.seek(pristine)

94 else:

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

96 code.putln(marker)

97 return res

98 else:

99 return func(*args, **kwds)

100 return f

101

102 class VerboseCodeWriter(type):

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

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

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

106 attrs = dict(attrs)

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

108 if isinstance(m, FunctionType):

109 attrs[mname] = write_func_call(m)

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

111

112

113 class Node(object):

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

115 # is_name boolean Is a NameNode

116 # is_literal boolean Is a ConstNode

117

118 if DebugFlags.debug_trace_code_generation:

119 __metaclass__ = VerboseCodeWriter

120

121 is_name = 0

122 is_literal = 0

123 temps = None

124

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

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

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

128 child_attrs = None

129

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

131 self.pos = pos

132 self.__dict__.update(kw)

133

134 gil_message = "Operation"

135

136 nogil_check = None

137

138 def gil_error(self, env=None):

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

140

141 def clone_node(self):

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

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

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

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

146 level in the tree."""

147 result = copy.copy(self)

148 for attrname in result.child_attrs:

149 value = getattr(result, attrname)

150 if isinstance(value, list):

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

152 return result

153

154

155 #

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

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

158 #

159 # (0) analyse_control_flow

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

161 # queried.

162 #

163 # (1) analyse_declarations

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

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

166 # to an otherwise undeclared name).

167 #

168 # (2) analyse_expressions

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

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

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

172 # Allocate temporary locals for intermediate results. Fill

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

174 # fragment.

175 #

176 # (3) generate_code

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

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

179 # functions.

180 #

181

182 def analyse_control_flow(self, env):

183 pass

184

185 def analyse_declarations(self, env):

186 pass

187

188 def analyse_expressions(self, env):

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

190 self.__class__.__name__)

191

192 def generate_code(self, code):

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

194 self.__class__.__name__)

195

196 def annotate(self, code):

197 # mro does the wrong thing

198 if isinstance(self, BlockNode):

199 self.body.annotate(code)

200

201 def end_pos(self):

202 try:

203 return self._end_pos

204 except AttributeError:

205 pos = self.pos

206 if not self.child_attrs:

207 self._end_pos = pos

208 return pos

209 for attr in self.child_attrs:

210 child = getattr(self, attr)

211 # Sometimes lists, sometimes nodes

212 if child is None:

213 pass

214 elif isinstance(child, list):

215 for c in child:

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

217 else:

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

219 self._end_pos = pos

220 return pos

221

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

223 if cutoff == 0:

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

225 if encountered is None:

226 encountered = set()

227 if id(self) in encountered:

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

229 encountered.add(id(self))

230

231 def dump_child(x, level):

232 if isinstance(x, Node):

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

234 elif isinstance(x, list):

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

236 else:

237 return repr(x)

238

239

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

241 if len(attrs) == 0:

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

243 else:

244 indent = " " * level

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

246 for key, value in attrs:

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

248 res += "%s>" % indent

249 return res

250

251 class CompilerDirectivesNode(Node):

252 """

253 Sets compiler directives for the children nodes

254 """

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

256 # *all* possible directives.

257 # body Node

258 child_attrs = ["body"]

259

260 def analyse_control_flow(self, env):

261 old = env.directives

262 env.directives = self.directives

263 self.body.analyse_control_flow(env)

264 env.directives = old

265

266 def analyse_declarations(self, env):

267 old = env.directives

268 env.directives = self.directives

269 self.body.analyse_declarations(env)

270 env.directives = old

271

272 def analyse_expressions(self, env):

273 old = env.directives

274 env.directives = self.directives

275 self.body.analyse_expressions(env)

276 env.directives = old

277

278 def generate_function_definitions(self, env, code):

279 env_old = env.directives

280 code_old = code.globalstate.directives

281 code.globalstate.directives = self.directives

282 self.body.generate_function_definitions(env, code)

283 env.directives = env_old

284 code.globalstate.directives = code_old

285

286 def generate_execution_code(self, code):

287 old = code.globalstate.directives

288 code.globalstate.directives = self.directives

289 self.body.generate_execution_code(code)

290 code.globalstate.directives = old

291

292 def annotate(self, code):

293 old = code.globalstate.directives

294 code.globalstate.directives = self.directives

295 self.body.annotate(code)

296 code.globalstate.directives = old

297

298 class BlockNode(object):

299 # Mixin class for nodes representing a declaration block.

300

301 def generate_cached_builtins_decls(self, env, code):

302 entries = env.global_scope().undeclared_cached_builtins

303 for entry in entries:

304 code.globalstate.add_cached_builtin_decl(entry)

305 del entries[:]

306

307

308 class StatListNode(Node):

309 # stats a list of StatNode

310

311 child_attrs = ["stats"]

312

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

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

315 return node # No node-specific analysis necesarry

316 create_analysed = staticmethod(create_analysed)

317

318 def analyse_control_flow(self, env):

319 for stat in self.stats:

320 stat.analyse_control_flow(env)

321

322 def analyse_declarations(self, env):

323 #print "StatListNode.analyse_declarations" ###

324 for stat in self.stats:

325 stat.analyse_declarations(env)

326

327 def analyse_expressions(self, env):

328 #print "StatListNode.analyse_expressions" ###

329 for stat in self.stats:

330 stat.analyse_expressions(env)

331

332 def generate_function_definitions(self, env, code):

333 #print "StatListNode.generate_function_definitions" ###

334 for stat in self.stats:

335 stat.generate_function_definitions(env, code)

336

337 def generate_execution_code(self, code):

338 #print "StatListNode.generate_execution_code" ###

339 for stat in self.stats:

340 code.mark_pos(stat.pos)

341 stat.generate_execution_code(code)

342

343 def annotate(self, code):

344 for stat in self.stats:

345 stat.annotate(code)

346

347

348 class StatNode(Node):

349 #

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

351 #

352 # (1) generate_function_definitions

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

354 # unions, enums and functions defined in the current

355 # scope-block.

356 #

357 # (2) generate_execution_code

358 # Emit C code for executable statements.

359 #

360

361 def generate_function_definitions(self, env, code):

362 pass

363

364 def generate_execution_code(self, code):

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

366 self.__class__.__name__)

367

368

369 class CDefExternNode(StatNode):

370 # include_file string or None

371 # body StatNode

372

373 child_attrs = ["body"]

374

375 def analyse_declarations(self, env):

376 if self.include_file:

377 env.add_include_file(self.include_file)

378 old_cinclude_flag = env.in_cinclude

379 env.in_cinclude = 1

380 self.body.analyse_declarations(env)

381 env.in_cinclude = old_cinclude_flag

382

383 def analyse_expressions(self, env):

384 pass

385

386 def generate_execution_code(self, code):

387 pass

388

389 def annotate(self, code):

390 self.body.annotate(code)

391

392

393 class CDeclaratorNode(Node):

394 # Part of a C declaration.

395 #

396 # Processing during analyse_declarations phase:

397 #

398 # analyse

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

400 # CNameDeclaratorNode of the name being declared

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

402 #

403 # calling_convention string Calling convention of CFuncDeclaratorNode

404 # for which this is a base

405

406 child_attrs = []

407

408 calling_convention = ""

409

410

411 class CNameDeclaratorNode(CDeclaratorNode):

412 # name string The Pyrex name being declared

413 # cname string or None C name, if specified

414 # default ExprNode or None the value assigned on declaration

415

416 child_attrs = ['default']

417

418 default = None

419

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

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

422 # May have mistaken the name for the type.

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

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

425 elif base_type.is_void:

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

427 else:

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

429 base_type = py_object_type

430 self.type = base_type

431 return self, base_type

432

433 class CPtrDeclaratorNode(CDeclaratorNode):

434 # base CDeclaratorNode

435

436 child_attrs = ["base"]

437

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

439 if base_type.is_pyobject:

440 error(self.pos,

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

442 ptr_type = PyrexTypes.c_ptr_type(base_type)

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

444

445 class CArrayDeclaratorNode(CDeclaratorNode):

446 # base CDeclaratorNode

447 # dimension ExprNode

448

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

450

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

452 if self.dimension:

453 self.dimension.analyse_const_expression(env)

454 if not self.dimension.type.is_int:

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

456 size = self.dimension.get_constant_c_result_code()

457 if size is not None:

458 try:

459 size = int(size)

460 except ValueError:

461 # runtime constant?

462 pass

463 else:

464 size = None

465 if not base_type.is_complete():

466 error(self.pos,

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

468 if base_type.is_pyobject:

469 error(self.pos,

470 "Array element cannot be a Python object")

471 if base_type.is_cfunction:

472 error(self.pos,

473 "Array element cannot be a function")

474 array_type = PyrexTypes.c_array_type(base_type, size)

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

476

477

478 class CFuncDeclaratorNode(CDeclaratorNode):

479 # base CDeclaratorNode

480 # args [CArgDeclNode]

481 # has_varargs boolean

482 # exception_value ConstNode

483 # exception_check boolean True if PyErr_Occurred check needed

484 # nogil boolean Can be called without gil

485 # with_gil boolean Acquire gil around function body

486

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

488

489 overridable = 0

490 optional_arg_count = 0

491

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

493 if nonempty:

494 nonempty -= 1

495 func_type_args = []

496 for arg_node in self.args:

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

498 name = name_declarator.name

499 if name_declarator.cname:

500 error(self.pos,

501 "Function argument cannot have C name specification")

502 # Turn *[] argument into **

503 if type.is_array:

504 type = PyrexTypes.c_ptr_type(type.base_type)

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

506 if type.is_void:

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

508 func_type_args.append(

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

510 if arg_node.default:

511 self.optional_arg_count += 1

512 elif self.optional_arg_count:

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

514

515 if self.optional_arg_count:

516 scope = StructOrUnionScope()

517 arg_count_member = '%sn' % Naming.pyrex_prefix

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

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

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

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

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

523 kind = 'struct',

524 scope = scope,

525 typedef_flag = 0,

526 pos = self.pos,

527 cname = struct_cname)

528 self.op_args_struct.defined_in_pxd = 1

529 self.op_args_struct.used = 1

530

531 exc_val = None

532 exc_check = 0

533 if self.exception_check == '+':

534 env.add_include_file('stdexcept')

535 if return_type.is_pyobject \

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

537 and self.exception_check != '+':

538 error(self.pos,

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

540 else:

541 if self.exception_value:

542 self.exception_value.analyse_const_expression(env)

543 exc_val = self.exception_value.get_constant_c_result_code()

544 if self.exception_check == '+':

545 exc_val_type = self.exception_value.type

546 if not exc_val_type.is_error and \

547 not exc_val_type.is_pyobject and \

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

549 error(self.exception_value.pos,

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

551 else:

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

553 error(self.exception_value.pos,

554 "Exception value incompatible with function return type")

555 exc_check = self.exception_check

556 if return_type.is_array:

557 error(self.pos,

558 "Function cannot return an array")

559 if return_type.is_cfunction:

560 error(self.pos,

561 "Function cannot return a function")

562 func_type = PyrexTypes.CFuncType(

563 return_type, func_type_args, self.has_varargs,

564 optional_arg_count = self.optional_arg_count,

565 exception_value = exc_val, exception_check = exc_check,

566 calling_convention = self.base.calling_convention,

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

568 if self.optional_arg_count:

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

570 callspec = env.directives['callspec']

571 if callspec:

572 current = func_type.calling_convention

573 if current and current != callspec:

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

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

576 func_type.calling_convention = callspec

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

578

579

580 class CArgDeclNode(Node):

581 # Item in a function declaration argument list.

582 #

583 # base_type CBaseTypeNode

584 # declarator CDeclaratorNode

585 # not_none boolean Tagged with 'not None'

586 # default ExprNode or None

587 # default_value PyObjectConst constant for default value

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

589 # is_kw_only boolean Is a keyword-only argument

590

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

592

593 is_self_arg = 0

594 is_generic = 1

595 type = None

596 name_declarator = None

597 default_value = None

598

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

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

601 if self.type is None:

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

603 # We fix that here.

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

605 if nonempty:

606 self.declarator.name = self.base_type.name

607 self.base_type.name = None

608 self.base_type.is_basic_c_type = False

609 could_be_name = True

610 else:

611 could_be_name = False

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

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

614 self.declarator.name = self.base_type.arg_name

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

616 else:

617 return self.name_declarator, self.type

618

619 def calculate_default_value_code(self, code):

620 if self.default_value is None:

621 if self.default:

622 if self.default.is_literal:

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

624 self.default.generate_evaluation_code(code)

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

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

627 return self.default_value

628

629 def annotate(self, code):

630 if self.default:

631 self.default.annotate(code)

632

633

634 class CBaseTypeNode(Node):

635 # Abstract base class for C base type nodes.

636 #

637 # Processing during analyse_declarations phase:

638 #

639 # analyse

640 # Returns the type.

641

642 pass

643

644 class CAnalysedBaseTypeNode(Node):

645 # type type

646

647 child_attrs = []

648

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

650 return self.type

651

652 class CSimpleBaseTypeNode(CBaseTypeNode):

653 # name string

654 # module_path [string] Qualifying name components

655 # is_basic_c_type boolean

656 # signed boolean

657 # longness integer

658 # complex boolean

659 # is_self_arg boolean Is self argument of C method

660

661 child_attrs = []

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

663

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

665 # Return type descriptor.

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

667 type = None

668 if self.is_basic_c_type:

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

670 if not type:

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

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

673 type = py_object_type

674 elif self.name is None:

675 if self.is_self_arg and env.is_c_class_scope:

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

677 type = env.parent_type

678 else:

679 type = py_object_type

680 else:

681 if self.module_path:

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

683 else:

684 scope = env

685 if scope:

686 if scope.is_c_class_scope:

687 scope = scope.global_scope()

688 entry = scope.lookup(self.name)

689 if entry and entry.is_type:

690 type = entry.type

691 elif could_be_name:

692 if self.is_self_arg and env.is_c_class_scope:

693 type = env.parent_type

694 else:

695 type = py_object_type

696 self.arg_name = self.name

697 else:

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

699 if self.complex:

700 if not type.is_numeric or type.is_complex:

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

702 type = PyrexTypes.CComplexType(type)

703 type.create_declaration_utility_code(env)

704 if type:

705 return type

706 else:

707 return PyrexTypes.error_type

708

709 class CBufferAccessTypeNode(CBaseTypeNode):

710 # After parsing:

711 # positional_args [ExprNode] List of positional arguments

712 # keyword_args DictNode Keyword arguments

713 # base_type_node CBaseTypeNode

714

715 # After analysis:

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

717

718

719 child_attrs = ["base_type_node", "positional_args",

720 "keyword_args", "dtype_node"]

721

722 dtype_node = None

723

724 name = None

725

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

727 base_type = self.base_type_node.analyse(env)

728 if base_type.is_error: return base_type

729 import Buffer

730

731 options = Buffer.analyse_buffer_options(

732 self.pos,

733 env,

734 self.positional_args,

735 self.keyword_args,

736 base_type.buffer_defaults)

737

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

739 return self.type

740

741 class CComplexBaseTypeNode(CBaseTypeNode):

742 # base_type CBaseTypeNode

743 # declarator CDeclaratorNode

744

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

746

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

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

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

750 return type

751

752

753 class CVarDefNode(StatNode):

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

755 #

756 # visibility 'private' or 'public' or 'extern'

757 # base_type CBaseTypeNode

758 # declarators [CDeclaratorNode]

759 # in_pxd boolean

760 # api boolean

761 # need_properties [entry]

762

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

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

765

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

767 need_properties = ()

768

769 decorators = None

770 directive_locals = {}

771

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

773 if not dest_scope:

774 dest_scope = env

775 self.dest_scope = dest_scope

776 base_type = self.base_type.analyse(env)

777

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

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

780 # a property; made in AnalyseDeclarationsTransform).

781 if (dest_scope.is_c_class_scope

782 and self.visibility == 'public'

783 and base_type.is_pyobject

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

785 self.need_properties = []

786 need_property = True

787 visibility = 'private'

788 else:

789 need_property = False

790 visibility = self.visibility

791

792 for declarator in self.declarators:

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

794 if not type.is_complete():

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

796 error(declarator.pos,

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

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

799 error(declarator.pos,

800 "Python object cannot be declared extern")

801 name = name_declarator.name

802 cname = name_declarator.cname

803 if name == '':

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

805 return

806 if type.is_cfunction:

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

808 cname = cname, visibility = self.visibility, in_pxd = self.in_pxd,

809 api = self.api)

810 if entry is not None:

811 entry.directive_locals = self.directive_locals

812 else:

813 if self.directive_locals:

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

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

816 error(self.pos,

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

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

819 cname = cname, visibility = visibility, is_cdef = 1)

820 if need_property:

821 self.need_properties.append(entry)

822 entry.needs_property = 1

823

824

825 class CStructOrUnionDefNode(StatNode):

826 # name string

827 # cname string or None

828 # kind "struct" or "union"

829 # typedef_flag boolean

830 # visibility "public" or "private"

831 # in_pxd boolean

832 # attributes [CVarDefNode] or None

833 # entry Entry

834 # packed boolean

835

836 child_attrs = ["attributes"]

837

838 def analyse_declarations(self, env):

839 scope = None

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

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

842 if self.attributes is not None:

843 scope = StructOrUnionScope(self.name)

844 self.entry = env.declare_struct_or_union(

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

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

847 if self.attributes is not None:

848 if self.in_pxd and not env.in_cinclude:

849 self.entry.defined_in_pxd = 1

850 for attr in self.attributes:

851 attr.analyse_declarations(env, scope)

852 if self.visibility != 'extern':

853 need_typedef_indirection = False

854 for attr in scope.var_entries:

855 type = attr.type

856 while type.is_array:

857 type = type.base_type

858 if type == self.entry.type:

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

860 if self.typedef_flag:

861 while type.is_ptr:

862 type = type.base_type

863 if type == self.entry.type:

864 need_typedef_indirection = True

865 if need_typedef_indirection:

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

867 struct_entry = self.entry

868 self.entry = env.declare_typedef(

869 self.name, struct_entry.type, self.pos,

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

871 struct_entry.type.typedef_flag = False

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

873 struct_entry.cname = struct_entry.type.cname = \

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

875

876 def analyse_expressions(self, env):

877 pass

878

879 def generate_execution_code(self, code):

880 pass

881

882

883 class CEnumDefNode(StatNode):

884 # name string or None

885 # cname string or None

886 # items [CEnumDefItemNode]

887 # typedef_flag boolean

888 # visibility "public" or "private"

889 # in_pxd boolean

890 # entry Entry

891

892 child_attrs = ["items"]

893

894 def analyse_declarations(self, env):

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

896 cname = self.cname, typedef_flag = self.typedef_flag,

897 visibility = self.visibility)

898 if self.items is not None:

899 if self.in_pxd and not env.in_cinclude:

900 self.entry.defined_in_pxd = 1

901 for item in self.items:

902 item.analyse_declarations(env, self.entry)

903

904 def generate_execution_code(self, code):

905 if self.visibility == 'public':

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

907 for item in self.entry.enum_values:

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

909 temp,

910 item.cname,

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

912 code.put_gotref(temp)

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

914 Naming.module_cname,

915 item.name,

916 temp,

917 code.error_goto(item.pos)))

918 code.put_decref_clear(temp, PyrexTypes.py_object_type)

919 code.funcstate.release_temp(temp)

920

921

922 class CEnumDefItemNode(StatNode):

923 # name string

924 # cname string or None

925 # value ExprNode or None

926

927 child_attrs = ["value"]

928

929 def analyse_declarations(self, env, enum_entry):

930 if self.value:

931 self.value.analyse_const_expression(env)

932 if not self.value.type.is_int:

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

934 self.value.analyse_const_expression(env)

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

936 self.value, self.pos, cname = self.cname,

937 visibility = enum_entry.visibility)

938 enum_entry.enum_values.append(entry)

939

940

941 class CTypeDefNode(StatNode):

942 # base_type CBaseTypeNode

943 # declarator CDeclaratorNode

944 # visibility "public" or "private"

945 # in_pxd boolean

946

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

948

949 def analyse_declarations(self, env):

950 base = self.base_type.analyse(env)

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

952 name = name_declarator.name

953 cname = name_declarator.cname

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

955 cname = cname, visibility = self.visibility)

956 if self.in_pxd and not env.in_cinclude:

957 entry.defined_in_pxd = 1

958

959 def analyse_expressions(self, env):

960 pass

961 def generate_execution_code(self, code):

962 pass

963

964

965 class FuncDefNode(StatNode, BlockNode):

966 # Base class for function definition nodes.

967 #

968 # return_type PyrexType

969 # #filename string C name of filename string const

970 # entry Symtab.Entry

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

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

973

974 py_func = None

975 assmt = None

976 needs_closure = False

977

978 def analyse_default_values(self, env):

979 genv = env.global_scope()

980 for arg in self.args:

981 if arg.default:

982 if arg.is_generic:

983 arg.default.analyse_types(env)

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

985 else:

986 error(arg.pos,

987 "This argument cannot have a default value")

988 arg.default = None

989

990 def need_gil_acquisition(self, lenv):

991 return 0

992

993 def create_local_scope(self, env):

994 genv = env

995 while env.is_py_class_scope or env.is_c_class_scope:

996 env = env.outer_scope

997 if self.needs_closure:

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

999 else:

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

1001 lenv.return_type = self.return_type

1002 type = self.entry.type

1003 if type.is_cfunction:

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

1005 self.local_scope = lenv

1006 lenv.directives = env.directives

1007 return lenv

1008

1009 def generate_function_definitions(self, env, code):

1010 import Buffer

1011

1012 lenv = self.local_scope

1013

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

1015 self.entry.scope.is_c_class_scope)

1016

1017 # Generate C code for header and body of function

1018 code.enter_cfunc_scope()

1019 code.return_from_error_cleanup_label = code.new_label()

1020

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

1022 code.mark_pos(self.pos)

1023 self.generate_cached_builtins_decls(lenv, code)

1024 # ----- Function header

1025 code.putln("")

1026 if self.py_func:

1027 self.py_func.generate_function_header(code,

1028 with_pymethdef = env.is_py_class_scope,

1029 proto_only=True)

1030 self.generate_function_header(code,

1031 with_pymethdef = env.is_py_class_scope)

1032 # ----- Local variable declarations

1033 lenv.mangle_closure_cnames(Naming.cur_scope_cname)

1034 self.generate_argument_declarations(lenv, code)

1035 if self.needs_closure:

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

1037 code.put_var_declarations(lenv.var_entries)

1038 init = ""

1039 if not self.return_type.is_void:

1040 if self.return_type.is_pyobject:

1041 init = " = NULL"

1042 code.putln(

1043 "%s%s;" %

1044 (self.return_type.declaration_code(

1045 Naming.retval_cname),

1046 init))

1047 tempvardecl_code = code.insertion_point()

1048 self.generate_keyword_list(code)

1049 # ----- Extern library function declarations

1050 lenv.generate_library_function_declarations(code)

1051 # ----- GIL acquisition

1052 acquire_gil = self.need_gil_acquisition(lenv)

1053 if acquire_gil:

1054 env.use_utility_code(force_init_threads_utility_code)

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

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

1057 if not lenv.nogil:

1058 code.put_setup_refcount_context(self.entry.name)

1059 if is_getbuffer_slot:

1060 self.getbuffer_init(code)

1061 # ----- Fetch arguments

1062 self.generate_argument_parsing_code(env, code)

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

1064 # incref it to properly keep track of refcounts.

1065 for entry in lenv.arg_entries:

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

1067 code.put_var_incref(entry)

1068 # ----- Initialise local variables

1069 for entry in lenv.var_entries:

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

1071 code.put_init_var_to_py_none(entry)

1072 # ----- Initialise local buffer auxiliary variables

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

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

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

1076 # ----- Check and convert arguments

1077 self.generate_argument_type_tests(code)

1078 # ----- Acquire buffer arguments

1079 for entry in lenv.arg_entries:

1080 if entry.type.is_buffer:

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

1082 # ----- Function body

1083 self.body.generate_execution_code(code)

1084 # ----- Default return value

1085 code.putln("")

1086 if self.return_type.is_pyobject:

1087 #if self.return_type.is_extension_type:

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

1089 #else:

1090 lhs = Naming.retval_cname

1091 code.put_init_to_py_none(lhs, self.return_type)

1092 else:

1093 val = self.return_type.default_value

1094 if val:

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

1096 # ----- Error cleanup

1097 if code.error_label in code.labels_used:

1098 code.put_goto(code.return_label)

1099 code.put_label(code.error_label)

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

1101 code.put_xdecref(cname, type)

1102

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

1104 # so need to save and restore error state

1105 buffers_present = len(lenv.buffer_entries) > 0

1106 if buffers_present:

1107 code.globalstate.use_utility_code(restore_exception_utility_code)

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

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

1110 for entry in lenv.buffer_entries:

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

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

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

1114

1115 err_val = self.error_value()

1116 exc_check = self.caller_will_check_exceptions()

1117 if err_val is not None or exc_check:

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

1119 else:

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

1121 % self.entry.qualified_name, 0)

1122 code.putln(

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

1124 self.entry.qualified_name)

1125 env.use_utility_code(unraisable_exception_utility_code)

1126 env.use_utility_code(restore_exception_utility_code)

1127 default_retval = self.return_type.default_value

1128 if err_val is None and default_retval:

1129 err_val = default_retval

1130 if err_val is not None:

1131 code.putln(

1132 "%s = %s;" % (

1133 Naming.retval_cname,

1134 err_val))

1135

1136 if is_getbuffer_slot:

1137 self.getbuffer_error_cleanup(code)

1138

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

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

1141 # whether this section is used.

1142 if buffers_present or is_getbuffer_slot:

1143 code.put_goto(code.return_from_error_cleanup_label)

1144

1145

1146 # ----- Non-error return cleanup

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

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

1149 # block).

1150 code.put_label(code.return_label)

1151 for entry in lenv.buffer_entries:

1152 if entry.used:

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

1154 if is_getbuffer_slot:

1155 self.getbuffer_normal_cleanup(code)

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

1157 code.put_label(code.return_from_error_cleanup_label)

1158 if not Options.init_local_none:

1159 for entry in lenv.var_entries:

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

1161 entry.xdecref_cleanup = 1

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

1163 # Decref any increfed args

1164 for entry in lenv.arg_entries:

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

1166 code.put_var_decref(entry)

1167

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

1169 # ----- Return

1170 # This code is duplicated in ModuleNode.generate_module_init_func

1171 if not lenv.nogil:

1172 default_retval = self.return_type.default_value

1173 err_val = self.error_value()

1174 if err_val is None and default_retval:

1175 err_val = default_retval

1176 if self.return_type.is_pyobject:

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

1178

1179 code.put_finish_refcount_context()

1180

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

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

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

1184 code.putln("if (unlikely(%s == -1) && !PyErr_Occurred()) %s = -2;" % (Naming.retval_cname, Naming.retval_cname))

1185

1186 if acquire_gil:

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

1188

1189 if not self.return_type.is_void:

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

1191

1192 code.putln("}")

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

1194 tempvardecl_code.put_temp_declarations(code.funcstate)

1195 # ----- Python version

1196 code.exit_cfunc_scope()

1197 if self.py_func:

1198 self.py_func.generate_function_definitions(env, code)

1199 self.generate_wrapper_functions(code)

1200

1201 def declare_argument(self, env, arg):

1202 if arg.type.is_void:

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

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

1205 error(arg.pos,

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

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

1208

1209 def generate_wrapper_functions(self, code):

1210 pass

1211

1212 def generate_execution_code(self, code):

1213 # Evaluate and store argument default values

1214 for arg in self.args:

1215 default = arg.default

1216 if default:

1217 if not default.is_literal:

1218 default.generate_evaluation_code(code)

1219 default.make_owned_reference(code)

1220 result = default.result_as(arg.type)

1221 code.putln(

1222 "%s = %s;" % (

1223 arg.calculate_default_value_code(code),

1224 result))

1225 if arg.type.is_pyobject:

1226 code.put_giveref(default.result())

1227 default.generate_post_assignment_code(code)

1228 default.free_temps(code)

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

1230 if self.assmt:

1231 self.assmt.generate_execution_code(code)

1232

1233 #

1234 # Special code for the __getbuffer__ function

1235 #

1236 def getbuffer_init(self, code):

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

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

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

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

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

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

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

1244

1245 def getbuffer_error_cleanup(self, code):

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

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

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

1249 (info, info))

1250

1251 def getbuffer_normal_cleanup(self, code):

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

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

1254 code.put_gotref("Py_None")

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

1256 code.putln("}")

1257

1258 class CFuncDefNode(FuncDefNode):

1259 # C function definition.

1260 #

1261 # modifiers ['inline']

1262 # visibility 'private' or 'public' or 'extern'

1263 # base_type CBaseTypeNode

1264 # declarator CDeclaratorNode

1265 # body StatListNode

1266 # api boolean

1267 # decorators [DecoratorNode] list of decorators

1268 #

1269 # with_gil boolean Acquire GIL around body

1270 # type CFuncType

1271 # py_func wrapper for calling from Python

1272 # overridable whether or not this is a cpdef function

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

1274

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

1276

1277 inline_in_pxd = False

1278 decorators = None

1279 directive_locals = {}

1280

1281 def unqualified_name(self):

1282 return self.entry.name

1283

1284 def analyse_declarations(self, env):

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

1286 base_type = self.base_type.analyse(env)

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

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

1289 if not type.is_cfunction:

1290 error(self.pos,

1291 "Suite attached to non-function declaration")

1292 # Remember the actual type according to the function header

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

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

1295 # from the base type of an extension type.

1296 self.type = type

1297 type.is_overridable = self.overridable

1298 declarator = self.declarator

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

1300 declarator = declarator.base

1301 self.args = declarator.args

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

1303 formal_arg.type = type_arg.type

1304 formal_arg.name = type_arg.name

1305 formal_arg.cname = type_arg.cname

1306 name = name_declarator.name

1307 cname = name_declarator.cname

1308 self.entry = env.declare_cfunction(

1309 name, type, self.pos,

1310 cname = cname, visibility = self.visibility,

1311 defining = self.body is not None,

1312 api = self.api, modifiers = self.modifiers)

1313 self.entry.inline_func_in_pxd = self.inline_in_pxd

1314 self.return_type = type.return_type

1315

1316 if self.overridable and not env.is_module_scope:

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

1318 # An error will be produced in the cdef function

1319 self.overridable = False

1320

1321 if self.overridable:

1322 import ExprNodes

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

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

1325 name = self.entry.name,

1326 args = self.args,

1327 star_arg = None,

1328 starstar_arg = None,

1329 doc = self.doc,

1330 body = py_func_body,

1331 is_wrapper = 1)

1332 self.py_func.is_module_scope = env.is_module_scope

1333 self.py_func.analyse_declarations(env)

1334 self.entry.as_variable = self.py_func.entry

1335 # Reset scope entry the above cfunction

1336 env.entries[name] = self.entry

1337 if not env.is_module_scope or Options.lookup_module_cpdef:

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

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

1340

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

1342 import ExprNodes

1343 args = self.type.args

1344 if omit_optional_args:

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

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

1347 if is_module_scope:

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

1349 else:

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

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

1352 skip_dispatch = not is_module_scope or Options.lookup_module_cpdef

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

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

1355

1356 def declare_arguments(self, env):

1357 for arg in self.type.args:

1358 if not arg.name:

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

1360 self.declare_argument(env, arg)

1361

1362 def need_gil_acquisition(self, lenv):

1363 return self.type.with_gil

1364

1365 def nogil_check(self, env):

1366 type = self.type

1367 with_gil = type.with_gil

1368 if type.nogil and not with_gil:

1369 if type.return_type.is_pyobject:

1370 error(self.pos,

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

1372 for entry in self.local_scope.var_entries:

1373 if entry.type.is_pyobject:

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

1375

1376 def analyse_expressions(self, env):

1377 self.local_scope.directives = env.directives

1378 if self.py_func is not None:

1379 # this will also analyse the default values

1380 self.py_func.analyse_expressions(env)

1381 else:

1382 self.analyse_default_values(env)

1383

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

1385 arg_decls = []

1386 type = self.type

1387 visibility = self.entry.visibility

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

1389 arg_decls.append(arg.declaration_code())

1390 if with_dispatch and self.overridable:

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

1392 if type.optional_arg_count and with_opt_args:

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

1394 if type.has_varargs:

1395 arg_decls.append("...")

1396 if not arg_decls:

1397 arg_decls = ["void"]

1398 if cname is None:

1399 cname = self.entry.func_cname

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

1401 if visibility == 'public':

1402 dll_linkage = "DL_EXPORT"

1403 else:

1404 dll_linkage = None

1405 header = self.return_type.declaration_code(entity,

1406 dll_linkage = dll_linkage)

1407 if visibility == 'extern':

1408 storage_class = "%s " % Naming.extern_c_macro

1409 elif visibility == 'public':

1410 storage_class = ""

1411 else:

1412 storage_class = "static "

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

1414 storage_class,

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

1416 header))

1417

1418 def generate_argument_declarations(self, env, code):

1419 for arg in self.args:

1420 if arg.default:

1421 result = arg.calculate_default_value_code(code)

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

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

1424

1425 def generate_keyword_list(self, code):

1426 pass

1427

1428 def generate_argument_parsing_code(self, env, code):

1429 i = 0

1430 if self.type.optional_arg_count:

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

1432 for arg in self.args:

1433 if arg.default:

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

1435 # argument name mangling is in place

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

1437 declarator = arg.declarator

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

1439 declarator = declarator.base

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

1441 i += 1

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

1443 code.putln('}')

1444 code.putln('}')

1445

1446 def generate_argument_conversion_code(self, code):

1447 pass

1448

1449 def generate_argument_type_tests(self, code):

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

1451 # class is a supertype of the declared type.

1452 for arg in self.type.args:

1453 if arg.needs_type_test:

1454 self.generate_arg_type_test(arg, code)

1455

1456 def generate_arg_type_test(self, arg, code):

1457 # Generate type test for one argument.

1458 if arg.type.typeobj_is_available():

1459 typeptr_cname = arg.type.typeptr_cname

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

1461 code.putln(

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

1463 arg_code,

1464 typeptr_cname,

1465 not arg.not_none,

1466 arg.name,

1467 type.is_builtin_type,

1468 code.error_goto(arg.pos)))

1469 else:

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

1471 "without type object name specification")

1472

1473 def error_value(self):

1474 if self.return_type.is_pyobject:

1475 return "0"

1476 else:

1477 #return None

1478 return self.entry.type.exception_value

1479

1480 def caller_will_check_exceptions(self):

1481 return self.entry.type.exception_check

1482

1483 def generate_wrapper_functions(self, code):

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

1485 # wrappers to put in the slots here.

1486 k = 0

1487 entry = self.entry

1488 func_type = entry.type

1489 while entry.prev_entry is not None:

1490 k += 1

1491 entry = entry.prev_entry

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

1493 code.putln()

1494 self.generate_function_header(code,

1495 0,

1496 with_dispatch = entry.type.is_overridable,

1497 with_opt_args = entry.type.optional_arg_count,

1498 cname = entry.func_cname)

1499 if not self.return_type.is_void:

1500 code.put('return ')

1501 args = self.type.args

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

1503 if entry.type.is_overridable:

1504 arglist.append(Naming.skip_dispatch_cname)

1505 elif func_type.is_overridable:

1506 arglist.append('0')

1507 if entry.type.optional_arg_count:

1508 arglist.append(Naming.optional_args_cname)

1509 elif func_type.optional_arg_count:

1510 arglist.append('NULL')

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

1512 code.putln('}')

1513

1514

1515 class PyArgDeclNode(Node):

1516 # Argument which must be a Python object (used

1517 # for * and ** arguments).

1518 #

1519 # name string

1520 # entry Symtab.Entry

1521 child_attrs = []

1522

1523

1524 class DecoratorNode(Node):

1525 # A decorator

1526 #

1527 # decorator NameNode or CallNode

1528 child_attrs = ['decorator']

1529

1530

1531 class DefNode(FuncDefNode):

1532 # A Python function definition.

1533 #

1534 # name string the Python name of the function

1535 # decorators [DecoratorNode] list of decorators

1536 # args [CArgDeclNode] formal arguments

1537 # star_arg PyArgDeclNode or None * argument

1538 # starstar_arg PyArgDeclNode or None ** argument

1539 # doc EncodedString or None

1540 # body StatListNode

1541 #

1542 # The following subnode is constructed internally

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

1544 #

1545 # assmt AssignmentNode Function construction/assignment

1546

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

1548

1549 assmt = None

1550 num_kwonly_args = 0

1551 num_required_kw_args = 0

1552 reqd_kw_flags_cname = "0"

1553 is_wrapper = 0

1554 decorators = None

1555 entry = None

1556

1557

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

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

1560 k = rk = r = 0

1561 for arg in self.args:

1562 if arg.kw_only:

1563 k += 1

1564 if not arg.default:

1565 rk += 1

1566 if not arg.default:

1567 r += 1

1568 self.num_kwonly_args = k

1569 self.num_required_kw_args = rk

1570 self.num_required_args = r

1571

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

1573 if self.star_arg:

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

1575 if self.starstar_arg:

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

1577 if cfunc is None:

1578 cfunc_args = []

1579 for formal_arg in self.args:

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

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

1582 cname = None,

1583 type = py_object_type,

1584 pos = formal_arg.pos))

1585 cfunc_type = PyrexTypes.CFuncType(return_type = py_object_type,

1586 args = cfunc_args,

1587 has_varargs = False,

1588 exception_value = None,

1589 exception_check = False,

1590 nogil = False,

1591 with_gil = False,

1592 is_overridable = True)

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

1594 else:

1595 cfunc_type = cfunc.type

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

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

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

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

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

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

1602 formal_arg.type = type_arg.type

1603 formal_arg.name_declarator = name_declarator

1604 import ExprNodes

1605 if cfunc_type.exception_value is None:

1606 exception_value = None

1607 else:

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

1609 declarator = CFuncDeclaratorNode(self.pos,

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

1611 args = self.args,

1612 has_varargs = False,

1613 exception_check = cfunc_type.exception_check,

1614 exception_value = exception_value,

1615 with_gil = cfunc_type.with_gil,

1616 nogil = cfunc_type.nogil)

1617 return CFuncDefNode(self.pos,

1618 modifiers = [],

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

1620 declarator = declarator,

1621 body = self.body,

1622 doc = self.doc,

1623 overridable = cfunc_type.is_overridable,

1624 type = cfunc_type,

1625 with_gil = cfunc_type.with_gil,

1626 nogil = cfunc_type.nogil,

1627 visibility = 'private',

1628 api = False,

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

1630

1631 def analyse_declarations(self, env):

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

1633 for arg in self.args:

1634 if hasattr(arg, 'name'):

1635 type = arg.type

1636 name_declarator = None

1637 else:

1638 base_type = arg.base_type.analyse(env)

1639 name_declarator, type = \

1640 arg.declarator.analyse(base_type, env)

1641 arg.name = name_declarator.name

1642 if arg.name in directive_locals:

1643 type_node = directive_locals[arg.name]

1644 other_type = type_node.analyse_as_type(env)

1645 if other_type is None:

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

1647 elif (type is not PyrexTypes.py_object_type

1648 and not type.same_as(other_type)):

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

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

1651 else:

1652 type = other_type

1653 if name_declarator and name_declarator.cname:

1654 error(self.pos,

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

1656 arg.type = type.as_argument_type()

1657 arg.hdr_type = None

1658 arg.needs_conversion = 0

1659 arg.needs_type_test = 0

1660 arg.is_generic = 1

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

1662 error(self.pos,

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

1664 self.declare_pyfunction(env)

1665 self.analyse_signature(env)

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

1667

1668 def analyse_signature(self, env):

1669 any_type_tests_needed = 0

1670 if self.entry.is_special:

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

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

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

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

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

1676 self.entry.signature = TypeSlots.pyfunction_noargs

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

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

1679 self.entry.signature = TypeSlots.pyfunction_onearg

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

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

1682 self.entry.signature = TypeSlots.unaryfunc

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

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

1685 self.entry.signature = TypeSlots.ibinaryfunc

1686 sig = self.entry.signature

1687 nfixed = sig.num_fixed_args()

1688 for i in range(nfixed):

1689 if i < len(self.args):

1690 arg = self.args[i]

1691 arg.is_generic = 0

1692 if sig.is_self_arg(i):

1693 arg.is_self_arg = 1

1694 arg.hdr_type = arg.type = env.parent_type

1695 arg.needs_conversion = 0

1696 else:

1697 arg.hdr_type = sig.fixed_arg_type(i)

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

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

1700 arg.needs_type_test = 1

1701 any_type_tests_needed = 1

1702 else:

1703 arg.needs_conversion = 1

1704 if arg.needs_conversion:

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

1706 else:

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

1708 else:

1709 self.bad_signature()

1710 return

1711 if nfixed < len(self.args):

1712 if not sig.has_generic_args:

1713 self.bad_signature()

1714 for arg in self.args:

1715 if arg.is_generic and \

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

1717 arg.needs_type_test = 1

1718 any_type_tests_needed = 1

1719 if any_type_tests_needed:

1720 env.use_utility_code(arg_type_test_utility_code)

1721

1722 def bad_signature(self):

1723 sig = self.entry.signature

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

1725 if sig.has_generic_args:

1726 expected_str = expected_str + " or more"

1727 name = self.name

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

1729 desc = "Special method"

1730 else:

1731 desc = "Method"

1732 error(self.pos,

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

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

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

1736

1737 def signature_has_nongeneric_args(self):

1738 argcount = len(self.args)

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

1740 return 0

1741 return 1

1742

1743 def signature_has_generic_args(self):

1744 return self.entry.signature.has_generic_args

1745

1746 def declare_pyfunction(self, env):

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

1748 name = self.name

1749 entry = env.lookup_here(self.name)

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

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

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

1753 self.entry = entry

1754 prefix = env.scope_prefix

1755 entry.func_cname = \

1756 Naming.pyfunc_prefix + prefix + name

1757 entry.pymethdef_cname = \

1758 Naming.pymethdef_prefix + prefix + name

1759 if Options.docstrings:

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

1761 entry.doc_cname = \

1762 Naming.funcdoc_prefix + prefix + name

1763 else:

1764 entry.doc = None

1765

1766 def declare_arguments(self, env):

1767 for arg in self.args:

1768 if not arg.name:

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

1770 if arg.needs_conversion:

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

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

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

1774 if arg.type.is_pyobject:

1775 arg.entry.init = "0"

1776 arg.entry.init_to_none = 0

1777 else:

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

1779 arg.entry.used = 1

1780 arg.entry.is_self_arg = arg.is_self_arg

1781 if arg.hdr_type:

1782 if arg.is_self_arg or \

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

1784 arg.entry.is_declared_generic = 1

1785 self.declare_python_arg(env, self.star_arg)

1786 self.declare_python_arg(env, self.starstar_arg)

1787

1788 def declare_python_arg(self, env, arg):

1789 if arg:

1790 entry = env.declare_var(arg.name,

1791 PyrexTypes.py_object_type, arg.pos)

1792 entry.used = 1

1793 entry.init = "0"

1794 entry.init_to_none = 0

1795 entry.xdecref_cleanup = 1

1796 arg.entry = entry

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

1798

1799 def analyse_expressions(self, env):

1800 self.local_scope.directives = env.directives

1801 self.analyse_default_values(env)

1802 if env.is_py_class_scope:

1803 self.synthesize_assignment_node(env)

1804

1805 def synthesize_assignment_node(self, env):

1806 import ExprNodes

1807 self.assmt = SingleAssignmentNode(self.pos,

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

1809 rhs = ExprNodes.UnboundMethodNode(self.pos,

1810 function = ExprNodes.PyCFunctionNode(self.pos,

1811 pymethdef_cname = self.entry.pymethdef_cname)))

1812 self.assmt.analyse_declarations(env)

1813 self.assmt.analyse_expressions(env)

1814

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

1816 arg_code_list = []

1817 sig = self.entry.signature

1818 if sig.has_dummy_arg:

1819 arg_code_list.append(

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

1821 for arg in self.args:

1822 if not arg.is_generic:

1823 if arg.is_self_arg:

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

1825 else:

1826 arg_code_list.append(

1827 arg.hdr_type.declaration_code(arg.hdr_cname))

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

1829 arg_code_list.append("PyObject *unused")

1830 if sig.has_generic_args:

1831 arg_code_list.append(

1832 "PyObject *%s, PyObject *%s"

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

1834 arg_code = ", ".join(arg_code_list)

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

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

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

1838 if proto_only:

1839 return

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

1841 docstr = self.entry.doc

1842 if not isinstance(docstr, str):

1843 docstr = docstr.utf8encode()

1844 code.putln(

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

1846 self.entry.doc_cname,

1847 split_docstring(escape_byte_string(docstr))))

1848 if with_pymethdef:

1849 code.put(

1850 "static PyMethodDef %s = " %

1851 self.entry.pymethdef_cname)

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

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

1854

1855 def generate_argument_declarations(self, env, code):

1856 for arg in self.args:

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

1858 if arg.needs_conversion:

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

1860 else:

1861 code.put_var_declaration(arg.entry)

1862

1863 def generate_keyword_list(self, code):

1864 if self.signature_has_generic_args() and \

1865 self.signature_has_nongeneric_args():

1866 code.put(

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

1868 Naming.pykwdlist_cname)

1869 for arg in self.args:

1870 if arg.is_generic:

1871 pystring_cname = code.intern_identifier(arg.name)

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

1873 code.putln("0};")

1874

1875 def generate_argument_parsing_code(self, env, code):

1876 # Generate PyArg_ParseTuple call for generic

1877 # arguments, if any.

1878 if self.entry.signature.has_dummy_arg:

1879 # get rid of unused argument warning

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

1881

1882 old_error_label = code.new_error_label()

1883 our_error_label = code.error_label

1884 end_label = code.new_label("argument_unpacking_done")

1885

1886 has_kwonly_args = self.num_kwonly_args > 0

1887 has_star_or_kw_args = self.star_arg is not None \

1888 or self.starstar_arg is not None or has_kwonly_args

1889

1890 for arg in self.args:

1891 if not arg.type.is_pyobject and arg.type.from_py_function is None:

1892 arg.type.create_from_py_utility_code(env)

1893

1894 if not self.signature_has_generic_args():

1895 if has_star_or_kw_args:

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

1897 self.generate_argument_conversion_code(code)

1898

1899 elif not self.signature_has_nongeneric_args():

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

1901 self.generate_stararg_copy_code(code)

1902

1903 else:

1904 positional_args = []

1905 kw_only_args = []

1906 default_seen = 0

1907 for arg in self.args:

1908 arg_entry = arg.entry

1909 if arg.is_generic:

1910 if arg.default:

1911 default_seen = 1

1912 if not arg.is_self_arg:

1913 if arg.kw_only:

1914 kw_only_args.append(arg)

1915 else:

1916 positional_args.append(arg)

1917 elif arg.kw_only:

1918 kw_only_args.append(arg)

1919 default_seen = 1

1920 elif default_seen:

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

1922 elif not arg.is_self_arg:

1923 positional_args.append(arg)

1924

1925 self.generate_tuple_and_keyword_parsing_code(

1926 positional_args, kw_only_args, end_label, code)

1927

1928 code.error_label = old_error_label

1929 if code.label_used(our_error_label):

1930 if not code.label_used(end_label):

1931 code.put_goto(end_label)

1932 code.put_label(our_error_label)

1933 if has_star_or_kw_args:

1934 self.generate_arg_decref(self.star_arg, code)

1935 if self.starstar_arg:

1936 if self.starstar_arg.entry.xdecref_cleanup:

1937 code.put_var_xdecref(self.starstar_arg.entry)

1938 else:

1939 code.put_var_decref(self.starstar_arg.entry)

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

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

1942 if code.label_used(end_label):

1943 code.put_label(end_label)

1944

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

1946 if arg.type.is_pyobject:

1947 if arg.is_generic:

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

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

1950 else:

1951 func = arg.type.from_py_function

1952 if func:

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

1954 arg.entry.cname,

1955 func,

1956 item,

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

1958 else:

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

1960

1961 def generate_arg_xdecref(self, arg, code):

1962 if arg:

1963 code.put_var_xdecref(arg.entry)

1964

1965 def generate_arg_decref(self, arg, code):

1966 if arg:

1967 code.put_var_decref(arg.entry)

1968

1969 def generate_stararg_copy_code(self, code):

1970 if not self.star_arg:

1971 code.globalstate.use_utility_code(raise_argtuple_invalid_utility_code)

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

1973 Naming.args_cname)

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

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

1976 code.putln("}")

1977

1978 code.globalstate.use_utility_code(keyword_string_check_utility_code)

1979

1980 if self.starstar_arg:

1981 if self.star_arg:

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

1983 else:

1984 kwarg_check = "%s" % Naming.kwds_cname

1985 else:

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

1987 Naming.kwds_cname, Naming.kwds_cname)

1988 code.putln(

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

1990 kwarg_check, Naming.kwds_cname, self.name,

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

1992

1993 if self.starstar_arg:

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

1995 self.starstar_arg.entry.cname,

1996 Naming.kwds_cname,

1997 Naming.kwds_cname))

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

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

2000 self.starstar_arg.entry.xdecref_cleanup = 0

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

2002

2003

2004 if self.star_arg:

2005 code.put_incref(Naming.args_cname, py_object_type)

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

2007 self.star_arg.entry.cname,

2008 Naming.args_cname))

2009 self.star_arg.entry.xdecref_cleanup = 0

2010

2011 def generate_tuple_and_keyword_parsing_code(self, positional_args,

2012 kw_only_args, success_label, code):

2013 argtuple_error_label = code.new_label("argtuple_error")

2014

2015 min_positional_args = self.num_required_args - self.num_required_kw_args

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

2017 min_positional_args -= 1

2018 max_positional_args = len(positional_args)

2019 has_fixed_positional_count = not self.star_arg and \

2020 min_positional_args == max_positional_args

2021

2022 code.globalstate.use_utility_code(raise_double_keywords_utility_code)

2023 code.globalstate.use_utility_code(raise_argtuple_invalid_utility_code)

2024 if self.num_required_kw_args:

2025 code.globalstate.use_utility_code(raise_keyword_required_utility_code)

2026

2027 if self.starstar_arg or self.star_arg:

2028 self.generate_stararg_init_code(max_positional_args, code)

2029

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

2031 if self.num_required_kw_args:

2032 likely_hint = "likely"

2033 else:

2034 likely_hint = "unlikely"

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

2036 self.generate_keyword_unpacking_code(

2037 min_positional_args, max_positional_args,

2038 has_fixed_positional_count,

2039 positional_args, kw_only_args, argtuple_error_label, code)

2040

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

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

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

2044 # check the length here

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

2046 compare = '!='

2047 else:

2048 compare = '<'

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

2050 Naming.args_cname, compare, min_positional_args))

2051 code.put_goto(argtuple_error_label)

2052

2053 if self.num_required_kw_args:

2054 # pure error case: keywords required but not passed

2055 if max_positional_args > min_positional_args and not self.star_arg:

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

2057 Naming.args_cname, max_positional_args))

2058 code.put_goto(argtuple_error_label)

2059 code.putln('} else {')

2060 for i, arg in enumerate(kw_only_args):

2061 if not arg.default:

2062 pystring_cname = code.intern_identifier(arg.name)

2063 # required keyword-only argument missing

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

2065 self.name.utf8encode(),

2066 pystring_cname))

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

2068 break

2069

2070 elif min_positional_args == max_positional_args:

2071 # parse the exact number of positional arguments from the

2072 # args tuple

2073 code.putln('} else {')

2074 for i, arg in enumerate(positional_args):

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

2076 self.generate_arg_assignment(arg, item, code)

2077 self.generate_arg_default_assignments(code)

2078

2079 else:

2080 # parse the positional arguments from the variable length

2081 # args tuple

2082 code.putln('} else {')

2083 self.generate_arg_default_assignments(code)

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

2085 if self.star_arg:

2086 code.putln('default:')

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

2088 for i, arg in reversed_args:

2089 if i >= min_positional_args-1:

2090 if min_positional_args > 1:

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

2092 else:

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

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

2095 self.generate_arg_assignment(arg, item, code)

2096 if min_positional_args == 0:

2097 code.put('case 0: ')

2098 code.putln('break;')

2099 if self.star_arg:

2100 if min_positional_args:

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

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

2103 code.put_goto(argtuple_error_label)

2104 else:

2105 code.put('default: ')

2106 code.put_goto(argtuple_error_label)

2107 code.putln('}')

2108

2109 code.putln('}')

2110

2111 if code.label_used(argtuple_error_label):

2112 code.put_goto(success_label)

2113 code.put_label(argtuple_error_label)

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

2115 self.name.utf8encode(), has_fixed_positional_count,

2116 min_positional_args, max_positional_args,

2117 Naming.args_cname))

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

2119

2120 def generate_arg_default_assignments(self, code):

2121 for arg in self.args:

2122 if arg.is_generic and arg.default:

2123 code.putln(

2124 "%s = %s;" % (

2125 arg.entry.cname,

2126 arg.calculate_default_value_code(code)))

2127

2128 def generate_stararg_init_code(self, max_positional_args, code):

2129 if self.starstar_arg:

2130 self.starstar_arg.entry.xdecref_cleanup = 0

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

2132 self.starstar_arg.entry.cname,

2133 self.starstar_arg.entry.cname,

2134 self.error_value()))

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

2136 if self.star_arg:

2137 self.star_arg.entry.xdecref_cleanup = 0

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

2139 Naming.args_cname,

2140 max_positional_args))

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

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

2143 max_positional_args, Naming.args_cname))

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

2145 if self.starstar_arg:

2146 code.putln("")

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

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

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

2150 code.putln('}')

2151 else:

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

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

2154 code.putln('} else {')

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

2156 code.put_incref(Naming.empty_tuple, py_object_type)

2157 code.putln('}')

2158

2159 def generate_keyword_unpacking_code(self, min_positional_args, max_positional_args,

2160 has_fixed_positional_count, positional_args,

2161 kw_only_args, argtuple_error_label, code):

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

2163 max_args = len(all_args)

2164

2165 default_args = []

2166 for i, arg in enumerate(all_args):

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

2168 default_value = arg.calculate_default_value_code(code)

2169 if arg.type is not PyrexTypes.py_object_type:

2170 default_value = "(PyObject*)"+default_value

2171 default_args.append((i, default_value))

2172

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

2174 Naming.kwds_cname)

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

2176 # default value, but C89 needs this

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

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

2179 for i, default_value in default_args:

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

2181

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

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

2184 if self.star_arg:

2185 code.putln('default:')

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

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

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

2189 i, Naming.args_cname, i))

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

2191 if not self.star_arg:

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

2193 code.put_goto(argtuple_error_label)

2194 code.putln('}')

2195

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

2197 # from the kw dict

2198 if self.num_required_args or max_positional_args > 0:

2199 last_required_arg = -1

2200 for i, arg in enumerate(all_args):

2201 if not arg.default:

2202 last_required_arg = i

2203 if last_required_arg < max_positional_args:

2204 last_required_arg = max_positional_args-1

2205 num_required_args = self.num_required_args

2206 if max_positional_args > 0:

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

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

2209 if max_positional_args > 0 and i <= max_positional_args:

2210 if self.star_arg and i == max_positional_args:

2211 code.putln('default:')

2212 else:

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

2214 pystring_cname = code.intern_identifier(arg.name)

2215 if arg.default:

2216 if arg.kw_only:

2217 # handled separately below

2218 continue

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

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

2221 Naming.kwds_cname, pystring_cname))

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

2223 code.putln('}')

2224 else:

2225 num_required_args -= 1

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

2227 i, Naming.kwds_cname, pystring_cname))

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

2229 if i < min_positional_args:

2230 if i == 0:

2231 # special case: we know arg 0 is missing

2232 code.put('else ')

2233 code.put_goto(argtuple_error_label)

2234 else:

2235 # print the correct number of values (args or

2236 # kwargs) that were passed into positional

2237 # arguments up to this point

2238 code.putln('else {')

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

2240 self.name.utf8encode(), has_fixed_positional_count,

2241 min_positional_args, max_positional_args, i))

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

2243 code.putln('}')

2244 elif arg.kw_only:

2245 code.putln('else {')

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

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

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

2249 code.putln('}')

2250 if max_positional_args > 0:

2251 code.putln('}')

2252

2253 if kw_only_args and not self.starstar_arg:

2254 # unpack optional keyword-only arguments

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

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

2257 optional_args = []

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

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

2260 continue

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

2262 if optional_args:

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

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

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

2266 for i, arg in optional_args:

2267 pystring_cname = code.intern_identifier(arg.name)

2268 code.putln(

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

2270 Naming.kwds_cname, pystring_cname))

2271 code.putln(

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

2273 code.putln('break;')

2274 code.putln('}')

2275

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

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

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

2279 #

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

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

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

2283 # common cases above.

2284 if max_positional_args == 0:

2285 pos_arg_count = "0"

2286 elif self.star_arg:

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

2288 Naming.args_cname, max_positional_args,

2289 Naming.args_cname, max_positional_args))

2290 pos_arg_count = "used_pos_args"

2291 else:

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

2293 code.globalstate.use_utility_code(parse_keywords_utility_code)

2294 code.put(

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

2296 Naming.kwds_cname,

2297 Naming.pykwdlist_cname,

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

2299 pos_arg_count,

2300 self.name.utf8encode()))

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

2302 code.putln('}')

2303

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

2305 for i, arg in enumerate(all_args):

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

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

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

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

2310 code.putln('} else {')

2311 code.putln(

2312 "%s = %s;" % (

2313 arg.entry.cname,

2314 arg.calculate_default_value_code(code)))

2315 code.putln('}')

2316

2317 def generate_argument_conversion_code(self, code):

2318 # Generate code to convert arguments from

2319 # signature type to declared type, if needed.

2320 for arg in self.args:

2321 if arg.needs_conversion:

2322 self.generate_arg_conversion(arg, code)

2323

2324 def generate_arg_conversion(self, arg, code):

2325 # Generate conversion code for one argument.

2326 old_type = arg.hdr_type

2327 new_type = arg.type

2328 if old_type.is_pyobject:

2329 if arg.default:

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

2331 else:

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

2333 self.generate_arg_conversion_from_pyobject(arg, code)

2334 code.putln("}")

2335 elif new_type.is_pyobject:

2336 self.generate_arg_conversion_to_pyobject(arg, code)

2337 else:

2338 if new_type.assignable_from(old_type):

2339 code.putln(

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

2341 else:

2342 error(arg.pos,

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

2344 (old_type, new_type))

2345

2346 def generate_arg_conversion_from_pyobject(self, arg, code):

2347 new_type = arg.type

2348 func = new_type.from_py_function

2349 # copied from CoerceFromPyTypeNode

2350 if func:

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

2352 arg.entry.cname,

2353 func,

2354 arg.hdr_cname,

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

2356 else:

2357 error(arg.pos,

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

2359 % new_type)

2360

2361 def generate_arg_conversion_to_pyobject(self, arg, code):

2362 old_type = arg.hdr_type

2363 func = old_type.to_py_function

2364 if func:

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

2366 arg.entry.cname,

2367 func,

2368 arg.hdr_cname,

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

2370 code.put_var_gotref(arg.entry)

2371 else:

2372 error(arg.pos,

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

2374 % old_type)

2375

2376 def generate_argument_type_tests(self, code):

2377 # Generate type tests for args whose signature

2378 # type is PyObject * and whose declared type is

2379 # a subtype thereof.

2380 for arg in self.args:

2381 if arg.needs_type_test:

2382 self.generate_arg_type_test(arg, code)

2383

2384 def generate_arg_type_test(self, arg, code):

2385 # Generate type test for one argument.

2386 if arg.type.typeobj_is_available():

2387 typeptr_cname = arg.type.typeptr_cname

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

2389 code.putln(

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

2391 arg_code,

2392 typeptr_cname,

2393 not arg.not_none,

2394 arg.name,

2395 arg.type.is_builtin_type,

2396 code.error_goto(arg.pos)))

2397 else:

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

2399 "without type object name specification")

2400

2401 def error_value(self):

2402 return self.entry.signature.error_value

2403

2404 def caller_will_check_exceptions(self):

2405 return 1

2406

2407 class OverrideCheckNode(StatNode):

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

2409 # is overriden.

2410 #

2411 # py_func

2412 #

2413 # args

2414 # func_temp

2415 # body

2416

2417 child_attrs = ['body']

2418

2419 body = None

2420

2421 def analyse_expressions(self, env):

2422 self.args = env.arg_entries

2423 if self.py_func.is_module_scope:

2424 first_arg = 0

2425 else:

2426 first_arg = 1

2427 import ExprNodes

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

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

2430 call_node = ExprNodes.SimpleCallNode(self.pos,

2431 function=self.func_node,

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

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

2434 self.body.analyse_expressions(env)

2435

2436 def generate_execution_code(self, code):

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

2438 # Check to see if we are an extension type

2439 if self.py_func.is_module_scope:

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

2441 else:

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

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

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

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

2446 if self.py_func.is_module_scope:

2447 code.putln("else {")

2448 else:

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

2450 self.func_node.allocate(code)

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

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

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

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

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

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

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

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

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

2460 self.body.generate_execution_code(code)

2461 code.putln('}')

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

2463 code.putln("}")

2464 self.func_node.release(code)

2465

2466 class ClassDefNode(StatNode, BlockNode):

2467 pass

2468

2469 class PyClassDefNode(ClassDefNode):

2470 # A Python class definition.

2471 #

2472 # name EncodedString Name of the class

2473 # doc string or None

2474 # body StatNode Attribute definition code

2475 # entry Symtab.Entry

2476 # scope PyClassScope

2477 # decorators [DecoratorNode] list of decorators or None

2478 #

2479 # The following subnodes are constructed internally:

2480 #

2481 # dict DictNode Class dictionary

2482 # classobj ClassNode Class object

2483 # target NameNode Variable to assign class object to

2484

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

2486 decorators = None

2487

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

2489 StatNode.__init__(self, pos)

2490 self.name = name

2491 self.doc = doc

2492 self.body = body

2493 self.decorators = decorators

2494 import ExprNodes

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

2496 if self.doc and Options.docstrings:

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

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

2499 else:

2500 doc_node = None

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

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

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

2504

2505 def as_cclass(self):

2506 """

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

2508 """

2509 bases = self.classobj.bases.args

2510 if len(bases) == 0:

2511 base_class_name = None

2512 base_class_module = None

2513 elif len(bases) == 1:

2514 base = bases[0]

2515 path = []

2516 from ExprNodes import AttributeNode, NameNode

2517 while isinstance(base, AttributeNode):

2518 path.insert(0, base.attribute)

2519 base = base.obj

2520 if isinstance(base, NameNode):

2521 path.insert(0, base.name)

2522 base_class_name = path[-1]

2523 if len(path) > 1:

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

2525 else:

2526 base_class_module = None

2527 else:

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

2529 else:

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

2531 return None

2532

2533 return CClassDefNode(self.pos,

2534 visibility = 'private',

2535 module_name = None,

2536 class_name = self.name,

2537 base_class_module = base_class_module,

2538 base_class_name = base_class_name,

2539 decorators = self.decorators,

2540 body = self.body,

2541 in_pxd = False,

2542 doc = self.doc)

2543

2544 def create_scope(self, env):

2545 genv = env

2546 while env.is_py_class_scope or env.is_c_class_scope:

2547 env = env.outer_scope

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

2549 return cenv

2550

2551 def analyse_declarations(self, env):

2552 self.target.analyse_target_declaration(env)

2553 cenv = self.create_scope(env)

2554 cenv.directives = env.directives

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

2556 self.body.analyse_declarations(cenv)

2557

2558 def analyse_expressions(self, env):

2559 self.dict.analyse_expressions(env)

2560 self.classobj.analyse_expressions(env)

2561 genv = env.global_scope()

2562 cenv = self.scope

2563 self.body.analyse_expressions(cenv)

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

2565

2566 def generate_function_definitions(self, env, code):

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

2568

2569 def generate_execution_code(self, code):

2570 code.pyclass_stack.append(self)

2571 cenv = self.scope

2572 self.dict.generate_evaluation_code(code)

2573 self.classobj.generate_evaluation_code(code)

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

2575 self.body.generate_execution_code(code)

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

2577 self.dict.generate_disposal_code(code)

2578 self.dict.free_temps(code)

2579 code.pyclass_stack.pop()

2580

2581

2582 class CClassDefNode(ClassDefNode):

2583 # An extension type definition.

2584 #

2585 # visibility 'private' or 'public' or 'extern'

2586 # typedef_flag boolean

2587 # api boolean

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

2589 # class_name string Unqualified name of class

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

2591 # base_class_module string or None Module containing the base class

2592 # base_class_name string or None Name of the base class

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

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

2595 # in_pxd boolean Is in a .pxd file

2596 # decorators [DecoratorNode] list of decorators or None

2597 # doc string or None

2598 # body StatNode or None

2599 # entry Symtab.Entry

2600 # base_type PyExtensionType or None

2601 # buffer_defaults_node DictNode or None Declares defaults for a buffer

2602 # buffer_defaults_pos

2603

2604 child_attrs = ["body"]

2605 buffer_defaults_node = None

2606 buffer_defaults_pos = None

2607 typedef_flag = False

2608 api = False

2609 objstruct_name = None

2610 typeobj_name = None

2611 decorators = None

2612

2613 def analyse_declarations(self, env):

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

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

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

2617

2618 import Buffer

2619 if self.buffer_defaults_node:

2620 buffer_defaults = Buffer.analyse_buffer_options(self.buffer_defaults_pos,

2621 env, [], self.buffer_defaults_node,

2622 need_complete=False)

2623 else:

2624 buffer_defaults = None

2625

2626 if env.in_cinclude and not self.objstruct_name:

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

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

2629 self.base_type = None

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

2631 # import the modules for extern classes.

2632 if self.module_name:

2633 self.module = None

2634 for module in env.cimported_modules:

2635 if module.name == self.module_name:

2636 self.module = module

2637 if self.module is None:

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

2639 self.module.has_extern_class = 1

2640 env.add_imported_module(self.module)

2641

2642 if self.base_class_name:

2643 if self.base_class_module:

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

2645 else:

2646 base_class_scope = env

2647 if self.base_class_name == 'object':

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

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

2650 self.base_class_name = None

2651 self.base_class_module = None

2652 base_class_scope = None

2653 if base_class_scope:

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

2655 if base_class_entry:

2656 if not base_class_entry.is_type:

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

2658 elif not base_class_entry.type.is_extension_type:

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

2660 elif not base_class_entry.type.is_complete():

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

2662 else:

2663 self.base_type = base_class_entry.type

2664 has_body = self.body is not None

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

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

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

2668 if not home_scope:

2669 return

2670 else:

2671 home_scope = env

2672

2673 if self.visibility == 'extern':

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

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

2676

2677 self.entry = home_scope.declare_c_class(

2678 name = self.class_name,

2679 pos = self.pos,

2680 defining = has_body and self.in_pxd,

2681 implementing = has_body and not self.in_pxd,

2682 module_name = self.module_name,

2683 base_type = self.base_type,

2684 objstruct_cname = self.objstruct_name,

2685 typeobj_cname = self.typeobj_name,

2686 visibility = self.visibility,

2687 typedef_flag = self.typedef_flag,

2688 api = self.api,

2689 buffer_defaults = buffer_defaults)

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

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

2692 scope = self.entry.type.scope

2693 if scope is not None:

2694 scope.directives = env.directives

2695

2696 if self.doc and Options.docstrings:

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

2698

2699 if has_body:

2700 self.body.analyse_declarations(scope)

2701 if self.in_pxd:

2702 scope.defined = 1

2703 else:

2704 scope.implemented = 1

2705 env.allocate_vtable_names(self.entry)

2706

2707 def analyse_expressions(self, env):

2708 if self.body:

2709 scope = self.entry.type.scope

2710 self.body.analyse_expressions(scope)

2711

2712 def generate_function_definitions(self, env, code):

2713 if self.body:

2714 self.body.generate_function_definitions(

2715 self.entry.type.scope, code)

2716

2717 def generate_execution_code(self, code):

2718 # This is needed to generate evaluation code for

2719 # default values of method arguments.

2720 if self.body:

2721 self.body.generate_execution_code(code)

2722

2723 def annotate(self, code):

2724 if self.body:

2725 self.body.annotate(code)

2726

2727

2728 class PropertyNode(StatNode):

2729 # Definition of a property in an extension type.

2730 #

2731 # name string

2732 # doc EncodedString or None Doc string

2733 # body StatListNode

2734

2735 child_attrs = ["body"]

2736

2737 def analyse_declarations(self, env):

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

2739 if entry:

2740 entry.scope.directives = env.directives

2741 self.body.analyse_declarations(entry.scope)

2742

2743 def analyse_expressions(self, env):

2744 self.body.analyse_expressions(env)

2745

2746 def generate_function_definitions(self, env, code):

2747 self.body.generate_function_definitions(env, code)

2748

2749 def generate_execution_code(self, code):

2750 pass

2751

2752 def annotate(self, code):

2753 self.body.annotate(code)

2754

2755

2756 class GlobalNode(StatNode):

2757 # Global variable declaration.

2758 #

2759 # names [string]

2760

2761 child_attrs = []

2762

2763 def analyse_declarations(self, env):

2764 for name in self.names:

2765 env.declare_global(name, self.pos)

2766

2767 def analyse_expressions(self, env):

2768 pass

2769

2770 def generate_execution_code(self, code):

2771 pass

2772

2773

2774 class ExprStatNode(StatNode):

2775 # Expression used as a statement.

2776 #

2777 # expr ExprNode

2778

2779 child_attrs = ["expr"]

2780

2781 def analyse_declarations(self, env):

2782 import ExprNodes

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

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

2785 if func == u'declare':

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

2787 if len(args):

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

2789 for var, type_node in kwds.key_value_pairs:

2790 type = type_node.analyse_as_type(env)

2791 if type is None:

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

2793 else:

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

2795 self.__class__ = PassStatNode

2796

2797 def analyse_expressions(self, env):

2798 self.expr.analyse_expressions(env)

2799

2800 def generate_execution_code(self, code):

2801 self.expr.generate_evaluation_code(code)

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

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

2804 self.expr.generate_disposal_code(code)

2805 self.expr.free_temps(code)

2806

2807 def annotate(self, code):

2808 self.expr.annotate(code)

2809

2810

2811 class AssignmentNode(StatNode):

2812 # Abstract base class for assignment nodes.

2813 #

2814 # The analyse_expressions and generate_execution_code

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

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

2817 # parallel assignment to be evaluated before assigning

2818 # to any of the left hand sides.

2819

2820 def analyse_expressions(self, env):

2821 self.analyse_types(env)

2822

2823 # def analyse_expressions(self, env):

2824 # self.analyse_expressions_1(env)

2825 # self.analyse_expressions_2(env)

2826

2827 def generate_execution_code(self, code):

2828 self.generate_rhs_evaluation_code(code)

2829 self.generate_assignment_code(code)

2830

2831

2832 class SingleAssignmentNode(AssignmentNode):

2833 # The simplest case:

2834 #

2835 # a = b

2836 #

2837 # lhs ExprNode Left hand side

2838 # rhs ExprNode Right hand side

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

2840

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

2842 first = False

2843 declaration_only = False

2844

2845 def analyse_declarations(self, env):

2846 import ExprNodes

2847

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

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

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

2851 if func_name:

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

2853

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

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

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

2857 return

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

2859 if type is None:

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

2861 return

2862 lhs = self.lhs

2863 if func_name == 'declare':

2864 if isinstance(lhs, ExprNodes.NameNode):

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

2866 elif isinstance(lhs, ExprNodes.TupleNode):

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

2868 else:

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

2870 return

2871 for var, pos in vars:

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

2873 if len(args) == 2:

2874 # we have a value

2875 self.rhs = args[1]

2876 else:

2877 self.declaration_only = True

2878 else:

2879 self.declaration_only = True

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

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

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

2883

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

2885 self.declaration_only = True

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

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

2888 return

2889 members = []

2890 for member, type_node in kwds.key_value_pairs:

2891 type = type_node.analyse_as_type(env)

2892 if type is None:

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

2894 else:

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

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

2897 return

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

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

2900 name = self.lhs.name

2901 scope = StructOrUnionScope(name)

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

2903 for member, type, pos in members:

2904 scope.declare_var(member, type, pos)

2905

2906 if self.declaration_only:

2907 return

2908 else:

2909 self.lhs.analyse_target_declaration(env)

2910

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

2912 self.rhs.analyse_types(env)

2913 self.lhs.analyse_target_types(env)

2914 self.lhs.gil_assignment_check(env)

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

2916 if use_temp:

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

2918

2919 def generate_rhs_evaluation_code(self, code):

2920 self.rhs.generate_evaluation_code(code)

2921

2922 def generate_assignment_code(self, code):

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

2924

2925 def annotate(self, code):

2926 self.lhs.annotate(code)

2927 self.rhs.annotate(code)

2928

2929

2930 class CascadedAssignmentNode(AssignmentNode):

2931 # An assignment with multiple left hand sides:

2932 #

2933 # a = b = c

2934 #

2935 # lhs_list [ExprNode] Left hand sides

2936 # rhs ExprNode Right hand sides

2937 #

2938 # Used internally:

2939 #

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

2941

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

2943 coerced_rhs_list = None

2944

2945 def analyse_declarations(self, env):

2946 for lhs in self.lhs_list:

2947 lhs.analyse_target_declaration(env)

2948

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

2950 self.rhs.analyse_types(env)

2951 if use_temp:

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

2953 else:

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

2955 from ExprNodes import CloneNode

2956 self.coerced_rhs_list = []

2957 for lhs in self.lhs_list:

2958 lhs.analyse_target_types(env)

2959 lhs.gil_assignment_check(env)

2960 rhs = CloneNode(self.rhs)

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

2962 self.coerced_rhs_list.append(rhs)

2963

2964 def generate_rhs_evaluation_code(self, code):

2965 self.rhs.generate_evaluation_code(code)

2966

2967 def generate_assignment_code(self, code):

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

2969 lhs = self.lhs_list[i]

2970 rhs = self.coerced_rhs_list[i]

2971 rhs.generate_evaluation_code(code)

2972 lhs.generate_assignment_code(rhs, code)

2973 # Assignment has disposed of the cloned RHS

2974 self.rhs.generate_disposal_code(code)

2975 self.rhs.free_temps(code)

2976

2977 def annotate(self, code):

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

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

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

2981 self.rhs.annotate(code)

2982

2983

2984 class ParallelAssignmentNode(AssignmentNode):

2985 # A combined packing/unpacking assignment:

2986 #

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

2988 #

2989 # This has been rearranged by the parser into

2990 #

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

2992 #

2993 # but we must evaluate all the right hand sides

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

2995 #

2996 # stats [AssignmentNode] The constituent assignments

2997

2998 child_attrs = ["stats"]

2999

3000 def analyse_declarations(self, env):

3001 for stat in self.stats:

3002 stat.analyse_declarations(env)

3003

3004 def analyse_expressions(self, env):

3005 for stat in self.stats:

3006 stat.analyse_types(env, use_temp = 1)

3007

3008 # def analyse_expressions(self, env):

3009 # for stat in self.stats:

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

3011 # for stat in self.stats:

3012 # stat.analyse_expressions_2(env)

3013

3014 def generate_execution_code(self, code):

3015 for stat in self.stats:

3016 stat.generate_rhs_evaluation_code(code)

3017 for stat in self.stats:

3018 stat.generate_assignment_code(code)

3019

3020 def annotate(self, code):

3021 for stat in self.stats:

3022 stat.annotate(code)

3023

3024

3025 class InPlaceAssignmentNode(AssignmentNode):

3026 # An in place arithmatic operand:

3027 #

3028 # a += b

3029 # a -= b

3030 # ...

3031 #

3032 # lhs ExprNode Left hand side

3033 # rhs ExprNode Right hand side

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

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

3036 #

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

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

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

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

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

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

3043

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

3045 dup = None

3046

3047 def analyse_declarations(self, env):

3048 self.lhs.analyse_target_declaration(env)

3049

3050 def analyse_types(self, env):

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

3052 self.rhs.analyse_types(env)

3053 self.lhs.analyse_target_types(env)

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

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

3056 import ExprNodes

3057 if self.lhs.type.is_pyobject:

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

3059 elif self.rhs.type.is_pyobject:

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

3061 if self.lhs.type.is_pyobject:

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

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

3064

3065 def generate_execution_code(self, code):

3066 import ExprNodes

3067 self.rhs.generate_evaluation_code(code)

3068 self.dup.generate_subexpr_evaluation_code(code)

3069 if self.dup.is_temp:

3070 self.dup.allocate_temp_result(code)

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

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

3073 extra = ", Py_None"

3074 else:

3075 extra = ""

3076 if self.lhs.type.is_pyobject:

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

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

3079 self.dup.generate_result_code(code)

3080 self.result_value_temp.allocate(code)

3081 code.putln(

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

3083 self.result_value.result(),

3084 self.py_operation_function(),

3085 self.dup.py_result(),

3086 self.rhs.py_result(),

3087 extra,

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

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

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

3091 self.rhs.generate_disposal_code(code)

3092 self.rhs.free_temps(code)

3093 self.dup.generate_disposal_code(code)

3094 self.dup.free_temps(code)

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

3096 self.result_value_temp.release(code)

3097 else:

3098 c_op = self.operator

3099 if c_op == "//":

3100 c_op = "/"

3101 elif c_op == "**":

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

3103 elif self.lhs.type.is_complex and not code.globalstate.directives['c99_complex']:

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

3105

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

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

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

3109 else:

3110 self.dup.generate_result_code(code)

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

3112 self.rhs.generate_disposal_code(code)

3113 self.rhs.free_temps(code)

3114 if self.dup.is_temp:

3115 self.dup.generate_subexpr_disposal_code(code)

3116 self.dup.free_subexpr_temps(code)

3117

3118 def create_dup_node(self, env):

3119 import ExprNodes

3120 self.dup = self.lhs

3121 self.dup.analyse_types(env)

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

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

3124 name = self.dup.name,

3125 is_temp = self.dup.is_temp,

3126 entry = self.dup.entry)

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

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

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

3130 attribute = self.dup.attribute,

3131 is_temp = self.dup.is_temp)

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

3133 if self.lhs.index:

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

3135 else:

3136 index = None

3137 if self.lhs.indices:

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

3139 else:

3140 indices = []

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

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

3143 index = index,

3144 indices = indices,

3145 is_temp = self.dup.is_temp)

3146 else:

3147 assert False

3148 self.lhs = target_lhs

3149 return self.dup

3150

3151 def py_operation_function(self):

3152 return self.py_functions[self.operator]

3153

3154 py_functions = {

3155 "|": "PyNumber_InPlaceOr",

3156 "^": "PyNumber_InPlaceXor",

3157 "&": "PyNumber_InPlaceAnd",

3158 "+": "PyNumber_InPlaceAdd",

3159 "-": "PyNumber_InPlaceSubtract",

3160 "*": "PyNumber_InPlaceMultiply",

3161 "/": "PyNumber_InPlaceDivide",

3162 "%": "PyNumber_InPlaceRemainder",

3163 "<<": "PyNumber_InPlaceLshift",

3164 ">>": "PyNumber_InPlaceRshift",

3165 "**": "PyNumber_InPlacePower",

3166 "//": "PyNumber_InPlaceFloorDivide",

3167 }

3168

3169 def annotate(self, code):

3170 self.lhs.annotate(code)

3171 self.rhs.annotate(code)

3172 self.dup.annotate(code)

3173

3174

3175 class PrintStatNode(StatNode):

3176 # print statement

3177 #

3178 # arg_tuple TupleNode

3179 # append_newline boolean

3180

3181 child_attrs = ["arg_tuple"]

3182

3183 def analyse_expressions(self, env):

3184 self.arg_tuple.analyse_expressions(env)

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

3186 env.use_utility_code(printing_utility_code)

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

3188 env.use_utility_code(printing_one_utility_code)

3189

3190 nogil_check = Node.gil_error

3191 gil_message = "Python print statement"

3192

3193 def generate_execution_code(self, code):

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

3195 arg = self.arg_tuple.args[0]

3196 arg.generate_evaluation_code(code)

3197

3198 code.putln(

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

3200 arg.py_result(),

3201 code.error_goto(self.pos)))

3202 arg.generate_disposal_code(code)

3203 arg.free_temps(code)

3204 else:

3205 self.arg_tuple.generate_evaluation_code(code)

3206 code.putln(

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

3208 self.arg_tuple.py_result(),

3209 self.append_newline,

3210 code.error_goto(self.pos)))

3211 self.arg_tuple.generate_disposal_code(code)

3212 self.arg_tuple.free_temps(code)

3213

3214 def annotate(self, code):

3215 self.arg_tuple.annotate(code)

3216

3217

3218 class ExecStatNode(StatNode):

3219 # exec statement

3220 #

3221 # args [ExprNode]

3222

3223 child_attrs = ["args"]

3224

3225 def analyse_expressions(self, env):

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

3227 arg.analyse_expressions(env)

3228 arg = arg.coerce_to_pyobject(env)

3229 self.args[i] = arg

3230 env.use_utility_code(Builtin.pyexec_utility_code)

3231

3232 nogil_check = Node.gil_error

3233 gil_message = "Python exec statement"

3234

3235 def generate_execution_code(self, code):

3236 args = []

3237 for arg in self.args:

3238 arg.generate_evaluation_code(code)

3239 args.append( arg.py_result() )

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

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

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

3243 (temp_result,) + args))

3244 for arg in self.args:

3245 arg.generate_disposal_code(code)

3246 arg.free_temps(code)

3247 code.putln(

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

3249 code.put_gotref(temp_result)

3250 code.put_decref_clear(temp_result, py_object_type)

3251 code.funcstate.release_temp(temp_result)

3252

3253 def annotate(self, code):

3254 for arg in self.args:

3255 arg.annotate(code)

3256

3257

3258 class DelStatNode(StatNode):

3259 # del statement

3260 #

3261 # args [ExprNode]

3262

3263 child_attrs = ["args"]

3264

3265 def analyse_declarations(self, env):

3266 for arg in self.args:

3267 arg.analyse_target_declaration(env)

3268

3269 def analyse_expressions(self, env):

3270 for arg in self.args:

3271 arg.analyse_target_expression(env, None)

3272 if not arg.type.is_pyobject:

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

3274 #arg.release_target_temp(env)

3275

3276 def nogil_check(self, env):

3277 for arg in self.args:

3278 if arg.type.is_pyobject:

3279 self.gil_error()

3280

3281 gil_message = "Deleting Python object"

3282

3283 def generate_execution_code(self, code):

3284 for arg in self.args:

3285 if arg.type.is_pyobject:

3286 arg.generate_deletion_code(code)

3287 # else error reported earlier

3288

3289 def annotate(self, code):

3290 for arg in self.args:

3291 arg.annotate(code)

3292

3293

3294 class PassStatNode(StatNode):

3295 # pass statement

3296

3297 child_attrs = []

3298

3299 def analyse_expressions(self, env):

3300 pass

3301

3302 def generate_execution_code(self, code):

3303 pass

3304

3305

3306 class BreakStatNode(StatNode):

3307

3308 child_attrs = []

3309

3310 def analyse_expressions(self, env):

3311 pass

3312

3313 def generate_execution_code(self, code):

3314 if not code.break_label:

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

3316 else:

3317 code.put_goto(code.break_label)

3318

3319

3320 class ContinueStatNode(StatNode):

3321

3322 child_attrs = []

3323

3324 def analyse_expressions(self, env):

3325 pass

3326

3327 def generate_execution_code(self, code):

3328 if code.funcstate.in_try_finally:

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

3330 elif not code.continue_label:

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

3332 else:

3333 code.put_goto(code.continue_label)

3334

3335

3336 class ReturnStatNode(StatNode):

3337 # return statement

3338 #

3339 # value ExprNode or None

3340 # return_type PyrexType

3341

3342 child_attrs = ["value"]

3343

3344 def analyse_expressions(self, env):

3345 return_type = env.return_type

3346 self.return_type = return_type

3347 if not return_type:

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

3349 return

3350 if self.value:

3351 self.value.analyse_types(env)

3352 if return_type.is_void or return_type.is_returncode:

3353 error(self.value.pos,

3354 "Return with value in void function")

3355 else:

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

3357 else:

3358 if (not return_type.is_void

3359 and not return_type.is_pyobject

3360 and not return_type.is_returncode):

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

3362

3363 def nogil_check(self, env):

3364 if self.return_type.is_pyobject:

3365 self.gil_error()

3366

3367 gil_message = "Returning Python object"

3368

3369 def generate_execution_code(self, code):

3370 code.mark_pos(self.pos)

3371 if not self.return_type:

3372 # error reported earlier

3373 return

3374 if self.return_type.is_pyobject:

3375 code.put_xdecref(Naming.retval_cname,

3376 self.return_type)

3377 if self.value:

3378 self.value.generate_evaluation_code(code)

3379 self.value.make_owned_reference(code)

3380 code.putln(

3381 "%s = %s;" % (

3382 Naming.retval_cname,

3383 self.value.result_as(self.return_type)))

3384 self.value.generate_post_assignment_code(code)

3385 self.value.free_temps(code)

3386 else:

3387 if self.return_type.is_pyobject:

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

3389 elif self.return_type.is_returncode:

3390 code.putln(

3391 "%s = %s;" % (

3392 Naming.retval_cname,

3393 self.return_type.default_value))

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

3395 code.put_decref_clear(cname, type)

3396 code.put_goto(code.return_label)

3397

3398 def annotate(self, code):

3399 if self.value:

3400 self.value.annotate(code)

3401

3402

3403 class RaiseStatNode(StatNode):

3404 # raise statement

3405 #

3406 # exc_type ExprNode or None

3407 # exc_value ExprNode or None

3408 # exc_tb ExprNode or None

3409

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

3411

3412 def analyse_expressions(self, env):

3413 if self.exc_type:

3414 self.exc_type.analyse_types(env)

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

3416 if self.exc_value:

3417 self.exc_value.analyse_types(env)

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

3419 if self.exc_tb:

3420 self.exc_tb.analyse_types(env)

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

3422 env.use_utility_code(raise_utility_code)

3423 env.use_utility_code(restore_exception_utility_code)

3424

3425 nogil_check = Node.gil_error

3426 gil_message = "Raising exception"

3427

3428 def generate_execution_code(self, code):

3429 if self.exc_type:

3430 self.exc_type.generate_evaluation_code(code)

3431 type_code = self.exc_type.py_result()

3432 else:

3433 type_code = "0"

3434 if self.exc_value:

3435 self.exc_value.generate_evaluation_code(code)

3436 value_code = self.exc_value.py_result()

3437 else:

3438 value_code = "0"

3439 if self.exc_tb:

3440 self.exc_tb.generate_evaluation_code(code)

3441 tb_code = self.exc_tb.py_result()

3442 else:

3443 tb_code = "0"

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

3445 code.putln(

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

3447 type_code,

3448 value_code,

3449 tb_code))

3450 else:

3451 code.putln(

3452 "__Pyx_ReRaise();")

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

3454 if obj:

3455 obj.generate_disposal_code(code)

3456 obj.free_temps(code)

3457 code.putln(

3458 code.error_goto(self.pos))

3459

3460 def annotate(self, code):

3461 if self.exc_type:

3462 self.exc_type.annotate(code)

3463 if self.exc_value:

3464 self.exc_value.annotate(code)

3465 if self.exc_tb:

3466 self.exc_tb.annotate(code)

3467

3468

3469 class ReraiseStatNode(StatNode):

3470

3471 child_attrs = []

3472

3473 def analyse_expressions(self, env):

3474 env.use_utility_code(raise_utility_code)

3475 env.use_utility_code(restore_exception_utility_code)

3476

3477 nogil_check = Node.gil_error

3478 gil_message = "Raising exception"

3479

3480 def generate_execution_code(self, code):

3481 vars = code.funcstate.exc_vars

3482 if vars:

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

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

3485 else:

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

3487

3488

3489 class AssertStatNode(StatNode):

3490 # assert statement

3491 #

3492 # cond ExprNode

3493 # value ExprNode or None

3494

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

3496

3497 def analyse_expressions(self, env):

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

3499 if self.value:

3500 self.value.analyse_types(env)

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

3502

3503 nogil_check = Node.gil_error

3504 gil_message = "Raising exception"

3505

3506 def generate_execution_code(self, code):

3507 code.putln("#ifndef PYREX_WITHOUT_ASSERTIONS")

3508 self.cond.generate_evaluation_code(code)

3509 code.putln(

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

3511 self.cond.result())

3512 if self.value:

3513 self.value.generate_evaluation_code(code)

3514 code.putln(

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

3516 self.value.py_result())

3517 self.value.generate_disposal_code(code)

3518 self.value.free_temps(code)

3519 else:

3520 code.putln(

3521 "PyErr_SetNone(PyExc_AssertionError);")

3522 code.putln(

3523 code.error_goto(self.pos))

3524 code.putln(

3525 "}")

3526 self.cond.generate_disposal_code(code)

3527 self.cond.free_temps(code)

3528 code.putln("#endif")

3529

3530 def annotate(self, code):

3531 self.cond.annotate(code)

3532 if self.value:

3533 self.value.annotate(code)

3534

3535

3536 class IfStatNode(StatNode):

3537 # if statement

3538 #

3539 # if_clauses [IfClauseNode]

3540 # else_clause StatNode or None

3541

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

3543

3544 def analyse_control_flow(self, env):

3545 env.start_branching(self.pos)

3546 for if_clause in self.if_clauses:

3547 if_clause.analyse_control_flow(env)

3548 env.next_branch(if_clause.end_pos())

3549 if self.else_clause:

3550 self.else_clause.analyse_control_flow(env)

3551 env.finish_branching(self.end_pos())

3552

3553 def analyse_declarations(self, env):

3554 for if_clause in self.if_clauses:

3555 if_clause.analyse_declarations(env)

3556 if self.else_clause:

3557 self.else_clause.analyse_declarations(env)

3558

3559 def analyse_expressions(self, env):

3560 for if_clause in self.if_clauses:

3561 if_clause.analyse_expressions(env)

3562 if self.else_clause:

3563 self.else_clause.analyse_expressions(env)

3564

3565 def generate_execution_code(self, code):

3566 code.mark_pos(self.pos)

3567 end_label = code.new_label()

3568 for if_clause in self.if_clauses:

3569 if_clause.generate_execution_code(code, end_label)

3570 if self.else_clause:

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

3572 self.else_clause.generate_execution_code(code)

3573 code.putln("}")

3574 code.put_label(end_label)

3575

3576 def annotate(self, code):

3577 for if_clause in self.if_clauses:

3578 if_clause.annotate(code)

3579 if self.else_clause:

3580 self.else_clause.annotate(code)

3581

3582

3583 class IfClauseNode(Node):

3584 # if or elif clause in an if statement

3585 #

3586 # condition ExprNode

3587 # body StatNode

3588

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

3590

3591 def analyse_control_flow(self, env):

3592 self.body.analyse_control_flow(env)

3593

3594 def analyse_declarations(self, env):

3595 self.condition.analyse_declarations(env)

3596 self.body.analyse_declarations(env)

3597

3598 def analyse_expressions(self, env):

3599 self.condition = \

3600 self.condition.analyse_temp_boolean_expression(env)

3601 self.body.analyse_expressions(env)

3602

3603 def generate_execution_code(self, code, end_label):

3604 self.condition.generate_evaluation_code(code)

3605 code.putln(

3606 "if (%s) {" %

3607 self.condition.result())

3608 self.condition.generate_disposal_code(code)

3609 self.condition.free_temps(code)

3610 self.body.generate_execution_code(code)

3611 #code.putln(

3612 # "goto %s;" %

3613 # end_label)

3614 code.put_goto(end_label)

3615 code.putln("}")

3616

3617 def annotate(self, code):

3618 self.condition.annotate(code)

3619 self.body.annotate(code)

3620

3621

3622 class SwitchCaseNode(StatNode):

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

3624 #

3625 # conditions [ExprNode]

3626 # body StatNode

3627

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

3629

3630 def generate_execution_code(self, code):

3631 for cond in self.conditions:

3632 code.mark_pos(cond.pos)

3633 cond.generate_evaluation_code(code)

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

3635 self.body.generate_execution_code(code)

3636 code.putln("break;")

3637

3638 def annotate(self, code):

3639 for cond in self.conditions:

3640 cond.annotate(code)

3641 self.body.annotate(code)

3642

3643 class SwitchStatNode(StatNode):

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

3645 #

3646 # test ExprNode

3647 # cases [SwitchCaseNode]

3648 # else_clause StatNode or None

3649

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

3651

3652 def generate_execution_code(self, code):

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

3654 for case in self.cases:

3655 case.generate_execution_code(code)

3656 if self.else_clause is not None:

3657 code.putln("default:")

3658 self.else_clause.generate_execution_code(code)

3659 code.putln("break;")

3660 code.putln("}")

3661

3662 def annotate(self, code):

3663 self.test.annotate(code)

3664 for case in self.cases:

3665 case.annotate(code)

3666 if self.else_clause is not None:

3667 self.else_clause.annotate(code)

3668

3669 class LoopNode(object):

3670

3671 def analyse_control_flow(self, env):

3672 env.start_branching(self.pos)

3673 self.body.analyse_control_flow(env)

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

3675 if self.else_clause:

3676 self.else_clause.analyse_control_flow(env)

3677 env.finish_branching(self.end_pos())

3678

3679

3680 class WhileStatNode(LoopNode, StatNode):

3681 # while statement

3682 #

3683 # condition ExprNode

3684 # body StatNode

3685 # else_clause StatNode

3686

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

3688

3689 def analyse_declarations(self, env):

3690 self.body.analyse_declarations(env)

3691 if self.else_clause:

3692 self.else_clause.analyse_declarations(env)

3693

3694 def analyse_expressions(self, env):

3695 self.condition = \

3696 self.condition.analyse_temp_boolean_expression(env)

3697 self.body.analyse_expressions(env)

3698 if self.else_clause:

3699 self.else_clause.analyse_expressions(env)

3700

3701 def generate_execution_code(self, code):

3702 old_loop_labels = code.new_loop_labels()

3703 code.putln(

3704 "while (1) {")

3705 self.condition.generate_evaluation_code(code)

3706 self.condition.generate_disposal_code(code)

3707 code.putln(

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

3709 self.condition.result())

3710 self.condition.free_temps(code)

3711 self.body.generate_execution_code(code)

3712 code.put_label(code.continue_label)

3713 code.putln("}")

3714 break_label = code.break_label

3715 code.set_loop_labels(old_loop_labels)

3716 if self.else_clause:

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

3718 self.else_clause.generate_execution_code(code)

3719 code.putln("}")

3720 code.put_label(break_label)

3721

3722 def annotate(self, code):

3723 self.condition.annotate(code)

3724 self.body.annotate(code)

3725 if self.else_clause:

3726 self.else_clause.annotate(code)

3727

3728

3729 def ForStatNode(pos, **kw):

3730 if 'iterator' in kw:

3731 return ForInStatNode(pos, **kw)

3732 else:

3733 return ForFromStatNode(pos, **kw)

3734

3735 class ForInStatNode(LoopNode, StatNode):

3736 # for statement

3737 #

3738 # target ExprNode

3739 # iterator IteratorNode

3740 # body StatNode

3741 # else_clause StatNode

3742 # item NextNode used internally

3743

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

3745 item = None

3746

3747 def analyse_declarations(self, env):

3748 self.target.analyse_target_declaration(env)

3749 self.body.analyse_declarations(env)

3750 if self.else_clause:

3751 self.else_clause.analyse_declarations(env)

3752

3753 def analyse_expressions(self, env):

3754 import ExprNodes

3755 self.target.analyse_target_types(env)

3756 self.iterator.analyse_expressions(env)

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

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

3759 self.body.analyse_expressions(env)

3760 if self.else_clause:

3761 self.else_clause.analyse_expressions(env)

3762

3763 def generate_execution_code(self, code):

3764 old_loop_labels = code.new_loop_labels()

3765 self.iterator.allocate_counter_temp(code)

3766 self.iterator.generate_evaluation_code(code)

3767 code.putln(

3768 "for (;;) {")

3769 self.item.generate_evaluation_code(code)

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

3771 self.body.generate_execution_code(code)

3772 code.put_label(code.continue_label)

3773 code.putln(

3774 "}")

3775 break_label = code.break_label

3776 code.set_loop_labels(old_loop_labels)

3777 if self.else_clause:

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

3779 self.else_clause.generate_execution_code(code)

3780 code.putln("}")

3781 code.put_label(break_label)

3782 self.iterator.release_counter_temp(code)

3783 self.iterator.generate_disposal_code(code)

3784 self.iterator.free_temps(code)

3785

3786 def annotate(self, code):

3787 self.target.annotate(code)

3788 self.iterator.annotate(code)

3789 self.body.annotate(code)

3790 if self.else_clause:

3791 self.else_clause.annotate(code)

3792 self.item.annotate(code)

3793

3794

3795 class ForFromStatNode(LoopNode, StatNode):

3796 # for name from expr rel name rel expr

3797 #

3798 # target NameNode

3799 # bound1 ExprNode

3800 # relation1 string

3801 # relation2 string

3802 # bound2 ExprNode

3803 # step ExprNode or None

3804 # body StatNode

3805 # else_clause StatNode or None

3806 #

3807 # Used internally:

3808 #

3809 # from_range bool

3810 # is_py_target bool

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

3812 # py_loopvar_node PyTempNode or None

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

3814

3815 is_py_target = False

3816 loopvar_node = None

3817 py_loopvar_node = None

3818 from_range = False

3819

3820 gil_message = "For-loop using object bounds or target"

3821

3822 def nogil_check(self, env):

3823 for x in (self.target, self.bound1, self.bound2):

3824 if x.type.is_pyobject:

3825 self.gil_error()

3826

3827 def analyse_declarations(self, env):

3828 self.target.analyse_target_declaration(env)

3829 self.body.analyse_declarations(env)

3830 if self.else_clause:

3831 self.else_clause.analyse_declarations(env)

3832

3833 def analyse_expressions(self, env):

3834 import ExprNodes

3835 self.target.analyse_target_types(env)

3836 self.bound1.analyse_types(env)

3837 self.bound2.analyse_types(env)

3838 if self.step is not None:

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

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

3841 self.step.analyse_types(env)

3842

3843 target_type = self.target.type

3844 if self.target.type.is_numeric:

3845 loop_type = self.target.type

3846 else:

3847 loop_type = PyrexTypes.c_int_type

3848 if not self.bound1.type.is_pyobject:

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

3850 if not self.bound2.type.is_pyobject:

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

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

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

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

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

3856 if not self.bound2.is_literal:

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

3858 if self.step is not None:

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

3860 if not self.step.is_literal:

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

3862

3863 target_type = self.target.type

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

3865 error(self.target.pos,

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

3867 if target_type.is_numeric:

3868 self.is_py_target = False

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

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

3871 self.loopvar_node = self.target

3872 self.py_loopvar_node = None

3873 else:

3874 self.is_py_target = True

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

3876 self.loopvar_node = c_loopvar_node

3877 self.py_loopvar_node = \

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

3879 self.body.analyse_expressions(env)

3880 if self.else_clause:

3881 self.else_clause.analyse_expressions(env)

3882

3883 def generate_execution_code(self, code):

3884 old_loop_labels = code.new_loop_labels()

3885 from_range = self.from_range

3886 self.bound1.generate_evaluation_code(code)

3887 self.bound2.generate_evaluation_code(code)

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

3889 if self.step is not None:

3890 self.step.generate_evaluation_code(code)

3891 step = self.step.result()

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

3893 import ExprNodes

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

3895 self.loopvar_node.allocate(code)

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

3897 self.py_loopvar_node.allocate(code)

3898 if from_range:

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

3900 else:

3901 loopvar_name = self.loopvar_node.result()

3902 code.putln(

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

3904 loopvar_name,

3905 self.bound1.result(), offset,

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

3907 loopvar_name, incop))

3908 if self.py_loopvar_node:

3909 self.py_loopvar_node.generate_evaluation_code(code)

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

3911 elif from_range:

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

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

3914 self.body.generate_execution_code(code)

3915 code.put_label(code.continue_label)

3916 if self.py_loopvar_node:

3917 # This mess is to make for..from loops with python targets behave

3918 # exactly like those with C targets with regards to re-assignment

3919 # of the loop variable.

3920 import ExprNodes

3921 if self.target.entry.is_pyglobal:

3922 # We know target is a NameNode, this is the only ugly case.

3923 target_node = ExprNodes.PyTempNode(self.target.pos, None)

3924 target_node.allocate(code)

3925 interned_cname = code.intern_identifier(self.target.entry.name)

3926 code.putln("/*here*/")

3927 code.putln("%s = __Pyx_GetName(%s, %s); %s" % (

3928 target_node.result(),

3929 Naming.module_cname,

3930 interned_cname,

3931 code.error_goto_if_null(target_node.result(), self.target.pos)))

3932 code.put_gotref(target_node.result())

3933 else:

3934 target_node = self.target

3935 from_py_node = ExprNodes.CoerceFromPyTypeNode(self.loopvar_node.type, target_node, None)

3936 from_py_node.temp_code = loopvar_name

3937 from_py_node.generate_result_code(code)

3938 if self.target.entry.is_pyglobal:

3939 code.put_decref(target_node.result(), target_node.type)

3940 target_node.release(code)

3941 code.putln("}")

3942 if self.py_loopvar_node:

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

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

3945 self.py_loopvar_node.generate_evaluation_code(code)

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

3947 break_label = code.break_label

3948 code.set_loop_labels(old_loop_labels)

3949 if self.else_clause:

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

3951 self.else_clause.generate_execution_code(code)

3952 code.putln("}")

3953 code.put_label(break_label)

3954 self.bound1.generate_disposal_code(code)

3955 self.bound1.free_temps(code)

3956 self.bound2.generate_disposal_code(code)

3957 self.bound2.free_temps(code)

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

3959 self.loopvar_node.release(code)

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

3961 self.py_loopvar_node.release(code)

3962 if self.step is not None:

3963 self.step.generate_disposal_code(code)

3964 self.step.free_temps(code)

3965

3966 relation_table = {

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

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

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

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

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

3972 }