1 #

2 # Pyrex - Parse tree nodes

3 #

4

5 import sys, os, time, copy

6

7 import Code

8 import Builtin

9 from Errors import error, warning, InternalError

10 import Naming

11 import PyrexTypes

12 import TypeSlots

13 from PyrexTypes import py_object_type, error_type, CTypedefType, CFuncType

14 from Symtab import ModuleScope, LocalScope, GeneratorLocalScope, \

15 StructOrUnionScope, PyClassScope, CClassScope

16 from Cython.Utils import open_new_file, replace_suffix, UtilityCode

17 from StringEncoding import EncodedString, escape_byte_string, split_docstring

18 import Options

19 import ControlFlow

20 import DebugFlags

21

22 absolute_path_length = 0

23

24 def relative_position(pos):

25 """

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

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

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

29 e.g,. when distributing binaries.)

30

31 INPUT:

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

33

34 OUTPUT:

35 relative filename

36 line number

37

38 AUTHOR: William Stein

39 """

40 global absolute_path_length

41 if absolute_path_length==0:

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

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

44

45 def embed_position(pos, docstring):

46 if not Options.embed_pos_in_docstring:

47 return docstring

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

49 if docstring is None:

50 # unicode string

51 return EncodedString(pos_line)

52

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

54 # otherwise make the docstring a unicode string

55 encoding = docstring.encoding

56 if encoding is not None:

57 try:

58 encoded_bytes = pos_line.encode(encoding)

59 except UnicodeEncodeError:

60 encoding = None

61

62 if not docstring:

63 # reuse the string encoding of the original docstring

64 doc = EncodedString(pos_line)

65 else:

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

67 doc.encoding = encoding

68 return doc

69

70

71 from Code import CCodeWriter

72 from types import FunctionType

73

74 def write_func_call(func):

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

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

77 # here we annotate the code with this function call

78 # but only if new code is generated

79 node, code = args[:2]

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

81 ' ' * code.call_level,

82 node.__class__.__name__,

83 func.__name__,

84 node.pos[1:])

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

86 code.putln(marker)

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

88 code.call_level += 4

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

90 code.call_level -= 4

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

92 code.buffer.stream.seek(pristine)

93 else:

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

95 code.putln(marker)

96 return res

97 else:

98 return func(*args, **kwds)

99 return f

100

101 class VerboseCodeWriter(type):

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

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

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

105 attrs = dict(attrs)

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

107 if isinstance(m, FunctionType):

108 attrs[mname] = write_func_call(m)

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

110

111

112 class Node(object):

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

114 # is_name boolean Is a NameNode

115 # is_literal boolean Is a ConstNode

116

117 if DebugFlags.debug_trace_code_generation:

118 __metaclass__ = VerboseCodeWriter

119

120 is_name = 0

121 is_literal = 0

122 temps = None

123

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

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

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

127 child_attrs = None

128

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

130 self.pos = pos

131 self.__dict__.update(kw)

132

133 gil_message = "Operation"

134

135 def gil_check(self, env):

136 if env.nogil:

137 self.gil_error()

138

139 def gil_error(self):

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

141

142 def clone_node(self):

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

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

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

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

147 level in the tree."""

148 result = copy.copy(self)

149 for attrname in result.child_attrs:

150 value = getattr(result, attrname)

151 if isinstance(value, list):

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

153 return result

154

155

156 #

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

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

159 #

160 # (0) analyse_control_flow

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

162 # queried.

163 #

164 # (1) analyse_declarations

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

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

167 # to an otherwise undeclared name).

168 #

169 # (2) analyse_expressions

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

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

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

173 # Allocate temporary locals for intermediate results. Fill

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

175 # fragment.

176 #

177 # (3) generate_code

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

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

180 # functions.

181 #

182

183 def analyse_control_flow(self, env):

184 pass

185

186 def analyse_declarations(self, env):

187 pass

188

189 def analyse_expressions(self, env):

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

191 self.__class__.__name__)

192

193 def generate_code(self, code):

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

195 self.__class__.__name__)

196

197 def annotate(self, code):

198 # mro does the wrong thing

199 if isinstance(self, BlockNode):

200 self.body.annotate(code)

201

202 def end_pos(self):

203 try:

204 return self._end_pos

205 except AttributeError:

206 pos = self.pos

207 if not self.child_attrs:

208 self._end_pos = pos

209 return pos

210 for attr in self.child_attrs:

211 child = getattr(self, attr)

212 # Sometimes lists, sometimes nodes

213 if child is None:

214 pass

215 elif isinstance(child, list):

216 for c in child:

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

218 else:

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

220 self._end_pos = pos

221 return pos

222

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

224 if cutoff == 0:

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

226 if encountered is None:

227 encountered = set()

228 if id(self) in encountered:

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

230 encountered.add(id(self))

231

232 def dump_child(x, level):

233 if isinstance(x, Node):

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

235 elif isinstance(x, list):

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

237 else:

238 return repr(x)

239

240

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

242 if len(attrs) == 0:

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

244 else:

245 indent = " " * level

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

247 for key, value in attrs:

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

249 res += "%s>" % indent

250 return res

251

252 class CompilerDirectivesNode(Node):

253 """

254 Sets compiler directives for the children nodes

255 """

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

257 # *all* possible directives.

258 # body Node

259 child_attrs = ["body"]

260

261 def analyse_control_flow(self, env):

262 old = env.directives

263 env.directives = self.directives

264 self.body.analyse_control_flow(env)

265 env.directives = old

266

267 def analyse_declarations(self, env):

268 old = env.directives

269 env.directives = self.directives

270 self.body.analyse_declarations(env)

271 env.directives = old

272

273 def analyse_expressions(self, env):

274 old = env.directives

275 env.directives = self.directives

276 self.body.analyse_expressions(env)

277 env.directives = old

278

279 def generate_function_definitions(self, env, code):

280 env_old = env.directives

281 code_old = code.globalstate.directives

282 code.globalstate.directives = self.directives

283 self.body.generate_function_definitions(env, code)

284 env.directives = env_old

285 code.globalstate.directives = code_old

286

287 def generate_execution_code(self, code):

288 old = code.globalstate.directives

289 code.globalstate.directives = self.directives

290 self.body.generate_execution_code(code)

291 code.globalstate.directives = old

292

293 def annotate(self, code):

294 old = code.globalstate.directives

295 code.globalstate.directives = self.directives

296 self.body.annotate(code)

297 code.globalstate.directives = old

298

299 class BlockNode(object):

300 # Mixin class for nodes representing a declaration block.

301

302 def generate_const_definitions(self, env, code):

303 if env.const_entries:

304 for entry in env.const_entries:

305 if not entry.is_interned:

306 code.globalstate.add_const_definition(entry)

307

308 def generate_interned_string_decls(self, env, code):

309 entries = env.global_scope().new_interned_string_entries

310 if entries:

311 for entry in entries:

312 code.globalstate.add_interned_string_decl(entry)

313 del entries[:]

314

315 def generate_py_string_decls(self, env, code):

316 if env is None:

317 return # earlier error

318 entries = env.pystring_entries

319 if entries:

320 for entry in entries:

321 if not entry.is_interned:

322 code.globalstate.add_py_string_decl(entry)

323

324 def generate_interned_num_decls(self, env, code):

325 # Flush accumulated interned nums from the global scope

326 # and generate declarations for them.

327 genv = env.global_scope()

328 entries = genv.interned_nums

329 if entries:

330 for entry in entries:

331 code.globalstate.add_interned_num_decl(entry)

332 del entries[:]

333

334 def generate_cached_builtins_decls(self, env, code):

335 entries = env.global_scope().undeclared_cached_builtins

336 for entry in entries:

337 code.globalstate.add_cached_builtin_decl(entry)

338 del entries[:]

339

340

341 class StatListNode(Node):

342 # stats a list of StatNode

343

344 child_attrs = ["stats"]

345

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

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

348 return node # No node-specific analysis necesarry

349 create_analysed = staticmethod(create_analysed)

350

351 def analyse_control_flow(self, env):

352 for stat in self.stats:

353 stat.analyse_control_flow(env)

354

355 def analyse_declarations(self, env):

356 #print "StatListNode.analyse_declarations" ###

357 for stat in self.stats:

358 stat.analyse_declarations(env)

359

360 def analyse_expressions(self, env):

361 #print "StatListNode.analyse_expressions" ###

362 for stat in self.stats:

363 stat.analyse_expressions(env)

364

365 def generate_function_definitions(self, env, code):

366 #print "StatListNode.generate_function_definitions" ###

367 for stat in self.stats:

368 stat.generate_function_definitions(env, code)

369

370 def generate_execution_code(self, code):

371 #print "StatListNode.generate_execution_code" ###

372 for stat in self.stats:

373 code.mark_pos(stat.pos)

374 stat.generate_execution_code(code)

375

376 def annotate(self, code):

377 for stat in self.stats:

378 stat.annotate(code)

379

380

381 class StatNode(Node):

382 #

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

384 #

385 # (1) generate_function_definitions

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

387 # unions, enums and functions defined in the current

388 # scope-block.

389 #

390 # (2) generate_execution_code

391 # Emit C code for executable statements.

392 #

393

394 def generate_function_definitions(self, env, code):

395 pass

396

397 def generate_execution_code(self, code):

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

399 self.__class__.__name__)

400

401

402 class CDefExternNode(StatNode):

403 # include_file string or None

404 # body StatNode

405

406 child_attrs = ["body"]

407

408 def analyse_declarations(self, env):

409 if self.include_file:

410 env.add_include_file(self.include_file)

411 old_cinclude_flag = env.in_cinclude

412 env.in_cinclude = 1

413 self.body.analyse_declarations(env)

414 env.in_cinclude = old_cinclude_flag

415

416 def analyse_expressions(self, env):

417 pass

418

419 def generate_execution_code(self, code):

420 pass

421

422 def annotate(self, code):

423 self.body.annotate(code)

424

425

426 class CDeclaratorNode(Node):

427 # Part of a C declaration.

428 #

429 # Processing during analyse_declarations phase:

430 #

431 # analyse

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

433 # CNameDeclaratorNode of the name being declared

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

435 #

436 # calling_convention string Calling convention of CFuncDeclaratorNode

437 # for which this is a base

438

439 child_attrs = []

440

441 calling_convention = ""

442

443

444 class CNameDeclaratorNode(CDeclaratorNode):

445 # name string The Pyrex name being declared

446 # cname string or None C name, if specified

447 # default ExprNode or None the value assigned on declaration

448

449 child_attrs = ['default']

450

451 default = None

452

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

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

455 # May have mistaken the name for the type.

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

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

458 elif base_type.is_void:

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

460 else:

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

462 base_type = py_object_type

463 self.type = base_type

464 return self, base_type

465

466 class CPtrDeclaratorNode(CDeclaratorNode):

467 # base CDeclaratorNode

468

469 child_attrs = ["base"]

470

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

472 if base_type.is_pyobject:

473 error(self.pos,

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

475 ptr_type = PyrexTypes.c_ptr_type(base_type)

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

477

478 class CArrayDeclaratorNode(CDeclaratorNode):

479 # base CDeclaratorNode

480 # dimension ExprNode

481

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

483

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

485 if self.dimension:

486 self.dimension.analyse_const_expression(env)

487 if not self.dimension.type.is_int:

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

489 size = self.dimension.result()

490 try:

491 size = int(size)

492 except ValueError:

493 # runtime constant?

494 pass

495 else:

496 size = None

497 if not base_type.is_complete():

498 error(self.pos,

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

500 if base_type.is_pyobject:

501 error(self.pos,

502 "Array element cannot be a Python object")

503 if base_type.is_cfunction:

504 error(self.pos,

505 "Array element cannot be a function")

506 array_type = PyrexTypes.c_array_type(base_type, size)

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

508

509

510 class CFuncDeclaratorNode(CDeclaratorNode):

511 # base CDeclaratorNode

512 # args [CArgDeclNode]

513 # has_varargs boolean

514 # exception_value ConstNode

515 # exception_check boolean True if PyErr_Occurred check needed

516 # nogil boolean Can be called without gil

517 # with_gil boolean Acquire gil around function body

518

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

520

521 overridable = 0

522 optional_arg_count = 0

523

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

525 if nonempty:

526 nonempty -= 1

527 func_type_args = []

528 for arg_node in self.args:

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

530 name = name_declarator.name

531 if name_declarator.cname:

532 error(self.pos,

533 "Function argument cannot have C name specification")

534 # Turn *[] argument into **

535 if type.is_array:

536 type = PyrexTypes.c_ptr_type(type.base_type)

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

538 if type.is_void:

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

540 # if type.is_pyobject and self.nogil:

541 # error(self.pos,

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

543 func_type_args.append(

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

545 if arg_node.default:

546 self.optional_arg_count += 1

547 elif self.optional_arg_count:

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

549

550 if self.optional_arg_count:

551 scope = StructOrUnionScope()

552 arg_count_member = '%sn' % Naming.pyrex_prefix

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

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

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

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

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

558 kind = 'struct',

559 scope = scope,

560 typedef_flag = 0,

561 pos = self.pos,

562 cname = struct_cname)

563 self.op_args_struct.defined_in_pxd = 1

564 self.op_args_struct.used = 1

565

566 exc_val = None

567 exc_check = 0

568 if self.exception_check == '+':

569 env.add_include_file('stdexcept')

570 if return_type.is_pyobject \

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

572 and self.exception_check != '+':

573 error(self.pos,

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

575 else:

576 if self.exception_value:

577 self.exception_value.analyse_const_expression(env)

578 if self.exception_check == '+':

579 exc_val_type = self.exception_value.type

580 if not exc_val_type.is_error and \

581 not exc_val_type.is_pyobject and \

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

583 error(self.exception_value.pos,

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

585 exc_val = self.exception_value

586 else:

587 exc_val = self.exception_value.result()

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

589 error(self.exception_value.pos,

590 "Exception value incompatible with function return type")

591 exc_check = self.exception_check

592 if return_type.is_array:

593 error(self.pos,

594 "Function cannot return an array")

595 if return_type.is_cfunction:

596 error(self.pos,

597 "Function cannot return a function")

598 func_type = PyrexTypes.CFuncType(

599 return_type, func_type_args, self.has_varargs,

600 optional_arg_count = self.optional_arg_count,

601 exception_value = exc_val, exception_check = exc_check,

602 calling_convention = self.base.calling_convention,

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

604 if self.optional_arg_count:

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

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

607

608

609 class CArgDeclNode(Node):

610 # Item in a function declaration argument list.

611 #

612 # base_type CBaseTypeNode

613 # declarator CDeclaratorNode

614 # not_none boolean Tagged with 'not None'

615 # default ExprNode or None

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

617 # default_result_code string cname or code fragment for default value

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

619 # is_kw_only boolean Is a keyword-only argument

620

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

622

623 is_self_arg = 0

624 is_generic = 1

625 type = None

626 name_declarator = None

627

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

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

630 if self.type is None:

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

632 # We fix that here.

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

634 if nonempty:

635 self.declarator.name = self.base_type.name

636 self.base_type.name = None

637 self.base_type.is_basic_c_type = False

638 could_be_name = True

639 else:

640 could_be_name = False

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

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

643 self.declarator.name = self.base_type.arg_name

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

645 else:

646 return self.name_declarator, self.type

647

648 def annotate(self, code):

649 if self.default:

650 self.default.annotate(code)

651

652

653 class CBaseTypeNode(Node):

654 # Abstract base class for C base type nodes.

655 #

656 # Processing during analyse_declarations phase:

657 #

658 # analyse

659 # Returns the type.

660

661 pass

662

663 class CAnalysedBaseTypeNode(Node):

664 # type type

665

666 child_attrs = []

667

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

669 return self.type

670

671 class CSimpleBaseTypeNode(CBaseTypeNode):

672 # name string

673 # module_path [string] Qualifying name components

674 # is_basic_c_type boolean

675 # signed boolean

676 # longness integer

677 # is_self_arg boolean Is self argument of C method

678

679 child_attrs = []

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

681

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

683 # Return type descriptor.

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

685 type = None

686 if self.is_basic_c_type:

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

688 if not type:

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

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

691 type = py_object_type

692 elif self.name is None:

693 if self.is_self_arg and env.is_c_class_scope:

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

695 type = env.parent_type

696 else:

697 type = py_object_type

698 else:

699 if self.module_path:

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

701 else:

702 scope = env

703 if scope:

704 if scope.is_c_class_scope:

705 scope = scope.global_scope()

706 entry = scope.lookup(self.name)

707 if entry and entry.is_type:

708 type = entry.type

709 elif could_be_name:

710 if self.is_self_arg and env.is_c_class_scope:

711 type = env.parent_type

712 else:

713 type = py_object_type

714 self.arg_name = self.name

715 else:

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

717 if type:

718 return type

719 else:

720 return PyrexTypes.error_type

721

722 class CBufferAccessTypeNode(CBaseTypeNode):

723 # After parsing:

724 # positional_args [ExprNode] List of positional arguments

725 # keyword_args DictNode Keyword arguments

726 # base_type_node CBaseTypeNode

727

728 # After analysis:

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

730

731

732 child_attrs = ["base_type_node", "positional_args",

733 "keyword_args", "dtype_node"]

734

735 dtype_node = None

736

737 name = None

738

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

740 base_type = self.base_type_node.analyse(env)

741 if base_type.is_error: return base_type

742 import Buffer

743

744 options = Buffer.analyse_buffer_options(

745 self.pos,

746 env,

747 self.positional_args,

748 self.keyword_args,

749 base_type.buffer_defaults)

750

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

752 return self.type

753

754 class CComplexBaseTypeNode(CBaseTypeNode):

755 # base_type CBaseTypeNode

756 # declarator CDeclaratorNode

757

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

759

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

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

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

763 return type

764

765

766 class CVarDefNode(StatNode):

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

768 #

769 # visibility 'private' or 'public' or 'extern'

770 # base_type CBaseTypeNode

771 # declarators [CDeclaratorNode]

772 # in_pxd boolean

773 # api boolean

774 # need_properties [entry]

775

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

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

778

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

780 need_properties = ()

781

782 decorators = None

783 directive_locals = {}

784

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

786 if not dest_scope:

787 dest_scope = env

788 self.dest_scope = dest_scope

789 base_type = self.base_type.analyse(env)

790 if (dest_scope.is_c_class_scope

791 and self.visibility == 'public'

792 and base_type.is_pyobject

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

794 self.need_properties = []

795 need_property = True

796 visibility = 'private'

797 else:

798 need_property = False

799 visibility = self.visibility

800

801 for declarator in self.declarators:

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

803 if not type.is_complete():

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

805 error(declarator.pos,

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

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

808 error(declarator.pos,

809 "Python object cannot be declared extern")

810 name = name_declarator.name

811 cname = name_declarator.cname

812 if name == '':

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

814 return

815 if type.is_cfunction:

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

817 cname = cname, visibility = self.visibility, in_pxd = self.in_pxd,

818 api = self.api)

819 if entry is not None:

820 entry.directive_locals = self.directive_locals

821 else:

822 if self.directive_locals:

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

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

825 error(self.pos,

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

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

828 cname = cname, visibility = visibility, is_cdef = 1)

829 if need_property:

830 self.need_properties.append(entry)

831 entry.needs_property = 1

832

833

834 class CStructOrUnionDefNode(StatNode):

835 # name string

836 # cname string or None

837 # kind "struct" or "union"

838 # typedef_flag boolean

839 # visibility "public" or "private"

840 # in_pxd boolean

841 # attributes [CVarDefNode] or None

842 # entry Entry

843

844 child_attrs = ["attributes"]

845

846 def analyse_declarations(self, env):

847 scope = None

848 if self.attributes is not None:

849 scope = StructOrUnionScope(self.name)

850 self.entry = env.declare_struct_or_union(

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

852 self.cname, visibility = self.visibility)

853 if self.attributes is not None:

854 if self.in_pxd and not env.in_cinclude:

855 self.entry.defined_in_pxd = 1

856 for attr in self.attributes:

857 attr.analyse_declarations(env, scope)

858 if self.visibility != 'extern':

859 need_typedef_indirection = False

860 for attr in scope.var_entries:

861 type = attr.type

862 while type.is_array:

863 type = type.base_type

864 if type == self.entry.type:

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

866 if self.typedef_flag:

867 while type.is_ptr:

868 type = type.base_type

869 if type == self.entry.type:

870 need_typedef_indirection = True

871 if need_typedef_indirection:

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

873 struct_entry = self.entry

874 cname = env.new_const_cname()

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

876 struct_entry.type.typedef_flag = False

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

878

879 def analyse_expressions(self, env):

880 pass

881

882 def generate_execution_code(self, code):

883 pass

884

885

886 class CEnumDefNode(StatNode):

887 # name string or None

888 # cname string or None

889 # items [CEnumDefItemNode]

890 # typedef_flag boolean

891 # visibility "public" or "private"

892 # in_pxd boolean

893 # entry Entry

894

895 child_attrs = ["items"]

896

897 def analyse_declarations(self, env):

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

899 cname = self.cname, typedef_flag = self.typedef_flag,

900 visibility = self.visibility)

901 if self.items is not None:

902 if self.in_pxd and not env.in_cinclude:

903 self.entry.defined_in_pxd = 1

904 for item in self.items:

905 item.analyse_declarations(env, self.entry)

906

907 def analyse_expressions(self, env):

908 if self.visibility == 'public':

909 self.temp = env.allocate_temp_pyobject()

910 env.release_temp(self.temp)

911

912 def generate_execution_code(self, code):

913 if self.visibility == 'public':

914 for item in self.entry.enum_values:

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

916 self.temp,

917 item.cname,

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

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

920 Naming.module_cname,

921 item.name,

922 self.temp,

923 code.error_goto(item.pos)))

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

925

926

927 class CEnumDefItemNode(StatNode):

928 # name string

929 # cname string or None

930 # value ExprNode or None

931

932 child_attrs = ["value"]

933

934 def analyse_declarations(self, env, enum_entry):

935 if self.value:

936 self.value.analyse_const_expression(env)

937 if not self.value.type.is_int:

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

939 self.value.analyse_const_expression(env)

940 value = self.value.result()

941 else:

942 value = self.name

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

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

945 enum_entry.enum_values.append(entry)

946

947

948 class CTypeDefNode(StatNode):

949 # base_type CBaseTypeNode

950 # declarator CDeclaratorNode

951 # visibility "public" or "private"

952 # in_pxd boolean

953

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

955

956 def analyse_declarations(self, env):

957 base = self.base_type.analyse(env)

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

959 name = name_declarator.name

960 cname = name_declarator.cname

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

962 cname = cname, visibility = self.visibility)

963 if self.in_pxd and not env.in_cinclude:

964 entry.defined_in_pxd = 1

965

966 def analyse_expressions(self, env):

967 pass

968 def generate_execution_code(self, code):

969 pass

970

971

972 class FuncDefNode(StatNode, BlockNode):

973 # Base class for function definition nodes.

974 #

975 # return_type PyrexType

976 # #filename string C name of filename string const

977 # entry Symtab.Entry

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

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

980

981 py_func = None

982 assmt = None

983 needs_closure = False

984

985 def analyse_default_values(self, env):

986 genv = env.global_scope()

987 for arg in self.args:

988 if arg.default:

989 if arg.is_generic:

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

991 arg.default.analyse_types(env)

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

993 if arg.default.is_literal:

994 arg.default_entry = arg.default

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

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

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

998 else:

999 arg.default.allocate_temps(genv)

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

1001 if arg.type.is_pyobject:

1002 arg.default_entry.init = 0

1003 arg.default_entry.used = 1

1004 arg.default_result_code = arg.default_entry.cname

1005 else:

1006 error(arg.pos,

1007 "This argument cannot have a default value")

1008 arg.default = None

1009

1010 def need_gil_acquisition(self, lenv):

1011 return 0

1012

1013 def create_local_scope(self, env):

1014 genv = env

1015 while env.is_py_class_scope or env.is_c_class_scope:

1016 env = env.outer_scope

1017 if self.needs_closure:

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

1019 else:

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

1021 lenv.return_type = self.return_type

1022 type = self.entry.type

1023 if type.is_cfunction:

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

1025 self.local_scope = lenv

1026 return lenv

1027

1028 def generate_function_definitions(self, env, code):

1029 import Buffer

1030

1031 lenv = self.local_scope

1032

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

1034 self.entry.scope.is_c_class_scope)

1035

1036 # Generate C code for header and body of function

1037 code.enter_cfunc_scope()

1038 code.return_from_error_cleanup_label = code.new_label()

1039

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

1041 code.mark_pos(self.pos)

1042 self.generate_interned_num_decls(lenv, code)

1043 self.generate_interned_string_decls(lenv, code)

1044 self.generate_py_string_decls(lenv, code)

1045 self.generate_cached_builtins_decls(lenv, code)

1046 #code.putln("")

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

1048 self.generate_const_definitions(lenv, code)

1049 # ----- Function header

1050 code.putln("")

1051 if self.py_func:

1052 self.py_func.generate_function_header(code,

1053 with_pymethdef = env.is_py_class_scope,

1054 proto_only=True)

1055 self.generate_function_header(code,

1056 with_pymethdef = env.is_py_class_scope)

1057 # ----- Local variable declarations

1058 lenv.mangle_closure_cnames(Naming.cur_scope_cname)

1059 self.generate_argument_declarations(lenv, code)

1060 if self.needs_closure:

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

1062 code.put_var_declarations(lenv.var_entries)

1063 init = ""

1064 if not self.return_type.is_void:

1065 if self.return_type.is_pyobject:

1066 init = " = NULL"

1067 code.putln(

1068 "%s%s;" %

1069 (self.return_type.declaration_code(

1070 Naming.retval_cname),

1071 init))

1072 tempvardecl_code = code.insertion_point()

1073 self.generate_keyword_list(code)

1074 # ----- Extern library function declarations

1075 lenv.generate_library_function_declarations(code)

1076 # ----- GIL acquisition

1077 acquire_gil = self.need_gil_acquisition(lenv)

1078 if acquire_gil:

1079 env.use_utility_code(force_init_threads_utility_code)

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

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

1082 if not lenv.nogil:

1083 code.put_setup_refcount_context(self.entry.name)

1084 if is_getbuffer_slot:

1085 self.getbuffer_init(code)

1086 # ----- Fetch arguments

1087 self.generate_argument_parsing_code(env, code)

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

1089 # incref it to properly keep track of refcounts.

1090 for entry in lenv.arg_entries:

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

1092 code.put_var_incref(entry)

1093 # ----- Initialise local variables

1094 for entry in lenv.var_entries:

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

1096 code.put_init_var_to_py_none(entry)

1097 # ----- Initialise local buffer auxiliary variables

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

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

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

1101 # ----- Check and convert arguments

1102 self.generate_argument_type_tests(code)

1103 # ----- Acquire buffer arguments

1104 for entry in lenv.arg_entries:

1105 if entry.type.is_buffer:

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

1107 # ----- Function body

1108 self.body.generate_execution_code(code)

1109 # ----- Default return value

1110 code.putln("")

1111 if self.return_type.is_pyobject:

1112 #if self.return_type.is_extension_type:

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

1114 #else:

1115 lhs = Naming.retval_cname

1116 code.put_init_to_py_none(lhs, self.return_type)

1117 else:

1118 val = self.return_type.default_value

1119 if val:

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

1121 # ----- Error cleanup

1122 if code.error_label in code.labels_used:

1123 code.put_goto(code.return_label)

1124 code.put_label(code.error_label)

1125 # cleanup temps the old way

1126 code.put_var_xdecrefs(lenv.temp_entries)

1127 # cleanup temps the new way

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

1129 code.put_xdecref(cname, type)

1130

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

1132 # so need to save and restore error state

1133 buffers_present = len(lenv.buffer_entries) > 0

1134 if buffers_present:

1135 code.globalstate.use_utility_code(restore_exception_utility_code)

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

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

1138 for entry in lenv.buffer_entries:

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

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

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

1142

1143 err_val = self.error_value()

1144 exc_check = self.caller_will_check_exceptions()

1145 if err_val is not None or exc_check:

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

1147 else:

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

1149 % self.entry.qualified_name, 0)

1150 code.putln(

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

1152 self.entry.qualified_name)

1153 env.use_utility_code(unraisable_exception_utility_code)

1154 env.use_utility_code(restore_exception_utility_code)

1155 default_retval = self.return_type.default_value

1156 if err_val is None and default_retval:

1157 err_val = default_retval

1158 if err_val is not None:

1159 code.putln(

1160 "%s = %s;" % (

1161 Naming.retval_cname,

1162 err_val))

1163

1164 if is_getbuffer_slot:

1165 self.getbuffer_error_cleanup(code)

1166

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

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

1169 # whether this section is used.

1170 if buffers_present or is_getbuffer_slot:

1171 code.put_goto(code.return_from_error_cleanup_label)

1172

1173

1174 # ----- Non-error return cleanup

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

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

1177 # block).

1178 code.put_label(code.return_label)

1179 for entry in lenv.buffer_entries:

1180 if entry.used:

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

1182 if is_getbuffer_slot:

1183 self.getbuffer_normal_cleanup(code)

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

1185 code.put_label(code.return_from_error_cleanup_label)

1186 if not Options.init_local_none:

1187 for entry in lenv.var_entries:

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

1189 entry.xdecref_cleanup = 1

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

1191 # Decref any increfed args

1192 for entry in lenv.arg_entries:

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

1194 code.put_var_decref(entry)

1195

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

1197 # ----- Return

1198 # This code is duplicated in ModuleNode.generate_module_init_func

1199 if not lenv.nogil:

1200 default_retval = self.return_type.default_value

1201 err_val = self.error_value()

1202 if err_val is None and default_retval:

1203 err_val = default_retval

1204 if self.return_type.is_pyobject:

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

1206

1207 code.put_finish_refcount_context()

1208

1209 if acquire_gil:

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

1211

1212 if not self.return_type.is_void:

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

1214

1215 code.putln("}")

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

1217 tempvardecl_code.put_var_declarations(lenv.temp_entries)

1218 tempvardecl_code.put_temp_declarations(code.funcstate)

1219 # ----- Python version

1220 code.exit_cfunc_scope()

1221 if self.py_func:

1222 self.py_func.generate_function_definitions(env, code)

1223 self.generate_wrapper_functions(code)

1224

1225 def declare_argument(self, env, arg):

1226 if arg.type.is_void:

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

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

1229 error(arg.pos,

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

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

1232

1233 def generate_wrapper_functions(self, code):

1234 pass

1235

1236 def generate_execution_code(self, code):

1237 # Evaluate and store argument default values

1238 for arg in self.args:

1239 default = arg.default

1240 if default:

1241 if not default.is_literal:

1242 default.generate_evaluation_code(code)

1243 default.make_owned_reference(code)

1244 code.putln(

1245 "%s = %s;" % (

1246 arg.default_entry.cname,

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

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

1249 code.putln("%s = 0;" % default.result())

1250 default.free_temps(code)

1251 code.put_var_giveref(arg.default_entry)

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

1253 if self.assmt:

1254 self.assmt.generate_execution_code(code)

1255

1256 #

1257 # Special code for the __getbuffer__ function

1258 #

1259 def getbuffer_init(self, code):

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

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

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

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

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

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

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

1267

1268 def getbuffer_error_cleanup(self, code):

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

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

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

1272 (info, info))

1273

1274 def getbuffer_normal_cleanup(self, code):

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

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

1277 code.put_gotref("Py_None")

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

1279 code.putln("}")

1280

1281 class CFuncDefNode(FuncDefNode):

1282 # C function definition.

1283 #

1284 # modifiers ['inline']

1285 # visibility 'private' or 'public' or 'extern'

1286 # base_type CBaseTypeNode

1287 # declarator CDeclaratorNode

1288 # body StatListNode

1289 # api boolean

1290 # decorators [DecoratorNode] list of decorators

1291 #

1292 # with_gil boolean Acquire GIL around body

1293 # type CFuncType

1294 # py_func wrapper for calling from Python

1295 # overridable whether or not this is a cpdef function

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

1297

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

1299

1300 inline_in_pxd = False

1301 decorators = None

1302 directive_locals = {}

1303

1304 def unqualified_name(self):

1305 return self.entry.name

1306

1307 def analyse_declarations(self, env):

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

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

1310 directive_locals = self.directive_locals

1311 base_type = self.base_type.analyse(env)

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

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

1314 if not type.is_cfunction:

1315 error(self.pos,

1316 "Suite attached to non-function declaration")

1317 # Remember the actual type according to the function header

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

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

1320 # from the base type of an extension type.

1321 self.type = type

1322 type.is_overridable = self.overridable

1323 declarator = self.declarator

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

1325 declarator = declarator.base

1326 self.args = declarator.args

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

1328 formal_arg.type = type_arg.type

1329 formal_arg.name = type_arg.name

1330 formal_arg.cname = type_arg.cname

1331 name = name_declarator.name

1332 cname = name_declarator.cname

1333 self.entry = env.declare_cfunction(

1334 name, type, self.pos,

1335 cname = cname, visibility = self.visibility,

1336 defining = self.body is not None,

1337 api = self.api, modifiers = self.modifiers)

1338 self.entry.inline_func_in_pxd = self.inline_in_pxd

1339 self.return_type = type.return_type

1340

1341 if self.overridable and not env.is_module_scope:

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

1343 # An error will be produced in the cdef function

1344 self.overridable = False

1345

1346 if self.overridable:

1347 import ExprNodes

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

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

1350 name = self.entry.name,

1351 args = self.args,

1352 star_arg = None,

1353 starstar_arg = None,

1354 doc = self.doc,

1355 body = py_func_body,

1356 is_wrapper = 1)

1357 self.py_func.is_module_scope = env.is_module_scope

1358 self.py_func.analyse_declarations(env)

1359 self.entry.as_variable = self.py_func.entry

1360 # Reset scope entry the above cfunction

1361 env.entries[name] = self.entry

1362 self.py_func.interned_attr_cname = env.intern_identifier(

1363 self.py_func.entry.name)

1364 if not env.is_module_scope or Options.lookup_module_cpdef:

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

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

1367

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

1369 import ExprNodes

1370 args = self.type.args

1371 if omit_optional_args:

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

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

1374 if is_module_scope:

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

1376 else:

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

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

1379 skip_dispatch = not is_module_scope or Options.lookup_module_cpdef

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

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

1382

1383 def declare_arguments(self, env):

1384 for arg in self.type.args:

1385 if not arg.name:

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

1387 self.declare_argument(env, arg)

1388

1389 def need_gil_acquisition(self, lenv):

1390 type = self.type

1391 with_gil = self.type.with_gil

1392 if type.nogil and not with_gil:

1393 if type.return_type.is_pyobject:

1394 error(self.pos,

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

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

1397 if entry.type.is_pyobject:

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

1399 return with_gil

1400

1401 def analyse_expressions(self, env):

1402 self.local_scope.directives = env.directives

1403 self.analyse_default_values(env)

1404 if self.py_func is not None:

1405 self.py_func.analyse_expressions(env)

1406

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

1408 arg_decls = []

1409 type = self.type

1410 visibility = self.entry.visibility

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

1412 arg_decls.append(arg.declaration_code())

1413 if with_dispatch and self.overridable:

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

1415 if type.optional_arg_count and with_opt_args:

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

1417 if type.has_varargs:

1418 arg_decls.append("...")

1419 if not arg_decls:

1420 arg_decls = ["void"]

1421 if cname is None:

1422 cname = self.entry.func_cname

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

1424 if visibility == 'public':

1425 dll_linkage = "DL_EXPORT"

1426 else:

1427 dll_linkage = None

1428 header = self.return_type.declaration_code(entity,

1429 dll_linkage = dll_linkage)

1430 if visibility == 'extern':

1431 storage_class = "%s " % Naming.extern_c_macro

1432 elif visibility == 'public':

1433 storage_class = ""

1434 else:

1435 storage_class = "static "

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

1437 storage_class,

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

1439 header))

1440

1441 def generate_argument_declarations(self, env, code):

1442 for arg in self.args:

1443 if arg.default:

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

1445

1446 def generate_keyword_list(self, code):

1447 pass

1448

1449 def generate_argument_parsing_code(self, env, code):

1450 i = 0

1451 if self.type.optional_arg_count:

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

1453 for arg in self.args:

1454 if arg.default:

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

1456 # argument name mangling is in place

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

1458 declarator = arg.declarator

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

1460 declarator = declarator.base

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

1462 i += 1

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

1464 code.putln('}')

1465 code.putln('}')

1466

1467 def generate_argument_conversion_code(self, code):

1468 pass

1469

1470 def generate_argument_type_tests(self, code):

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

1472 # class is a supertype of the declared type.

1473 for arg in self.type.args:

1474 if arg.needs_type_test:

1475 self.generate_arg_type_test(arg, code)

1476

1477 def generate_arg_type_test(self, arg, code):

1478 # Generate type test for one argument.

1479 if arg.type.typeobj_is_available():

1480 typeptr_cname = arg.type.typeptr_cname

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

1482 code.putln(

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

1484 arg_code,

1485 typeptr_cname,

1486 not arg.not_none,

1487 arg.name,

1488 type.is_builtin_type,

1489 code.error_goto(arg.pos)))

1490 else:

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

1492 "without type object name specification")

1493

1494 def error_value(self):

1495 if self.return_type.is_pyobject:

1496 return "0"

1497 else:

1498 #return None

1499 return self.entry.type.exception_value

1500

1501 def caller_will_check_exceptions(self):

1502 return self.entry.type.exception_check

1503

1504 def generate_wrapper_functions(self, code):

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

1506 # wrappers to put in the slots here.

1507 k = 0

1508 entry = self.entry

1509 func_type = entry.type

1510 while entry.prev_entry is not None:

1511 k += 1

1512 entry = entry.prev_entry

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

1514 code.putln()

1515 self.generate_function_header(code,

1516 0,

1517 with_dispatch = entry.type.is_overridable,

1518 with_opt_args = entry.type.optional_arg_count,

1519 cname = entry.func_cname)

1520 if not self.return_type.is_void:

1521 code.put('return ')

1522 args = self.type.args

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

1524 if entry.type.is_overridable:

1525 arglist.append(Naming.skip_dispatch_cname)

1526 elif func_type.is_overridable:

1527 arglist.append('0')

1528 if entry.type.optional_arg_count:

1529 arglist.append(Naming.optional_args_cname)

1530 elif func_type.optional_arg_count:

1531 arglist.append('NULL')

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

1533 code.putln('}')

1534

1535

1536 class PyArgDeclNode(Node):

1537 # Argument which must be a Python object (used

1538 # for * and ** arguments).

1539 #

1540 # name string

1541 # entry Symtab.Entry

1542 child_attrs = []

1543

1544

1545 class DecoratorNode(Node):

1546 # A decorator

1547 #

1548 # decorator NameNode or CallNode

1549 child_attrs = ['decorator']

1550

1551

1552 class DefNode(FuncDefNode):

1553 # A Python function definition.

1554 #

1555 # name string the Python name of the function

1556 # decorators [DecoratorNode] list of decorators

1557 # args [CArgDeclNode] formal arguments

1558 # star_arg PyArgDeclNode or None * argument

1559 # starstar_arg PyArgDeclNode or None ** argument

1560 # doc EncodedString or None

1561 # body StatListNode

1562 #

1563 # The following subnode is constructed internally

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

1565 #

1566 # assmt AssignmentNode Function construction/assignment

1567

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

1569

1570 assmt = None

1571 num_kwonly_args = 0

1572 num_required_kw_args = 0

1573 reqd_kw_flags_cname = "0"

1574 is_wrapper = 0

1575 decorators = None

1576 entry = None

1577

1578

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

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

1581 k = rk = r = 0

1582 for arg in self.args:

1583 if arg.kw_only:

1584 k += 1

1585 if not arg.default:

1586 rk += 1

1587 if not arg.default:

1588 r += 1

1589 self.num_kwonly_args = k

1590 self.num_required_kw_args = rk

1591 self.num_required_args = r

1592

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

1594 if self.star_arg:

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

1596 if self.starstar_arg:

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

1598 if cfunc is None:

1599 cfunc_args = []

1600 for formal_arg in self.args:

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

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

1603 cname = None,

1604 type = py_object_type,

1605 pos = formal_arg.pos))

1606 cfunc_type = PyrexTypes.CFuncType(return_type = py_object_type,

1607 args = cfunc_args,

1608 has_varargs = False,

1609 exception_value = None,

1610 exception_check = False,

1611 nogil = False,

1612 with_gil = False,

1613 is_overridable = True)

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

1615 else:

1616 cfunc_type = cfunc.type

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

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

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

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

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

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

1623 formal_arg.type = type_arg.type

1624 formal_arg.name_declarator = name_declarator

1625 import ExprNodes

1626 if cfunc_type.exception_value is None:

1627 exception_value = None

1628 else:

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

1630 declarator = CFuncDeclaratorNode(self.pos,

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

1632 args = self.args,

1633 has_varargs = False,

1634 exception_check = cfunc_type.exception_check,

1635 exception_value = exception_value,

1636 with_gil = cfunc_type.with_gil,

1637 nogil = cfunc_type.nogil)

1638 return CFuncDefNode(self.pos,

1639 modifiers = [],

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

1641 declarator = declarator,

1642 body = self.body,

1643 doc = self.doc,

1644 overridable = cfunc_type.is_overridable,

1645 type = cfunc_type,

1646 with_gil = cfunc_type.with_gil,

1647 nogil = cfunc_type.nogil,

1648 visibility = 'private',

1649 api = False,

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

1651

1652 def analyse_declarations(self, env):

1653 if 'locals' in env.directives:

1654 directive_locals = env.directives['locals']

1655 else:

1656 directive_locals = {}

1657 self.directive_locals = directive_locals

1658 for arg in self.args:

1659 if hasattr(arg, 'name'):

1660 type = arg.type

1661 name_declarator = None

1662 else:

1663 base_type = arg.base_type.analyse(env)

1664 name_declarator, type = \

1665 arg.declarator.analyse(base_type, env)

1666 arg.name = name_declarator.name

1667 if arg.name in directive_locals:

1668 type_node = directive_locals[arg.name]

1669 other_type = type_node.analyse_as_type(env)

1670 if other_type is None:

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

1672 elif (type is not PyrexTypes.py_object_type

1673 and not type.same_as(other_type)):

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

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

1676 else:

1677 type = other_type

1678 if name_declarator and name_declarator.cname:

1679 error(self.pos,

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

1681 arg.type = type.as_argument_type()

1682 arg.hdr_type = None

1683 arg.needs_conversion = 0

1684 arg.needs_type_test = 0

1685 arg.is_generic = 1

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

1687 error(self.pos,

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

1689 self.declare_pyfunction(env)

1690 self.analyse_signature(env)

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

1692

1693 def analyse_signature(self, env):

1694 any_type_tests_needed = 0

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

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

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

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

1699 self.entry.signature = TypeSlots.pyfunction_noargs

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

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

1702 self.entry.signature = TypeSlots.pyfunction_onearg

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

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

1705 self.entry.signature = TypeSlots.unaryfunc

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

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

1708 self.entry.signature = TypeSlots.ibinaryfunc

1709 elif self.entry.is_special:

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

1711 sig = self.entry.signature

1712 nfixed = sig.num_fixed_args()

1713 for i in range(nfixed):

1714 if i < len(self.args):

1715 arg = self.args[i]

1716 arg.is_generic = 0

1717 if sig.is_self_arg(i):

1718 arg.is_self_arg = 1

1719 arg.hdr_type = arg.type = env.parent_type

1720 arg.needs_conversion = 0

1721 else:

1722 arg.hdr_type = sig.fixed_arg_type(i)

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

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

1725 arg.needs_type_test = 1

1726 any_type_tests_needed = 1

1727 else:

1728 arg.needs_conversion = 1

1729 if arg.needs_conversion:

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

1731 else:

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

1733 else:

1734 self.bad_signature()

1735 return

1736 if nfixed < len(self.args):

1737 if not sig.has_generic_args:

1738 self.bad_signature()

1739 for arg in self.args:

1740 if arg.is_generic and \

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

1742 arg.needs_type_test = 1

1743 any_type_tests_needed = 1

1744 if any_type_tests_needed:

1745 env.use_utility_code(arg_type_test_utility_code)

1746

1747 def bad_signature(self):

1748 sig = self.entry.signature

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

1750 if sig.has_generic_args:

1751 expected_str = expected_str + " or more"

1752 name = self.name

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

1754 desc = "Special method"

1755 else:

1756 desc = "Method"

1757 error(self.pos,

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

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

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

1761

1762 def signature_has_nongeneric_args(self):

1763 argcount = len(self.args)

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

1765 return 0

1766 return 1

1767

1768 def signature_has_generic_args(self):

1769 return self.entry.signature.has_generic_args

1770

1771 def declare_pyfunction(self, env):

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

1773 name = self.name

1774 entry = env.lookup_here(self.name)

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

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

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

1778 self.entry = entry

1779 prefix = env.scope_prefix

1780 entry.func_cname = \

1781 Naming.pyfunc_prefix + prefix + name

1782 entry.pymethdef_cname = \

1783 Naming.pymethdef_prefix + prefix + name

1784 if Options.docstrings:

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

1786 entry.doc_cname = \

1787 Naming.funcdoc_prefix + prefix + name

1788 else:

1789 entry.doc = None

1790

1791 def declare_arguments(self, env):

1792 for arg in self.args:

1793 if not arg.name:

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

1795 if arg.needs_conversion:

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

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

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

1799 if arg.type.is_pyobject:

1800 arg.entry.init = "0"

1801 arg.entry.init_to_none = 0

1802 else:

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

1804 arg.entry.used = 1

1805 arg.entry.is_self_arg = arg.is_self_arg

1806 if not arg.is_self_arg:

1807 arg.name_entry = env.get_string_const(

1808 arg.name, identifier = True)

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

1810 if arg.hdr_type:

1811 if arg.is_self_arg or \

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

1813 arg.entry.is_declared_generic = 1

1814 self.declare_python_arg(env, self.star_arg)

1815 self.declare_python_arg(env, self.starstar_arg)

1816

1817 def declare_python_arg(self, env, arg):

1818 if arg:

1819 entry = env.declare_var(arg.name,

1820 PyrexTypes.py_object_type, arg.pos)

1821 entry.used = 1

1822 entry.init = "0"

1823 entry.init_to_none = 0

1824 entry.xdecref_cleanup = 1

1825 arg.entry = entry

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

1827

1828 def analyse_expressions(self, env):

1829 self.local_scope.directives = env.directives

1830 self.analyse_default_values(env)

1831 if env.is_py_class_scope:

1832 self.synthesize_assignment_node(env)

1833

1834 def synthesize_assignment_node(self, env):

1835 import ExprNodes

1836 self.assmt = SingleAssignmentNode(self.pos,

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

1838 rhs = ExprNodes.UnboundMethodNode(self.pos,

1839 class_cname = env.class_obj_cname,

1840 function = ExprNodes.PyCFunctionNode(self.pos,

1841 pymethdef_cname = self.entry.pymethdef_cname)))

1842 self.assmt.analyse_declarations(env)

1843 self.assmt.analyse_expressions(env)

1844

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

1846 arg_code_list = []

1847 sig = self.entry.signature

1848 if sig.has_dummy_arg:

1849 arg_code_list.append(

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

1851 for arg in self.args:

1852 if not arg.is_generic:

1853 if arg.is_self_arg:

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

1855 else:

1856 arg_code_list.append(

1857 arg.hdr_type.declaration_code(arg.hdr_cname))

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

1859 arg_code_list.append("PyObject *unused")

1860 if sig.has_generic_args:

1861 arg_code_list.append(

1862 "PyObject *%s, PyObject *%s"

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

1864 arg_code = ", ".join(arg_code_list)

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

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

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

1868 if proto_only:

1869 return

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

1871 docstr = self.entry.doc

1872 if not isinstance(docstr, str):

1873 docstr = docstr.utf8encode()

1874 code.putln(

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

1876 self.entry.doc_cname,

1877 split_docstring(escape_byte_string(docstr))))

1878 if with_pymethdef:

1879 code.put(

1880 "static PyMethodDef %s = " %

1881 self.entry.pymethdef_cname)

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

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

1884

1885 def generate_argument_declarations(self, env, code):

1886 for arg in self.args:

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

1888 if arg.needs_conversion:

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

1890 else:

1891 code.put_var_declaration(arg.entry)

1892

1893 def generate_keyword_list(self, code):

1894 if self.signature_has_generic_args() and \

1895 self.signature_has_nongeneric_args():

1896 code.put(

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

1898 Naming.pykwdlist_cname)

1899 for arg in self.args:

1900 if arg.is_generic:

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

1902 code.putln("0};")

1903

1904 def generate_argument_parsing_code(self, env, code):

1905 # Generate PyArg_ParseTuple call for generic

1906 # arguments, if any.

1907 if self.entry.signature.has_dummy_arg:

1908 # get rid of unused argument warning

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

1910

1911 old_error_label = code.new_error_label()

1912 our_error_label = code.error_label

1913 end_label = code.new_label("argument_unpacking_done")

1914

1915 has_kwonly_args = self.num_kwonly_args > 0

1916 has_star_or_kw_args = self.star_arg is not None \

1917 or self.starstar_arg is not None or has_kwonly_args

1918

1919 if not self.signature_has_generic_args():

1920 if has_star_or_kw_args:

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

1922 self.generate_argument_conversion_code(code)

1923

1924 elif not self.signature_has_nongeneric_args():

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

1926 self.generate_stararg_copy_code(code)

1927

1928 else:

1929 positional_args = []

1930 kw_only_args = []

1931 default_seen = 0

1932 for arg in self.args:

1933 arg_entry = arg.entry

1934 if arg.is_generic:

1935 if arg.default:

1936 default_seen = 1

1937 if not arg.is_self_arg:

1938 if arg.kw_only:

1939 kw_only_args.append(arg)

1940 else:

1941 positional_args.append(arg)

1942 elif arg.kw_only:

1943 kw_only_args.append(arg)

1944 default_seen = 1

1945 elif default_seen:

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

1947 elif not arg.is_self_arg:

1948 positional_args.append(arg)

1949

1950 self.generate_tuple_and_keyword_parsing_code(

1951 positional_args, kw_only_args, end_label, code)

1952

1953 code.error_label = old_error_label

1954 if code.label_used(our_error_label):

1955 if not code.label_used(end_label):

1956 code.put_goto(end_label)

1957 code.put_label(our_error_label)

1958 if has_star_or_kw_args:

1959 self.generate_arg_decref(self.star_arg, code)

1960 if self.starstar_arg:

1961 if self.starstar_arg.entry.xdecref_cleanup:

1962 code.put_var_xdecref(self.starstar_arg.entry)

1963 else:

1964 code.put_var_decref(self.starstar_arg.entry)

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

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

1967 if code.label_used(end_label):

1968 code.put_label(end_label)

1969

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

1971 if arg.type.is_pyobject:

1972 if arg.is_generic:

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

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

1975 else:

1976 func = arg.type.from_py_function

1977 if func:

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

1979 arg.entry.cname,

1980 func,

1981 item,

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

1983 else:

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

1985

1986 def generate_arg_xdecref(self, arg, code):

1987 if arg:

1988 code.put_var_xdecref(arg.entry)

1989

1990 def generate_arg_decref(self, arg, code):

1991 if arg:

1992 code.put_var_decref(arg.entry)

1993

1994 def generate_stararg_copy_code(self, code):

1995 if not self.star_arg:

1996 code.globalstate.use_utility_code(raise_argtuple_invalid_utility_code)

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

1998 Naming.args_cname)

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

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

2001 code.putln("}")

2002

2003 code.globalstate.use_utility_code(keyword_string_check_utility_code)

2004

2005 if self.starstar_arg:

2006 if self.star_arg:

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

2008 else:

2009 kwarg_check = "%s" % Naming.kwds_cname

2010 else:

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

2012 Naming.kwds_cname, Naming.kwds_cname)

2013 code.putln(

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

2015 kwarg_check, Naming.kwds_cname, self.name,

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

2017

2018 if self.starstar_arg:

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

2020 self.starstar_arg.entry.cname,

2021 Naming.kwds_cname,

2022 Naming.kwds_cname))

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

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

2025 self.starstar_arg.entry.xdecref_cleanup = 0

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

2027

2028

2029 if self.star_arg:

2030 code.put_incref(Naming.args_cname, py_object_type)

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

2032 self.star_arg.entry.cname,

2033 Naming.args_cname))

2034 self.star_arg.entry.xdecref_cleanup = 0

2035

2036 def generate_tuple_and_keyword_parsing_code(self, positional_args,

2037 kw_only_args, success_label, code):

2038 argtuple_error_label = code.new_label("argtuple_error")

2039

2040 min_positional_args = self.num_required_args - self.num_required_kw_args

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

2042 min_positional_args -= 1

2043 max_positional_args = len(positional_args)

2044 has_fixed_positional_count = not self.star_arg and \

2045 min_positional_args == max_positional_args

2046

2047 code.globalstate.use_utility_code(raise_double_keywords_utility_code)

2048 code.globalstate.use_utility_code(raise_argtuple_invalid_utility_code)

2049 if self.num_required_kw_args:

2050 code.globalstate.use_utility_code(raise_keyword_required_utility_code)

2051

2052 if self.starstar_arg or self.star_arg:

2053 self.generate_stararg_init_code(max_positional_args, code)

2054

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

2056 if self.num_required_kw_args:

2057 likely_hint = "likely"

2058 else:

2059 likely_hint = "unlikely"

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

2061 self.generate_keyword_unpacking_code(

2062 min_positional_args, max_positional_args,

2063 has_fixed_positional_count,

2064 positional_args, kw_only_args, argtuple_error_label, code)

2065

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

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

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

2069 # check the length here

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

2071 compare = '!='

2072 else:

2073 compare = '<'

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

2075 Naming.args_cname, compare, min_positional_args))

2076 code.put_goto(argtuple_error_label)

2077

2078 if self.num_required_kw_args:

2079 # pure error case: keywords required but not passed

2080 if max_positional_args > min_positional_args and not self.star_arg:

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

2082 Naming.args_cname, max_positional_args))

2083 code.put_goto(argtuple_error_label)

2084 code.putln('} else {')

2085 for i, arg in enumerate(kw_only_args):

2086 if not arg.default:

2087 # required keyword-only argument missing

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

2089 self.name.utf8encode(),

2090 arg.name_entry.pystring_cname))

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

2092 break

2093

2094 elif min_positional_args == max_positional_args:

2095 # parse the exact number of positional arguments from the

2096 # args tuple

2097 code.putln('} else {')

2098 for i, arg in enumerate(positional_args):

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

2100 self.generate_arg_assignment(arg, item, code)

2101 self.generate_arg_default_assignments(code)

2102

2103 else:

2104 # parse the positional arguments from the variable length

2105 # args tuple

2106 code.putln('} else {')

2107 self.generate_arg_default_assignments(code)

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

2109 if self.star_arg:

2110 code.putln('default:')

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

2112 for i, arg in reversed_args:

2113 if i >= min_positional_args-1:

2114 if min_positional_args > 1:

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

2116 else:

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

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

2119 self.generate_arg_assignment(arg, item, code)

2120 if min_positional_args == 0:

2121 code.put('case 0: ')

2122 code.putln('break;')

2123 if self.star_arg:

2124 if min_positional_args:

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

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

2127 code.put_goto(argtuple_error_label)

2128 else:

2129 code.put('default: ')

2130 code.put_goto(argtuple_error_label)

2131 code.putln('}')

2132

2133 code.putln('}')

2134

2135 if code.label_used(argtuple_error_label):

2136 code.put_goto(success_label)

2137 code.put_label(argtuple_error_label)

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

2139 self.name.utf8encode(), has_fixed_positional_count,

2140 min_positional_args, max_positional_args,

2141 Naming.args_cname))

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

2143

2144 def generate_arg_default_assignments(self, code):

2145 for arg in self.args:

2146 if arg.is_generic and arg.default:

2147 code.putln(

2148 "%s = %s;" % (

2149 arg.entry.cname,

2150 arg.default_result_code))

2151

2152 def generate_stararg_init_code(self, max_positional_args, code):

2153 if self.starstar_arg:

2154 self.starstar_arg.entry.xdecref_cleanup = 0

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

2156 self.starstar_arg.entry.cname,

2157 self.starstar_arg.entry.cname,

2158 self.error_value()))

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

2160 if self.star_arg:

2161 self.star_arg.entry.xdecref_cleanup = 0

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

2163 Naming.args_cname,

2164 max_positional_args))

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

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

2167 max_positional_args, Naming.args_cname))

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

2169 if self.starstar_arg:

2170 code.putln("")

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

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

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

2174 code.putln('}')

2175 else:

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

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

2178 code.putln('} else {')

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

2180 code.put_incref(Naming.empty_tuple, py_object_type)

2181 code.putln('}')

2182

2183 def generate_keyword_unpacking_code(self, min_positional_args, max_positional_args,

2184 has_fixed_positional_count, positional_args,

2185 kw_only_args, argtuple_error_label, code):

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

2187 max_args = len(all_args)

2188

2189 default_args = []

2190 for i, arg in enumerate(all_args):

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

2192 default_value = arg.default_result_code

2193 if arg.type is not PyrexTypes.py_object_type:

2194 default_value = "(PyObject*)"+default_value

2195 default_args.append((i, default_value))

2196

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

2198 Naming.kwds_cname)

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

2200 # default value, but C89 needs this

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

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

2203 for i, default_value in default_args:

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

2205

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

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

2208 if self.star_arg:

2209 code.putln('default:')

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

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

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

2213 i, Naming.args_cname, i))

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

2215 if not self.star_arg:

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

2217 code.put_goto(argtuple_error_label)

2218 code.putln('}')

2219

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

2221 # from the kw dict

2222 if self.num_required_args or max_positional_args > 0:

2223 last_required_arg = -1

2224 for i, arg in enumerate(all_args):

2225 if not arg.default:

2226 last_required_arg = i

2227 if last_required_arg < max_positional_args:

2228 last_required_arg = max_positional_args-1

2229 num_required_args = self.num_required_args

2230 if max_positional_args > 0:

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

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

2233 if max_positional_args > 0 and i <= max_positional_args:

2234 if self.star_arg and i == max_positional_args:

2235 code.putln('default:')

2236 else:

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

2238 if arg.default:

2239 if arg.kw_only:

2240 # handled separately below

2241 continue

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

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

2244 Naming.kwds_cname, arg.name_entry.pystring_cname))

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

2246 code.putln('}')

2247 else:

2248 num_required_args -= 1

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

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

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

2252 if i < min_positional_args:

2253 if i == 0:

2254 # special case: we know arg 0 is missing

2255 code.put('else ')

2256 code.put_goto(argtuple_error_label)

2257 else:

2258 # print the correct number of values (args or

2259 # kwargs) that were passed into positional

2260 # arguments up to this point

2261 code.putln('else {')

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

2263 self.name.utf8encode(), has_fixed_positional_count,

2264 min_positional_args, max_positional_args, i))

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

2266 code.putln('}')

2267 elif arg.kw_only:

2268 code.putln('else {')

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

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

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

2272 code.putln('}')

2273 if max_positional_args > 0:

2274 code.putln('}')

2275

2276 if kw_only_args and not self.starstar_arg:

2277 # unpack optional keyword-only arguments

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

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

2280 optional_args = []

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

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

2283 continue

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

2285 if optional_args:

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

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

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

2289 for i, arg in optional_args:

2290 code.putln(

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

2292 Naming.kwds_cname, arg.name_entry.pystring_cname))

2293 code.putln(

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

2295 code.putln('break;')

2296 code.putln('}')

2297

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

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

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

2301 #

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

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

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

2305 # common cases above.

2306 if max_positional_args == 0:

2307 pos_arg_count = "0"

2308 elif self.star_arg:

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

2310 Naming.args_cname, max_positional_args,

2311 Naming.args_cname, max_positional_args))

2312 pos_arg_count = "used_pos_args"

2313 else:

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

2315 code.globalstate.use_utility_code(parse_keywords_utility_code)

2316 code.put(

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

2318 Naming.kwds_cname,

2319 Naming.pykwdlist_cname,

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

2321 pos_arg_count,

2322 self.name.utf8encode()))

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

2324 code.putln('}')

2325

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

2327 for i, arg in enumerate(all_args):

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

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

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

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

2332 code.putln('} else {')

2333 code.putln(

2334 "%s = %s;" % (

2335 arg.entry.cname,

2336 arg.default_result_code))

2337 code.putln('}')

2338

2339 def generate_argument_conversion_code(self, code):

2340 # Generate code to convert arguments from

2341 # signature type to declared type, if needed.

2342 for arg in self.args:

2343 if arg.needs_conversion:

2344 self.generate_arg_conversion(arg, code)

2345

2346 def generate_arg_conversion(self, arg, code):

2347 # Generate conversion code for one argument.

2348 old_type = arg.hdr_type

2349 new_type = arg.type

2350 if old_type.is_pyobject:

2351 if arg.default:

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

2353 else:

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

2355 self.generate_arg_conversion_from_pyobject(arg, code)

2356 code.putln("}")

2357 elif new_type.is_pyobject:

2358 self.generate_arg_conversion_to_pyobject(arg, code)

2359 else:

2360 if new_type.assignable_from(old_type):

2361 code.putln(

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

2363 else:

2364 error(arg.pos,

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

2366 (old_type, new_type))

2367

2368 def generate_arg_conversion_from_pyobject(self, arg, code):

2369 new_type = arg.type

2370 func = new_type.from_py_function

2371 # copied from CoerceFromPyTypeNode

2372 if func:

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

2374 arg.entry.cname,

2375 func,

2376 arg.hdr_cname,

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

2378 else:

2379 error(arg.pos,

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

2381 % new_type)

2382

2383 def generate_arg_conversion_to_pyobject(self, arg, code):

2384 old_type = arg.hdr_type

2385 func = old_type.to_py_function

2386 if func:

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

2388 arg.entry.cname,

2389 func,

2390 arg.hdr_cname,

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

2392 code.put_var_gotref(arg.entry)

2393 else:

2394 error(arg.pos,

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

2396 % old_type)

2397

2398 def generate_argument_type_tests(self, code):

2399 # Generate type tests for args whose signature

2400 # type is PyObject * and whose declared type is

2401 # a subtype thereof.

2402 for arg in self.args:

2403 if arg.needs_type_test:

2404 self.generate_arg_type_test(arg, code)

2405

2406 def generate_arg_type_test(self, arg, code):

2407 # Generate type test for one argument.

2408 if arg.type.typeobj_is_available():

2409 typeptr_cname = arg.type.typeptr_cname

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

2411 code.putln(

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

2413 arg_code,

2414 typeptr_cname,

2415 not arg.not_none,

2416 arg.name,

2417 arg.type.is_builtin_type,

2418 code.error_goto(arg.pos)))

2419 else:

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

2421 "without type object name specification")

2422

2423 def error_value(self):

2424 return self.entry.signature.error_value

2425

2426 def caller_will_check_exceptions(self):

2427 return 1

2428

2429 class OverrideCheckNode(StatNode):

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

2431 # is overriden.

2432 #

2433 # py_func

2434 #

2435 # args

2436 # func_temp

2437 # body

2438

2439 child_attrs = ['body']

2440

2441 body = None

2442

2443 def analyse_expressions(self, env):

2444 self.args = env.arg_entries

2445 if self.py_func.is_module_scope:

2446 first_arg = 0

2447 else:

2448 first_arg = 1

2449 import ExprNodes

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

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

2452 call_node = ExprNodes.SimpleCallNode(self.pos,

2453 function=self.func_node,

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

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

2456 self.body.analyse_expressions(env)

2457

2458 def generate_execution_code(self, code):

2459 # Check to see if we are an extension type

2460 if self.py_func.is_module_scope:

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

2462 else:

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

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

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

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

2467 if self.py_func.is_module_scope:

2468 code.putln("else {")

2469 else:

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

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

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

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

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

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

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

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

2478 self.body.generate_execution_code(code)

2479 code.putln('}')

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

2481 code.putln("}")

2482

2483 class ClassDefNode(StatNode, BlockNode):

2484 pass

2485

2486 class PyClassDefNode(ClassDefNode):

2487 # A Python class definition.

2488 #

2489 # name EncodedString Name of the class

2490 # doc string or None

2491 # body StatNode Attribute definition code

2492 # entry Symtab.Entry

2493 # scope PyClassScope

2494 #

2495 # The following subnodes are constructed internally:

2496 #

2497 # dict DictNode Class dictionary

2498 # classobj ClassNode Class object

2499 # target NameNode Variable to assign class object to

2500

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

2502

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

2504 StatNode.__init__(self, pos)

2505 self.name = name

2506 self.doc = doc

2507 self.body = body

2508 import ExprNodes

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

2510 if self.doc and Options.docstrings:

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

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

2513 else:

2514 doc_node = None

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

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

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

2518

2519 def as_cclass(self):

2520 """

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

2522 """

2523 bases = self.classobj.bases.args

2524 if len(bases) == 0:

2525 base_class_name = None

2526 base_class_module = None

2527 elif len(bases) == 1:

2528 base = bases[0]

2529 path = []

2530 from ExprNodes import AttributeNode, NameNode

2531 while isinstance(base, AttributeNode):

2532 path.insert(0, base.attribute)

2533 base = base.obj

2534 if isinstance(base, NameNode):

2535 path.insert(0, base.name)

2536 base_class_name = path[-1]

2537 if len(path) > 1:

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

2539 else:

2540 base_class_module = None

2541 else:

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

2543 else:

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

2545 return None

2546

2547 return CClassDefNode(self.pos,

2548 visibility = 'private',

2549 module_name = None,

2550 class_name = self.name,

2551 base_class_module = base_class_module,

2552 base_class_name = base_class_name,

2553 body = self.body,

2554 in_pxd = False,

2555 doc = self.doc)

2556

2557 def create_scope(self, env):

2558 genv = env

2559 while env.is_py_class_scope or env.is_c_class_scope:

2560 env = env.outer_scope

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

2562 return cenv

2563

2564 def analyse_declarations(self, env):

2565 self.target.analyse_target_declaration(env)

2566 cenv = self.create_scope(env)

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

2568 self.body.analyse_declarations(cenv)

2569

2570 def analyse_expressions(self, env):

2571 self.dict.analyse_expressions(env)

2572 self.classobj.analyse_expressions(env)

2573 genv = env.global_scope()

2574 cenv = self.scope

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

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

2577 self.body.analyse_expressions(cenv)

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

2579 self.dict.release_temp(env)

2580 #self.classobj.release_temp(env)

2581 #self.target.release_target_temp(env)

2582

2583 def generate_function_definitions(self, env, code):

2584 self.generate_py_string_decls(self.scope, code)

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

2586

2587 def generate_execution_code(self, code):

2588 self.dict.generate_evaluation_code(code)

2589 self.classobj.generate_evaluation_code(code)

2590 self.body.generate_execution_code(code)

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

2592 self.dict.generate_disposal_code(code)

2593 self.dict.free_temps(code)

2594

2595

2596 class CClassDefNode(ClassDefNode):

2597 # An extension type definition.

2598 #

2599 # visibility 'private' or 'public' or 'extern'

2600 # typedef_flag boolean

2601 # api boolean

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

2603 # class_name string Unqualified name of class

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

2605 # base_class_module string or None Module containing the base class

2606 # base_class_name string or None Name of the base class

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

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

2609 # in_pxd boolean Is in a .pxd file

2610 # doc string or None

2611 # body StatNode or None

2612 # entry Symtab.Entry

2613 # base_type PyExtensionType or None

2614 # buffer_defaults_node DictNode or None Declares defaults for a buffer

2615 # buffer_defaults_pos

2616

2617 child_attrs = ["body"]

2618 buffer_defaults_node = None

2619 buffer_defaults_pos = None

2620 typedef_flag = False

2621 api = False

2622 objstruct_name = None

2623 typeobj_name = None

2624

2625 def analyse_declarations(self, env):

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

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

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

2629

2630 import Buffer

2631 if self.buffer_defaults_node:

2632 buffer_defaults = Buffer.analyse_buffer_options(self.buffer_defaults_pos,

2633 env, [], self.buffer_defaults_node,

2634 need_complete=False)

2635 else:

2636 buffer_defaults = None

2637

2638 if env.in_cinclude and not self.objstruct_name:

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

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

2641 self.base_type = None

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

2643 # import the modules for extern classes.

2644 if self.module_name:

2645 self.module = None

2646 for module in env.cimported_modules:

2647 if module.name == self.module_name:

2648 self.module = module

2649 if self.module is None:

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

2651 self.module.has_extern_class = 1

2652 env.add_imported_module(self.module)

2653

2654 if self.base_class_name:

2655 if self.base_class_module:

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

2657 else:

2658 base_class_scope = env

2659 if self.base_class_name == 'object':

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

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

2662 self.base_class_name = None

2663 self.base_class_module = None

2664 base_class_scope = None

2665 if base_class_scope:

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

2667 if base_class_entry:

2668 if not base_class_entry.is_type:

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

2670 elif not base_class_entry.type.is_extension_type:

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

2672 elif not base_class_entry.type.is_complete():

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

2674 else:

2675 self.base_type = base_class_entry.type

2676 has_body = self.body is not None

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

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

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

2680 if not home_scope:

2681 return

2682 else:

2683 home_scope = env

2684

2685 if self.visibility == 'extern':

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

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

2688

2689 self.entry = home_scope.declare_c_class(

2690 name = self.class_name,

2691 pos = self.pos,

2692 defining = has_body and self.in_pxd,

2693 implementing = has_body and not self.in_pxd,

2694 module_name = self.module_name,

2695 base_type = self.base_type,

2696 objstruct_cname = self.objstruct_name,

2697 typeobj_cname = self.typeobj_name,

2698 visibility = self.visibility,

2699 typedef_flag = self.typedef_flag,

2700 api = self.api,

2701 buffer_defaults = buffer_defaults)

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

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

2704 scope = self.entry.type.scope

2705

2706 if self.doc and Options.docstrings:

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

2708

2709 if has_body:

2710 self.body.analyse_declarations(scope)

2711 if self.in_pxd:

2712 scope.defined = 1

2713 else:

2714 scope.implemented = 1

2715 env.allocate_vtable_names(self.entry)

2716

2717 def analyse_expressions(self, env):

2718 if self.body:

2719 scope = self.entry.type.scope

2720 self.body.analyse_expressions(scope)

2721

2722 def generate_function_definitions(self, env, code):

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

2724 if self.body:

2725 self.body.generate_function_definitions(

2726 self.entry.type.scope, code)

2727

2728 def generate_execution_code(self, code):

2729 # This is needed to generate evaluation code for

2730 # default values of method arguments.

2731 if self.body:

2732 self.body.generate_execution_code(code)

2733

2734 def annotate(self, code):

2735 if self.body:

2736 self.body.annotate(code)

2737

2738

2739 class PropertyNode(StatNode):

2740 # Definition of a property in an extension type.

2741 #

2742 # name string

2743 # doc EncodedString or None Doc string

2744 # body StatListNode

2745

2746 child_attrs = ["body"]

2747

2748 def analyse_declarations(self, env):

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

2750 if entry:

2751 if self.doc and Options.docstrings:

2752 doc_entry = env.get_string_const(

2753 self.doc, identifier = False)

2754 entry.doc_cname = doc_entry.cname

2755 self.body.analyse_declarations(entry.scope)

2756

2757 def analyse_expressions(self, env):

2758 self.body.analyse_expressions(env)

2759

2760 def generate_function_definitions(self, env, code):

2761 self.body.generate_function_definitions(env, code)

2762

2763 def generate_execution_code(self, code):

2764 pass

2765

2766 def annotate(self, code):

2767 self.body.annotate(code)

2768

2769

2770 class GlobalNode(StatNode):

2771 # Global variable declaration.

2772 #

2773 # names [string]

2774

2775 child_attrs = []

2776

2777 def analyse_declarations(self, env):

2778 for name in self.names:

2779 env.declare_global(name, self.pos)

2780

2781 def analyse_expressions(self, env):

2782 pass

2783

2784 def generate_execution_code(self, code):

2785 pass

2786

2787

2788 class ExprStatNode(StatNode):

2789 # Expression used as a statement.

2790 #

2791 # expr ExprNode

2792

2793 child_attrs = ["expr"]

2794

2795 def analyse_declarations(self, env):

2796 import ExprNodes

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

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

2799 if func == u'declare':

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

2801 if len(args):

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

2803 for var, type_node in kwds.key_value_pairs:

2804 type = type_node.analyse_as_type(env)

2805 if type is None:

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

2807 else:

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

2809 self.__class__ = PassStatNode

2810

2811 def analyse_expressions(self, env):

2812 self.expr.analyse_expressions(env)

2813 self.expr.release_temp(env)

2814

2815 def generate_execution_code(self, code):

2816 self.expr.generate_evaluation_code(code)

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

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

2819 self.expr.generate_disposal_code(code)

2820 self.expr.free_temps(code)

2821

2822 def annotate(self, code):

2823 self.expr.annotate(code)

2824

2825

2826 class AssignmentNode(StatNode):

2827 # Abstract base class for assignment nodes.

2828 #

2829 # The analyse_expressions and generate_execution_code

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

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

2832 # parallel assignment to be evaluated before assigning

2833 # to any of the left hand sides.

2834

2835 def analyse_expressions(self, env):

2836 self.analyse_types(env)

2837 self.allocate_rhs_temps(env)

2838 self.allocate_lhs_temps(env)

2839

2840 # def analyse_expressions(self, env):

2841 # self.analyse_expressions_1(env)

2842 # self.analyse_expressions_2(env)

2843

2844 def generate_execution_code(self, code):

2845 self.generate_rhs_evaluation_code(code)

2846 self.generate_assignment_code(code)

2847

2848

2849 class SingleAssignmentNode(AssignmentNode):

2850 # The simplest case:

2851 #

2852 # a = b

2853 #

2854 # lhs ExprNode Left hand side

2855 # rhs ExprNode Right hand side

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

2857

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

2859 first = False

2860 declaration_only = False

2861

2862 def analyse_declarations(self, env):

2863 import ExprNodes

2864

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

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

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

2868 if func_name:

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

2870

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

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

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

2874 return

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

2876 if type is None:

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

2878 return

2879 lhs = self.lhs

2880 if func_name == 'declare':

2881 if isinstance(lhs, ExprNodes.NameNode):

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

2883 elif isinstance(lhs, ExprNodes.TupleNode):

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

2885 else:

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

2887 return

2888 for var, pos in vars:

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

2890 if len(args) == 2:

2891 # we have a value

2892 self.rhs = args[1]

2893 else:

2894 self.declaration_only = True

2895 else:

2896 self.declaration_only = True

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

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

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

2900

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

2902 self.declaration_only = True

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

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

2905 return

2906 members = []

2907 for member, type_node in kwds.key_value_pairs:

2908 type = type_node.analyse_as_type(env)

2909 if type is None:

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

2911 else:

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

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

2914 return

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

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

2917 name = self.lhs.name

2918 scope = StructOrUnionScope(name)

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

2920 for member, type, pos in members:

2921 scope.declare_var(member, type, pos)

2922

2923 if self.declaration_only:

2924 return

2925 else:

2926 self.lhs.analyse_target_declaration(env)

2927

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

2929 self.rhs.analyse_types(env)

2930 self.lhs.analyse_target_types(env)

2931 self.lhs.gil_assignment_check(env)

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

2933 if use_temp:

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

2935

2936 def allocate_rhs_temps(self, env):

2937 self.rhs.allocate_temps(env)

2938

2939 def allocate_lhs_temps(self, env):

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

2941 #self.lhs.release_target_temp(env)

2942 #self.rhs.release_temp(env)

2943

2944 def generate_rhs_evaluation_code(self, code):

2945 self.rhs.generate_evaluation_code(code)

2946

2947 def generate_assignment_code(self, code):

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

2949

2950 def annotate(self, code):

2951 self.lhs.annotate(code)

2952 self.rhs.annotate(code)

2953

2954

2955 class CascadedAssignmentNode(AssignmentNode):

2956 # An assignment with multiple left hand sides:

2957 #

2958 # a = b = c

2959 #

2960 # lhs_list [ExprNode] Left hand sides

2961 # rhs ExprNode Right hand sides

2962 #

2963 # Used internally:

2964 #

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

2966

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

2968 coerced_rhs_list = None

2969

2970 def analyse_declarations(self, env):

2971 for lhs in self.lhs_list:

2972 lhs.analyse_target_declaration(env)

2973

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

2975 self.rhs.analyse_types(env)

2976 if use_temp:

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

2978 else:

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

2980 from ExprNodes import CloneNode

2981 self.coerced_rhs_list = []

2982 for lhs in self.lhs_list:

2983 lhs.analyse_target_types(env)

2984 lhs.gil_assignment_check(env)

2985 rhs = CloneNode(self.rhs)

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

2987 self.coerced_rhs_list.append(rhs)

2988

2989 def allocate_rhs_temps(self, env):

2990 self.rhs.allocate_temps(env)

2991

2992 def allocate_lhs_temps(self, env):

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

2994 rhs.allocate_temps(env)

2995 lhs.allocate_target_temps(env, rhs)

2996 #lhs.release_target_temp(env)

2997 #rhs.release_temp(env)

2998 self.rhs.release_temp(env)

2999

3000 def generate_rhs_evaluation_code(self, code):

3001 self.rhs.generate_evaluation_code(code)

3002

3003 def generate_assignment_code(self, code):

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

3005 lhs = self.lhs_list[i]

3006 rhs = self.coerced_rhs_list[i]

3007 rhs.generate_evaluation_code(code)

3008 lhs.generate_assignment_code(rhs, code)

3009 # Assignment has disposed of the cloned RHS

3010 self.rhs.generate_disposal_code(code)

3011 self.rhs.free_temps(code)

3012

3013 def annotate(self, code):

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

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

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

3017 self.rhs.annotate(code)

3018

3019

3020 class ParallelAssignmentNode(AssignmentNode):

3021 # A combined packing/unpacking assignment:

3022 #

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

3024 #

3025 # This has been rearranged by the parser into

3026 #

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

3028 #

3029 # but we must evaluate all the right hand sides

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

3031 #

3032 # stats [AssignmentNode] The constituent assignments

3033

3034 child_attrs = ["stats"]

3035

3036 def analyse_declarations(self, env):

3037 for stat in self.stats:

3038 stat.analyse_declarations(env)

3039

3040 def analyse_expressions(self, env):

3041 for stat in self.stats:

3042 stat.analyse_types(env, use_temp = 1)

3043 stat.allocate_rhs_temps(env)

3044 for stat in self.stats:

3045 stat.allocate_lhs_temps(env)

3046

3047 # def analyse_expressions(self, env):

3048 # for stat in self.stats:

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

3050 # for stat in self.stats:

3051 # stat.analyse_expressions_2(env)

3052

3053 def generate_execution_code(self, code):

3054 for stat in self.stats:

3055 stat.generate_rhs_evaluation_code(code)

3056 for stat in self.stats:

3057 stat.generate_assignment_code(code)

3058

3059 def annotate(self, code):

3060 for stat in self.stats:

3061 stat.annotate(code)

3062

3063

3064 class InPlaceAssignmentNode(AssignmentNode):

3065 # An in place arithmatic operand:

3066 #

3067 # a += b

3068 # a -= b

3069 # ...

3070 #

3071 # lhs ExprNode Left hand side

3072 # rhs ExprNode Right hand side

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

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

3075 #

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

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

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

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

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

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

3082

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

3084 dup = None

3085

3086 def analyse_declarations(self, env):

3087 self.lhs.analyse_target_declaration(env)

3088

3089 def analyse_types(self, env):

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

3091 self.rhs.analyse_types(env)

3092 self.lhs.analyse_target_types(env)

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

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

3095

3096 def allocate_rhs_temps(self, env):

3097 import ExprNodes

3098 if self.lhs.type.is_pyobject:

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

3100 elif self.rhs.type.is_pyobject:

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

3102 if self.lhs.type.is_pyobject:

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

3104 self.result_value.allocate_temps(env)

3105 # if use_temp:

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

3107 self.rhs.allocate_temps(env)

3108 self.dup.allocate_subexpr_temps(env)

3109 self.dup.allocate_temp(env)

3110

3111 def allocate_lhs_temps(self, env):

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

3113 # self.lhs.release_target_temp(env)

3114 self.dup.release_temp(env)

3115 if self.dup.is_temp:

3116 self.dup.release_subexpr_temps(env)

3117 # self.rhs.release_temp(env)

3118 if self.lhs.type.is_pyobject:

3119 self.result_value.release_temp(env)

3120

3121 def generate_execution_code(self, code):

3122 import ExprNodes

3123 self.rhs.generate_evaluation_code(code)

3124 self.dup.generate_subexpr_evaluation_code(code)

3125 if isinstance(self.dup, ExprNodes.NewTempExprNode):

3126 # This is because we're manually messing with subexpr nodes

3127 if self.dup.is_temp:

3128 self.dup.allocate_temp_result(code)

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

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

3131 extra = ", Py_None"

3132 else:

3133 extra = ""

3134 if self.lhs.type.is_pyobject:

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

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

3137 self.dup.generate_result_code(code)

3138 code.putln(

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

3140 self.result_value.result(),

3141 self.py_operation_function(),

3142 self.dup.py_result(),

3143 self.rhs.py_result(),

3144 extra,

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

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

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

3148 self.rhs.generate_disposal_code(code)

3149 self.rhs.free_temps(code)

3150 self.dup.generate_disposal_code(code)

3151 self.dup.free_temps(code)

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

3153 else:

3154 c_op = self.operator

3155 if c_op == "//":

3156 c_op = "/"

3157 elif c_op == "**":

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

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

3160 else:

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

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

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

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

3165 else:

3166 self.dup.generate_result_code(code)

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

3168 self.rhs.generate_disposal_code(code)

3169 self.rhs.free_temps(code)

3170 if self.dup.is_temp:

3171 self.dup.generate_subexpr_disposal_code(code)

3172 self.dup.free_subexpr_temps(code)

3173

3174 def create_dup_node(self, env):

3175 import ExprNodes

3176 self.dup = self.lhs

3177 self.dup.analyse_types(env)

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

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

3180 name = self.dup.name,

3181 is_temp = self.dup.is_temp,

3182 entry = self.dup.entry)

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

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

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

3186 attribute = self.dup.attribute,

3187 is_temp = self.dup.is_temp)

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

3189 if self.lhs.index:

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

3191 else:

3192 index = None

3193 if self.lhs.indices:

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

3195 else:

3196 indices = []

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

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

3199 index = index,

3200 indices = indices,

3201 is_temp = self.dup.is_temp)

3202 else:

3203 assert False

3204 self.lhs = target_lhs

3205 return self.dup

3206

3207 def py_operation_function(self):

3208 return self.py_functions[self.operator]

3209

3210 py_functions = {

3211 "|": "PyNumber_InPlaceOr",

3212 "^": "PyNumber_InPlaceXor",

3213 "&": "PyNumber_InPlaceAnd",

3214 "+": "PyNumber_InPlaceAdd",

3215 "-": "PyNumber_InPlaceSubtract",

3216 "*": "PyNumber_InPlaceMultiply",

3217 "/": "PyNumber_InPlaceDivide",

3218 "%": "PyNumber_InPlaceRemainder",

3219 "<<": "PyNumber_InPlaceLshift",

3220 ">>": "PyNumber_InPlaceRshift",

3221 "**": "PyNumber_InPlacePower",

3222 "//": "PyNumber_InPlaceFloorDivide",

3223 }

3224

3225 def annotate(self, code):

3226 self.lhs.annotate(code)

3227 self.rhs.annotate(code)

3228 self.dup.annotate(code)

3229

3230

3231 class PrintStatNode(StatNode):

3232 # print statement

3233 #

3234 # arg_tuple TupleNode

3235 # append_newline boolean

3236

3237 child_attrs = ["arg_tuple"]

3238

3239 def analyse_expressions(self, env):

3240 self.arg_tuple.analyse_expressions(env)

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

3242 self.arg_tuple.release_temp(env)

3243 env.use_utility_code(printing_utility_code)

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

3245 env.use_utility_code(printing_one_utility_code)

3246 self.gil_check(env)

3247

3248 gil_message = "Python print statement"

3249

3250 def generate_execution_code(self, code):

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

3252 arg = self.arg_tuple.args[0]

3253 arg.generate_evaluation_code(code)

3254

3255 code.putln(

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

3257 arg.py_result(),

3258 code.error_goto(self.pos)))

3259 arg.generate_disposal_code(code)

3260 arg.free_temps(code)

3261 else:

3262 self.arg_tuple.generate_evaluation_code(code)

3263 code.putln(

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

3265 self.arg_tuple.py_result(),

3266 self.append_newline,

3267 code.error_goto(self.pos)))

3268 self.arg_tuple.generate_disposal_code(code)

3269 self.arg_tuple.free_temps(code)

3270

3271 def annotate(self, code):

3272 self.arg_tuple.annotate(code)

3273

3274

3275 class ExecStatNode(StatNode):

3276 # exec statement

3277 #

3278 # args [ExprNode]

3279

3280 child_attrs = ["args"]

3281

3282 def analyse_expressions(self, env):

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

3284 arg.analyse_expressions(env)

3285 arg = arg.coerce_to_pyobject(env)

3286 arg.release_temp(env)

3287 self.args[i] = arg

3288 self.temp_result = env.allocate_temp_pyobject()

3289 env.release_temp(self.temp_result)

3290 env.use_utility_code(Builtin.pyexec_utility_code)

3291 self.gil_check(env)

3292

3293 gil_message = "Python exec statement"

3294

3295 def generate_execution_code(self, code):

3296 args = []

3297 for arg in self.args:

3298 arg.generate_evaluation_code(code)

3299 args.append( arg.py_result() )

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

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

3302 (self.temp_result,) + args))

3303 for arg in self.args:

3304 arg.generate_disposal_code(code)

3305 arg.free_temps(code)

3306 code.putln(

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

3308 code.put_gotref(self.temp_result)

3309 code.put_decref_clear(self.temp_result, py_object_type)

3310

3311 def annotate(self, code):

3312 for arg in self.args:

3313 arg.annotate(code)

3314

3315

3316 class DelStatNode(StatNode):

3317 # del statement

3318 #

3319 # args [ExprNode]

3320

3321 child_attrs = ["args"]

3322

3323 def analyse_declarations(self, env):

3324 for arg in self.args:

3325 arg.analyse_target_declaration(env)

3326

3327 def analyse_expressions(self, env):

3328 for arg in self.args:

3329 arg.analyse_target_expression(env, None)

3330 if arg.type.is_pyobject:

3331 self.gil_check(env)

3332 else:

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

3334 #arg.release_target_temp(env)

3335

3336 gil_message = "Deleting Python object"

3337

3338 def generate_execution_code(self, code):

3339 for arg in self.args:

3340 if arg.type.is_pyobject:

3341 arg.generate_deletion_code(code)

3342 # else error reported earlier

3343

3344 def annotate(self, code):

3345 for arg in self.args:

3346 arg.annotate(code)

3347

3348

3349 class PassStatNode(StatNode):

3350 # pass statement

3351

3352 child_attrs = []

3353

3354 def analyse_expressions(self, env):

3355 pass

3356

3357 def generate_execution_code(self, code):

3358 pass

3359

3360

3361 class BreakStatNode(StatNode):

3362

3363 child_attrs = []

3364

3365 def analyse_expressions(self, env):

3366 pass

3367

3368 def generate_execution_code(self, code):

3369 if not code.break_label:

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

3371 else:

3372 code.put_goto(code.break_label)

3373

3374

3375 class ContinueStatNode(StatNode):

3376

3377 child_attrs = []

3378

3379 def analyse_expressions(self, env):

3380 pass

3381

3382 def generate_execution_code(self, code):

3383 if code.funcstate.in_try_finally:

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

3385 elif not code.continue_label:

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

3387 else:

3388 code.put_goto(code.continue_label)

3389

3390

3391 class ReturnStatNode(StatNode):

3392 # return statement

3393 #

3394 # value ExprNode or None

3395 # return_type PyrexType

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

3397

3398 child_attrs = ["value"]

3399

3400 def analyse_expressions(self, env):

3401 return_type = env.return_type

3402 self.return_type = return_type

3403 self.temps_in_use = env.temps_in_use()

3404 if not return_type:

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

3406 return

3407 if self.value:

3408 self.value.analyse_types(env)

3409 if return_type.is_void or return_type.is_returncode:

3410 error(self.value.pos,

3411 "Return with value in void function")

3412 else:

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

3414 self.value.allocate_temps(env)

3415 self.value.release_temp(env)

3416 else:

3417 if (not return_type.is_void

3418 and not return_type.is_pyobject

3419 and not return_type.is_returncode):

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

3421 if return_type.is_pyobject:

3422 self.gil_check(env)

3423

3424 gil_message = "Returning Python object"

3425

3426 def generate_execution_code(self, code):

3427 code.mark_pos(self.pos)

3428 if not self.return_type:

3429 # error reported earlier

3430 return

3431 if self.return_type.is_pyobject:

3432 code.put_xdecref(Naming.retval_cname,

3433 self.return_type)

3434 if self.value:

3435 self.value.generate_evaluation_code(code)

3436 self.value.make_owned_reference(code)

3437 code.putln(

3438 "%s = %s;" % (

3439 Naming.retval_cname,

3440 self.value.result_as(self.return_type)))

3441 self.value.generate_post_assignment_code(code)

3442 self.value.free_temps(code)

3443 else:

3444 if self.return_type.is_pyobject:

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

3446 elif self.return_type.is_returncode:

3447 code.putln(

3448 "%s = %s;" % (

3449 Naming.retval_cname,

3450 self.return_type.default_value))

3451 # free temps the old way

3452 for entry in self.temps_in_use:

3453 code.put_var_decref_clear(entry)

3454 # free temps the new way

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

3456 code.put_decref_clear(cname, type)

3457 #code.putln(

3458 # "goto %s;" %

3459 # code.return_label)

3460 code.put_goto(code.return_label)

3461

3462 def annotate(self, code):

3463 if self.value:

3464 self.value.annotate(code)

3465

3466

3467 class RaiseStatNode(StatNode):

3468 # raise statement

3469 #

3470 # exc_type ExprNode or None

3471 # exc_value ExprNode or None

3472 # exc_tb ExprNode or None

3473

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

3475

3476 def analyse_expressions(self, env):

3477 if self.exc_type:

3478 self.exc_type.analyse_types(env)

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

3480 self.exc_type.allocate_temps(env)

3481 if self.exc_value:

3482 self.exc_value.analyse_types(env)

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

3484 self.exc_value.allocate_temps(env)

3485 if self.exc_tb:

3486 self.exc_tb.analyse_types(env)

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

3488 self.exc_tb.allocate_temps(env)

3489 if self.exc_type:

3490 self.exc_type.release_temp(env)

3491 if self.exc_value:

3492 self.exc_value.release_temp(env)

3493 if self.exc_tb:

3494 self.exc_tb.release_temp(env)

3495 env.use_utility_code(raise_utility_code)

3496 env.use_utility_code(restore_exception_utility_code)

3497 self.gil_check(env)

3498

3499 gil_message = "Raising exception"

3500

3501 def generate_execution_code(self, code):

3502 if self.exc_type:

3503 self.exc_type.generate_evaluation_code(code)

3504 type_code = self.exc_type.py_result()

3505 else:

3506 type_code = "0"

3507 if self.exc_value:

3508 self.exc_value.generate_evaluation_code(code)

3509 value_code = self.exc_value.py_result()

3510 else:

3511 value_code = "0"

3512 if self.exc_tb:

3513 self.exc_tb.generate_evaluation_code(code)

3514 tb_code = self.exc_tb.py_result()

3515 else:

3516 tb_code = "0"

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

3518 code.putln(

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

3520 type_code,

3521 value_code,

3522 tb_code))

3523 else:

3524 code.putln(

3525 "__Pyx_ReRaise();")

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

3527 if obj:

3528 obj.generate_disposal_code(code)

3529 obj.free_temps(code)

3530 code.putln(

3531 code.error_goto(self.pos))

3532

3533 def annotate(self, code):

3534 if self.exc_type:

3535 self.exc_type.annotate(code)

3536 if self.exc_value:

3537 self.exc_value.annotate(code)

3538 if self.exc_tb:

3539 self.exc_tb.annotate(code)

3540

3541

3542 class ReraiseStatNode(StatNode):

3543

3544 child_attrs = []

3545

3546 def analyse_expressions(self, env):

3547 self.gil_check(env)

3548 env.use_utility_code(raise_utility_code)

3549 env.use_utility_code(restore_exception_utility_code)

3550

3551 gil_message = "Raising exception"

3552

3553 def generate_execution_code(self, code):

3554 vars = code.funcstate.exc_vars

3555 if vars:

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

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

3558 else:

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

3560

3561

3562 class AssertStatNode(StatNode):

3563 # assert statement

3564 #

3565 # cond ExprNode

3566 # value ExprNode or None

3567

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

3569

3570 def analyse_expressions(self, env):

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

3572 if self.value:

3573 self.value.analyse_types(env)

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

3575 self.value.allocate_temps(env)

3576 self.cond.release_temp(env)

3577 if self.value:

3578 self.value.release_temp(env)

3579 self.gil_check(env)

3580 #env.recycle_pending_temps() # TEMPORARY

3581

3582 gil_message = "Raising exception"

3583

3584 def generate_execution_code(self, code):

3585 code.putln("#ifndef PYREX_WITHOUT_ASSERTIONS")

3586 self.cond.generate_evaluation_code(code)

3587 code.putln(

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

3589 self.cond.result())

3590 if self.value:

3591 self.value.generate_evaluation_code(code)

3592 code.putln(

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

3594 self.value.py_result())

3595 self.value.generate_disposal_code(code)

3596 self.value.free_temps(code)

3597 else:

3598 code.putln(

3599 "PyErr_SetNone(PyExc_AssertionError);")

3600 code.putln(

3601 code.error_goto(self.pos))

3602 code.putln(

3603 "}")

3604 self.cond.generate_disposal_code(code)

3605 self.cond.free_temps(code)

3606 code.putln("#endif")

3607

3608 def annotate(self, code):

3609 self.cond.annotate(code)

3610 if self.value:

3611 self.value.annotate(code)

3612

3613

3614 class IfStatNode(StatNode):

3615 # if statement

3616 #

3617 # if_clauses [IfClauseNode]

3618 # else_clause StatNode or None

3619

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

3621

3622 def analyse_control_flow(self, env):

3623 env.start_branching(self.pos)

3624 for if_clause in self.if_clauses:

3625 if_clause.analyse_control_flow(env)

3626 env.next_branch(if_clause.end_pos())

3627 if self.else_clause:

3628 self.else_clause.analyse_control_flow(env)

3629 env.finish_branching(self.end_pos())

3630

3631 def analyse_declarations(self, env):

3632 for if_clause in self.if_clauses:

3633 if_clause.analyse_declarations(env)

3634 if self.else_clause:

3635 self.else_clause.analyse_declarations(env)

3636

3637 def analyse_expressions(self, env):

3638 for if_clause in self.if_clauses:

3639 if_clause.analyse_expressions(env)

3640 if self.else_clause:

3641 self.else_clause.analyse_expressions(env)

3642

3643 def generate_execution_code(self, code):

3644 code.mark_pos(self.pos)

3645 end_label = code.new_label()

3646 for if_clause in self.if_clauses:

3647 if_clause.generate_execution_code(code, end_label)

3648 if self.else_clause:

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

3650 self.else_clause.generate_execution_code(code)

3651 code.putln("}")

3652 code.put_label(end_label)

3653

3654 def annotate(self, code):

3655 for if_clause in self.if_clauses:

3656 if_clause.annotate(code)

3657 if self.else_clause:

3658 self.else_clause.annotate(code)

3659

3660

3661 class IfClauseNode(Node):

3662 # if or elif clause in an if statement

3663 #

3664 # condition ExprNode

3665 # body StatNode

3666

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

3668

3669 def analyse_control_flow(self, env):

3670 self.body.analyse_control_flow(env)

3671

3672 def analyse_declarations(self, env):

3673 self.condition.analyse_declarations(env)

3674 self.body.analyse_declarations(env)

3675

3676 def analyse_expressions(self, env):

3677 self.condition = \

3678 self.condition.analyse_temp_boolean_expression(env)

3679 self.condition.release_temp(env)

3680 self.body.analyse_expressions(env)

3681

3682 def generate_execution_code(self, code, end_label):

3683 self.condition.generate_evaluation_code(code)

3684 code.putln(

3685 "if (%s) {" %

3686 self.condition.result())

3687 self.condition.generate_disposal_code(code)

3688 self.condition.free_temps(code)

3689 self.body.generate_execution_code(code)

3690 #code.putln(

3691 # "goto %s;" %

3692 # end_label)

3693 code.put_goto(end_label)

3694 code.putln("}")

3695

3696 def annotate(self, code):

3697 self.condition.annotate(code)

3698 self.body.annotate(code)

3699

3700

3701 class SwitchCaseNode(StatNode):

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

3703 #

3704 # conditions [ExprNode]

3705 # body StatNode

3706

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

3708

3709 def generate_execution_code(self, code):

3710 for cond in self.conditions:

3711 code.mark_pos(cond.pos)

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

3713 self.body.generate_execution_code(code)

3714 code.putln("break;")

3715

3716 def annotate(self, code):

3717 for cond in self.conditions:

3718 cond.annotate(code)

3719 self.body.annotate(code)

3720

3721 class SwitchStatNode(StatNode):

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

3723 #

3724 # test ExprNode

3725 # cases [SwitchCaseNode]

3726 # else_clause StatNode or None

3727

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

3729

3730 def generate_execution_code(self, code):

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

3732 for case in self.cases:

3733 case.generate_execution_code(code)

3734 if self.else_clause is not None:

3735 code.putln("default:")

3736 self.else_clause.generate_execution_code(code)

3737 code.putln("break;")

3738 code.putln("}")

3739

3740 def annotate(self, code):

3741 self.test.annotate(code)

3742 for case in self.cases:

3743 case.annotate(code)

3744 if self.else_clause is not None:

3745 self.else_clause.annotate(code)

3746

3747 class LoopNode(object):

3748

3749 def analyse_control_flow(self, env):

3750 env.start_branching(self.pos)

3751 self.body.analyse_control_flow(env)

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

3753 if self.else_clause:

3754 self.else_clause.analyse_control_flow(env)

3755 env.finish_branching(self.end_pos())

3756

3757

3758 class WhileStatNode(LoopNode, StatNode):

3759 # while statement

3760 #

3761 # condition ExprNode

3762 # body StatNode

3763 # else_clause StatNode

3764

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

3766

3767 def analyse_declarations(self, env):

3768 self.body.analyse_declarations(env)

3769 if self.else_clause:

3770 self.else_clause.analyse_declarations(env)

3771

3772 def analyse_expressions(self, env):

3773 self.condition = \

3774 self.condition.analyse_temp_boolean_expression(env)

3775 self.condition.release_temp(env)

3776 #env.recycle_pending_temps() # TEMPORARY

3777 self.body.analyse_expressions(env)

3778 if self.else_clause:

3779 self.else_clause.analyse_expressions(env)

3780

3781 def generate_execution_code(self, code):

3782 old_loop_labels = code.new_loop_labels()

3783 code.putln(

3784 "while (1) {")

3785 self.condition.generate_evaluation_code(code)

3786 self.condition.generate_disposal_code(code)

3787 code.putln(

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

3789 self.condition.result())

3790 self.condition.free_temps(code)

3791 self.body.generate_execution_code(code)

3792 code.put_label(code.continue_label)

3793 code.putln("}")

3794 break_label = code.break_label

3795 code.set_loop_labels(old_loop_labels)

3796 if self.else_clause:

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

3798 self.else_clause.generate_execution_code(code)

3799 code.putln("}")

3800 code.put_label(break_label)

3801

3802 def annotate(self, code):

3803 self.condition.annotate(code)

3804 self.body.annotate(code)

3805 if self.else_clause:

3806 self.else_clause.annotate(code)

3807

3808

3809 def ForStatNode(pos, **kw):

3810 if 'iterator' in kw:

3811 return ForInStatNode(pos, **kw)

3812 else:

3813 return ForFromStatNode(pos, **kw)

3814

3815 class ForInStatNode(LoopNode, StatNode):

3816 # for statement

3817 #

3818 # target ExprNode

3819 # iterator IteratorNode

3820 # body StatNode

3821 # else_clause StatNode

3822 # item NextNode used internally

3823

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

3825 item = None

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.iterator.analyse_expressions(env)

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

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

3839 self.item.allocate_temps(env)

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

3841 #self.item.release_temp(env)

3842 #self.target.release_target_temp(env)

3843 self.body.analyse_expressions(env)

3844 if self.else_clause:

3845 self.else_clause.analyse_expressions(env)

3846 self.iterator.release_temp(env)

3847

3848 def generate_execution_code(self, code):

3849 old_loop_labels = code.new_loop_labels()

3850 self.iterator.allocate_counter_temp(code)

3851 self.iterator.generate_evaluation_code(code)

3852 code.putln(

3853 "for (;;) {")

3854 self.item.generate_evaluation_code(code)

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

3856 self.body.generate_execution_code(code)

3857 code.put_label(code.continue_label)

3858 code.putln(

3859 "}")

3860 break_label = code.break_label

3861 code.set_loop_labels(old_loop_labels)

3862 if self.else_clause:

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

3864 self.else_clause.generate_execution_code(code)

3865 code.putln("}")

3866 code.put_label(break_label)

3867 self.iterator.release_counter_temp(code)

3868 self.iterator.generate_disposal_code(code)

3869 self.iterator.free_temps(code)

3870

3871 def annotate(self, code):

3872 self.target.annotate(code)

3873 self.iterator.annotate(code)

3874 self.body.annotate(code)

3875 if self.else_clause:

3876 self.else_clause.annotate(code)

3877 self.item.annotate(code)

3878

3879

3880 class ForFromStatNode(LoopNode, StatNode):

3881 # for name from expr rel name rel expr

3882 #

3883 # target NameNode

3884 # bound1 ExprNode

3885 # relation1 string

3886 # relation2 string

3887 # bound2 ExprNode

3888 # step ExprNode or None

3889 # body StatNode

3890 # else_clause StatNode or None

3891 #

3892 # Used internally:

3893 #

3894 # from_range bool

3895 # is_py_target bool

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

3897 # py_loopvar_node PyTempNode or None

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

3899

3900 is_py_target = False

3901 loopvar_node = None

3902 py_loopvar_node = None

3903 from_range = False

3904

3905 def analyse_declarations(self, env):

3906 self.target.analyse_target_declaration(env)

3907 self.body.analyse_declarations(env)

3908 if self.else_clause:

3909 self.else_clause.analyse_declarations(env)

3910

3911 def analyse_expressions(self, env):

3912 import ExprNodes

3913 self.target.analyse_target_types(env)

3914 self.bound1.analyse_types(env)

3915 self.bound2.analyse_types(env)

3916 if self.step is not None:

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

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

3919 self.step.analyse_types(env)

3920

3921 target_type = self.target.type

3922 if self.target.type.is_numeric:

3923 loop_type = self.target.type

3924 else:

3925 loop_type = PyrexTypes.c_int_type

3926 if not self.bound1.type.is_pyobject:

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

3928 if not self.bound2.type.is_pyobject:

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

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

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

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

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

3934 if not self.bound2.is_literal:

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

3936 if self.step is not None:

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

3938 if not self.step.is_literal:

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

3940

3941 target_type = self.target.type

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

3943 error(self.target.pos,

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

3945 if target_type.is_numeric:

3946 self.is_py_target = False

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

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

3949 self.loopvar_node = self.target

3950 self.py_loopvar_node = None

3951 else:

3952 self.is_py_target = True

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

3954 c_loopvar_node.allocate_temps(env)

3955 self.loopvar_node = c_loopvar_node

3956 self.py_loopvar_node = \

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

3958 self.bound1.allocate_temps(env)

3959 self.bound2.allocate_temps(env)

3960 if self.step is not None:

3961 self.step.allocate_temps(env)

3962 if self.is_py_target:

3963 self.py_loopvar_node.allocate_temps(env)

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

3965 #self.target.release_target_temp(env)

3966 #self.py_loopvar_node.release_temp(env)

3967 self.body.analyse_expressions(env)

3968 if self.is_py_target:

3969 c_loopvar_node.release_temp(env)

3970 if self.else_clause:

3971 self.else_clause.analyse_expressions(env)