1 #

2 # Pyrex - Parse tree nodes

3 #

4

5 import sys, os, time, copy

6

7 try:

8 set

9 except NameError:

10 # Python 2.3

11 from sets import Set as set

12

13 import Code

14 import Builtin

15 from Errors import error, warning, InternalError

16 import Naming

17 import PyrexTypes

18 import TypeSlots

19 from PyrexTypes import py_object_type, error_type, CFuncType

20 from Symtab import ModuleScope, LocalScope, GeneratorLocalScope, \

21 StructOrUnionScope, PyClassScope, CClassScope

22 from Cython.Utils import open_new_file, replace_suffix

23 from Code import UtilityCode

24 from StringEncoding import EncodedString, escape_byte_string, split_docstring

25 import Options

26 import ControlFlow

27 import DebugFlags

28

29 absolute_path_length = 0

30

31 def relative_position(pos):

32 """

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

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

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

36 e.g,. when distributing binaries.)

37

38 INPUT:

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

40

41 OUTPUT:

42 relative filename

43 line number

44

45 AUTHOR: William Stein

46 """

47 global absolute_path_length

48 if absolute_path_length==0:

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

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

51

52 def embed_position(pos, docstring):

53 if not Options.embed_pos_in_docstring:

54 return docstring

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

56 if docstring is None:

57 # unicode string

58 return EncodedString(pos_line)

59

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

61 # otherwise make the docstring a unicode string

62 encoding = docstring.encoding

63 if encoding is not None:

64 try:

65 encoded_bytes = pos_line.encode(encoding)

66 except UnicodeEncodeError:

67 encoding = None

68

69 if not docstring:

70 # reuse the string encoding of the original docstring

71 doc = EncodedString(pos_line)

72 else:

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

74 doc.encoding = encoding

75 return doc

76

77

78 from Code import CCodeWriter

79 from types import FunctionType

80

81 def write_func_call(func):

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

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

84 # here we annotate the code with this function call

85 # but only if new code is generated

86 node, code = args[:2]

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

88 ' ' * code.call_level,

89 node.__class__.__name__,

90 func.__name__,

91 node.pos[1:])

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

93 code.putln(marker)

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

95 code.call_level += 4

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

97 code.call_level -= 4

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

99 code.buffer.stream.seek(pristine)

100 else:

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

102 code.putln(marker)

103 return res

104 else:

105 return func(*args, **kwds)

106 return f

107

108 class VerboseCodeWriter(type):

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

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

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

112 attrs = dict(attrs)

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

114 if isinstance(m, FunctionType):

115 attrs[mname] = write_func_call(m)

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

117

118

119 class Node(object):

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

121 # is_name boolean Is a NameNode

122 # is_literal boolean Is a ConstNode

123

124 if DebugFlags.debug_trace_code_generation:

125 __metaclass__ = VerboseCodeWriter

126

127 is_name = 0

128 is_literal = 0

129 temps = None

130

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

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

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

134 child_attrs = None

135

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

137 self.pos = pos

138 self.__dict__.update(kw)

139

140 gil_message = "Operation"

141

142 nogil_check = None

143

144 def gil_error(self, env=None):

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

146

147 def clone_node(self):

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

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

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

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

152 level in the tree."""

153 result = copy.copy(self)

154 for attrname in result.child_attrs:

155 value = getattr(result, attrname)

156 if isinstance(value, list):

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

158 return result

159

160

161 #

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

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

164 #

165 # (0) analyse_control_flow

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

167 # queried.

168 #

169 # (1) analyse_declarations

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

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

172 # to an otherwise undeclared name).

173 #

174 # (2) analyse_expressions

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

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

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

178 # Allocate temporary locals for intermediate results. Fill

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

180 # fragment.

181 #

182 # (3) generate_code

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

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

185 # functions.

186 #

187

188 def analyse_control_flow(self, env):

189 pass

190

191 def analyse_declarations(self, env):

192 pass

193

194 def analyse_expressions(self, env):

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

196 self.__class__.__name__)

197

198 def generate_code(self, code):

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

200 self.__class__.__name__)

201

202 def annotate(self, code):

203 # mro does the wrong thing

204 if isinstance(self, BlockNode):

205 self.body.annotate(code)

206

207 def end_pos(self):

208 try:

209 return self._end_pos

210 except AttributeError:

211 pos = self.pos

212 if not self.child_attrs:

213 self._end_pos = pos

214 return pos

215 for attr in self.child_attrs:

216 child = getattr(self, attr)

217 # Sometimes lists, sometimes nodes

218 if child is None:

219 pass

220 elif isinstance(child, list):

221 for c in child:

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

223 else:

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

225 self._end_pos = pos

226 return pos

227

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

229 if cutoff == 0:

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

231 if encountered is None:

232 encountered = set()

233 if id(self) in encountered:

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

235 encountered.add(id(self))

236

237 def dump_child(x, level):

238 if isinstance(x, Node):

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

240 elif isinstance(x, list):

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

242 else:

243 return repr(x)

244

245

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

247 if len(attrs) == 0:

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

249 else:

250 indent = " " * level

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

252 for key, value in attrs:

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

254 res += "%s>" % indent

255 return res

256

257 class CompilerDirectivesNode(Node):

258 """

259 Sets compiler directives for the children nodes

260 """

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

262 # *all* possible directives.

263 # body Node

264 child_attrs = ["body"]

265

266 def analyse_control_flow(self, env):

267 old = env.directives

268 env.directives = self.directives

269 self.body.analyse_control_flow(env)

270 env.directives = old

271

272 def analyse_declarations(self, env):

273 old = env.directives

274 env.directives = self.directives

275 self.body.analyse_declarations(env)

276 env.directives = old

277

278 def analyse_expressions(self, env):

279 old = env.directives

280 env.directives = self.directives

281 self.body.analyse_expressions(env)

282 env.directives = old

283

284 def generate_function_definitions(self, env, code):

285 env_old = env.directives

286 code_old = code.globalstate.directives

287 code.globalstate.directives = self.directives

288 self.body.generate_function_definitions(env, code)

289 env.directives = env_old

290 code.globalstate.directives = code_old

291

292 def generate_execution_code(self, code):

293 old = code.globalstate.directives

294 code.globalstate.directives = self.directives

295 self.body.generate_execution_code(code)

296 code.globalstate.directives = old

297

298 def annotate(self, code):

299 old = code.globalstate.directives

300 code.globalstate.directives = self.directives

301 self.body.annotate(code)

302 code.globalstate.directives = old

303

304 class BlockNode(object):

305 # Mixin class for nodes representing a declaration block.

306

307 def generate_cached_builtins_decls(self, env, code):

308 entries = env.global_scope().undeclared_cached_builtins

309 for entry in entries:

310 code.globalstate.add_cached_builtin_decl(entry)

311 del entries[:]

312

313

314 class StatListNode(Node):

315 # stats a list of StatNode

316

317 child_attrs = ["stats"]

318

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

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

321 return node # No node-specific analysis necesarry

322 create_analysed = staticmethod(create_analysed)

323

324 def analyse_control_flow(self, env):

325 for stat in self.stats:

326 stat.analyse_control_flow(env)

327

328 def analyse_declarations(self, env):

329 #print "StatListNode.analyse_declarations" ###

330 for stat in self.stats:

331 stat.analyse_declarations(env)

332

333 def analyse_expressions(self, env):

334 #print "StatListNode.analyse_expressions" ###

335 for stat in self.stats:

336 stat.analyse_expressions(env)

337

338 def generate_function_definitions(self, env, code):

339 #print "StatListNode.generate_function_definitions" ###

340 for stat in self.stats:

341 stat.generate_function_definitions(env, code)

342

343 def generate_execution_code(self, code):

344 #print "StatListNode.generate_execution_code" ###

345 for stat in self.stats:

346 code.mark_pos(stat.pos)

347 stat.generate_execution_code(code)

348

349 def annotate(self, code):

350 for stat in self.stats:

351 stat.annotate(code)

352

353

354 class StatNode(Node):

355 #

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

357 #

358 # (1) generate_function_definitions

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

360 # unions, enums and functions defined in the current

361 # scope-block.

362 #

363 # (2) generate_execution_code

364 # Emit C code for executable statements.

365 #

366

367 def generate_function_definitions(self, env, code):

368 pass

369

370 def generate_execution_code(self, code):

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

372 self.__class__.__name__)

373

374

375 class CDefExternNode(StatNode):

376 # include_file string or None

377 # body StatNode

378

379 child_attrs = ["body"]

380

381 def analyse_declarations(self, env):

382 if self.include_file:

383 env.add_include_file(self.include_file)

384 old_cinclude_flag = env.in_cinclude

385 env.in_cinclude = 1

386 self.body.analyse_declarations(env)

387 env.in_cinclude = old_cinclude_flag

388

389 def analyse_expressions(self, env):

390 pass

391

392 def generate_execution_code(self, code):

393 pass

394

395 def annotate(self, code):

396 self.body.annotate(code)

397

398

399 class CDeclaratorNode(Node):

400 # Part of a C declaration.

401 #

402 # Processing during analyse_declarations phase:

403 #

404 # analyse

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

406 # CNameDeclaratorNode of the name being declared

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

408 #

409 # calling_convention string Calling convention of CFuncDeclaratorNode

410 # for which this is a base

411

412 child_attrs = []

413

414 calling_convention = ""

415

416

417 class CNameDeclaratorNode(CDeclaratorNode):

418 # name string The Pyrex name being declared

419 # cname string or None C name, if specified

420 # default ExprNode or None the value assigned on declaration

421

422 child_attrs = ['default']

423

424 default = None

425

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

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

428 # May have mistaken the name for the type.

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

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

431 elif base_type.is_void:

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

433 else:

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

435 base_type = py_object_type

436 self.type = base_type

437 return self, base_type

438

439 class CPtrDeclaratorNode(CDeclaratorNode):

440 # base CDeclaratorNode

441

442 child_attrs = ["base"]

443

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

445 if base_type.is_pyobject:

446 error(self.pos,

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

448 ptr_type = PyrexTypes.c_ptr_type(base_type)

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

450

451 class CArrayDeclaratorNode(CDeclaratorNode):

452 # base CDeclaratorNode

453 # dimension ExprNode

454

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

456

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

458 if self.dimension:

459 self.dimension.analyse_const_expression(env)

460 if not self.dimension.type.is_int:

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

462 size = self.dimension.get_constant_c_result_code()

463 if size is not None:

464 try:

465 size = int(size)

466 except ValueError:

467 # runtime constant?

468 pass

469 else:

470 size = None

471 if not base_type.is_complete():

472 error(self.pos,

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

474 if base_type.is_pyobject:

475 error(self.pos,

476 "Array element cannot be a Python object")

477 if base_type.is_cfunction:

478 error(self.pos,

479 "Array element cannot be a function")

480 array_type = PyrexTypes.c_array_type(base_type, size)

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

482

483

484 class CFuncDeclaratorNode(CDeclaratorNode):

485 # base CDeclaratorNode

486 # args [CArgDeclNode]

487 # has_varargs boolean

488 # exception_value ConstNode

489 # exception_check boolean True if PyErr_Occurred check needed

490 # nogil boolean Can be called without gil

491 # with_gil boolean Acquire gil around function body

492

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

494

495 overridable = 0

496 optional_arg_count = 0

497

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

499 if nonempty:

500 nonempty -= 1

501 func_type_args = []

502 for arg_node in self.args:

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

504 name = name_declarator.name

505 if name_declarator.cname:

506 error(self.pos,

507 "Function argument cannot have C name specification")

508 # Turn *[] argument into **

509 if type.is_array:

510 type = PyrexTypes.c_ptr_type(type.base_type)

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

512 if type.is_void:

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

514 func_type_args.append(

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

516 if arg_node.default:

517 self.optional_arg_count += 1

518 elif self.optional_arg_count:

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

520

521 if self.optional_arg_count:

522 scope = StructOrUnionScope()

523 arg_count_member = '%sn' % Naming.pyrex_prefix

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

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

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

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

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

529 kind = 'struct',

530 scope = scope,

531 typedef_flag = 0,

532 pos = self.pos,

533 cname = struct_cname)

534 self.op_args_struct.defined_in_pxd = 1

535 self.op_args_struct.used = 1

536

537 exc_val = None

538 exc_check = 0

539 if self.exception_check == '+':

540 env.add_include_file('stdexcept')

541 if return_type.is_pyobject \

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

543 and self.exception_check != '+':

544 error(self.pos,

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

546 else:

547 if self.exception_value:

548 self.exception_value.analyse_const_expression(env)

549 if self.exception_check == '+':

550 self.exception_value.analyse_types(env)

551 exc_val_type = self.exception_value.type

552 if not exc_val_type.is_error and \

553 not exc_val_type.is_pyobject and \

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

555 error(self.exception_value.pos,

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

557 exc_val = self.exception_value

558 else:

559 if self.exception_value.analyse_const_expression(env):

560 exc_val = self.exception_value.get_constant_c_result_code()

561 if exc_val is None:

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

563 self.exception_value.__class__.__name__)

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

565 error(self.exception_value.pos,

566 "Exception value incompatible with function return type")

567 exc_check = self.exception_check

568 if return_type.is_array:

569 error(self.pos,

570 "Function cannot return an array")

571 if return_type.is_cfunction:

572 error(self.pos,

573 "Function cannot return a function")

574 func_type = PyrexTypes.CFuncType(

575 return_type, func_type_args, self.has_varargs,

576 optional_arg_count = self.optional_arg_count,

577 exception_value = exc_val, exception_check = exc_check,

578 calling_convention = self.base.calling_convention,

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

580 if self.optional_arg_count:

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

582 callspec = env.directives['callspec']

583 if callspec:

584 current = func_type.calling_convention

585 if current and current != callspec:

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

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

588 func_type.calling_convention = callspec

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

590

591

592 class CArgDeclNode(Node):

593 # Item in a function declaration argument list.

594 #

595 # base_type CBaseTypeNode

596 # declarator CDeclaratorNode

597 # not_none boolean Tagged with 'not None'

598 # default ExprNode or None

599 # default_value PyObjectConst constant for default value

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

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

602 # is_kw_only boolean Is a keyword-only argument

603

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

605

606 is_self_arg = 0

607 is_type_arg = 0

608 is_generic = 1

609 type = None

610 name_declarator = None

611 default_value = None

612

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

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

615 if self.type is None:

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

617 # We fix that here.

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

619 if nonempty:

620 self.declarator.name = self.base_type.name

621 self.base_type.name = None

622 self.base_type.is_basic_c_type = False

623 could_be_name = True

624 else:

625 could_be_name = False

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

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

628 self.declarator.name = self.base_type.arg_name

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

630 else:

631 return self.name_declarator, self.type

632

633 def calculate_default_value_code(self, code):

634 if self.default_value is None:

635 if self.default:

636 if self.default.is_literal:

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

638 self.default.generate_evaluation_code(code)

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

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

641 return self.default_value

642

643 def annotate(self, code):

644 if self.default:

645 self.default.annotate(code)

646

647

648 class CBaseTypeNode(Node):

649 # Abstract base class for C base type nodes.

650 #

651 # Processing during analyse_declarations phase:

652 #

653 # analyse

654 # Returns the type.

655

656 pass

657

658 class CAnalysedBaseTypeNode(Node):

659 # type type

660

661 child_attrs = []

662

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

664 return self.type

665

666 class CSimpleBaseTypeNode(CBaseTypeNode):

667 # name string

668 # module_path [string] Qualifying name components

669 # is_basic_c_type boolean

670 # signed boolean

671 # longness integer

672 # complex boolean

673 # is_self_arg boolean Is self argument of C method

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

675

676 child_attrs = []

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

678

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

680 # Return type descriptor.

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

682 type = None

683 if self.is_basic_c_type:

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

685 if not type:

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

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

688 type = py_object_type

689 elif self.name is None:

690 if self.is_self_arg and env.is_c_class_scope:

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

692 type = env.parent_type

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

694 ## type = Builtin.type_type

695 else:

696 type = py_object_type

697 else:

698 if self.module_path:

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

700 else:

701 scope = env

702 if scope:

703 if scope.is_c_class_scope:

704 scope = scope.global_scope()

705 entry = scope.lookup(self.name)

706 if entry and entry.is_type:

707 type = entry.type

708 elif could_be_name:

709 if self.is_self_arg and env.is_c_class_scope:

710 type = env.parent_type

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

712 ## type = Builtin.type_type

713 else:

714 type = py_object_type

715 self.arg_name = self.name

716 else:

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

718 if self.complex:

719 if not type.is_numeric or type.is_complex:

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

721 type = PyrexTypes.CComplexType(type)

722 type.create_declaration_utility_code(env)

723 if type:

724 return type

725 else:

726 return PyrexTypes.error_type

727

728 class CBufferAccessTypeNode(CBaseTypeNode):

729 # After parsing:

730 # positional_args [ExprNode] List of positional arguments

731 # keyword_args DictNode Keyword arguments

732 # base_type_node CBaseTypeNode

733

734 # After analysis:

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

736

737

738 child_attrs = ["base_type_node", "positional_args",

739 "keyword_args", "dtype_node"]

740

741 dtype_node = None

742

743 name = None

744

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

746 base_type = self.base_type_node.analyse(env)

747 if base_type.is_error: return base_type

748 import Buffer

749

750 options = Buffer.analyse_buffer_options(

751 self.pos,

752 env,

753 self.positional_args,

754 self.keyword_args,

755 base_type.buffer_defaults)

756

757 if sys.version_info[0] < 3:

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

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

760 for name, value in options.iteritems() ])

761

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

763 return self.type

764

765 class CComplexBaseTypeNode(CBaseTypeNode):

766 # base_type CBaseTypeNode

767 # declarator CDeclaratorNode

768

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

770

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

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

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

774 return type

775

776

777 class CVarDefNode(StatNode):

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

779 #

780 # visibility 'private' or 'public' or 'extern'

781 # base_type CBaseTypeNode

782 # declarators [CDeclaratorNode]

783 # in_pxd boolean

784 # api boolean

785 # need_properties [entry]

786

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

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

789

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

791 need_properties = ()

792

793 decorators = None

794 directive_locals = {}

795

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

797 if not dest_scope:

798 dest_scope = env

799 self.dest_scope = dest_scope

800 base_type = self.base_type.analyse(env)

801

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

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

804 # a property; made in AnalyseDeclarationsTransform).

805 if (dest_scope.is_c_class_scope

806 and self.visibility == 'public'

807 and base_type.is_pyobject

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

809 self.need_properties = []

810 need_property = True

811 visibility = 'private'

812 else:

813 need_property = False

814 visibility = self.visibility

815

816 for declarator in self.declarators:

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

818 if not type.is_complete():

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

820 error(declarator.pos,

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

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

823 error(declarator.pos,

824 "Python object cannot be declared extern")

825 name = name_declarator.name

826 cname = name_declarator.cname

827 if name == '':

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

829 return

830 if type.is_cfunction:

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

832 cname = cname, visibility = self.visibility, in_pxd = self.in_pxd,

833 api = self.api)

834 if entry is not None:

835 entry.directive_locals = self.directive_locals

836 else:

837 if self.directive_locals:

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

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

840 error(self.pos,

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

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

843 cname = cname, visibility = visibility, is_cdef = 1)

844 if need_property:

845 self.need_properties.append(entry)

846 entry.needs_property = 1

847

848

849 class CStructOrUnionDefNode(StatNode):

850 # name string

851 # cname string or None

852 # kind "struct" or "union"

853 # typedef_flag boolean

854 # visibility "public" or "private"

855 # in_pxd boolean

856 # attributes [CVarDefNode] or None

857 # entry Entry

858 # packed boolean

859

860 child_attrs = ["attributes"]

861

862 def analyse_declarations(self, env):

863 scope = None

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

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

866 if self.attributes is not None:

867 scope = StructOrUnionScope(self.name)

868 self.entry = env.declare_struct_or_union(

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

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

871 if self.attributes is not None:

872 if self.in_pxd and not env.in_cinclude:

873 self.entry.defined_in_pxd = 1

874 for attr in self.attributes:

875 attr.analyse_declarations(env, scope)

876 if self.visibility != 'extern':

877 need_typedef_indirection = False

878 for attr in scope.var_entries:

879 type = attr.type

880 while type.is_array:

881 type = type.base_type

882 if type == self.entry.type:

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

884 if self.typedef_flag:

885 while type.is_ptr:

886 type = type.base_type

887 if type == self.entry.type:

888 need_typedef_indirection = True

889 if need_typedef_indirection:

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

891 struct_entry = self.entry

892 self.entry = env.declare_typedef(

893 self.name, struct_entry.type, self.pos,

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

895 struct_entry.type.typedef_flag = False

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

897 struct_entry.cname = struct_entry.type.cname = \

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

899

900 def analyse_expressions(self, env):

901 pass

902

903 def generate_execution_code(self, code):

904 pass

905

906

907 class CEnumDefNode(StatNode):

908 # name string or None

909 # cname string or None

910 # items [CEnumDefItemNode]

911 # typedef_flag boolean

912 # visibility "public" or "private"

913 # in_pxd boolean

914 # entry Entry

915

916 child_attrs = ["items"]

917

918 def analyse_declarations(self, env):

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

920 cname = self.cname, typedef_flag = self.typedef_flag,

921 visibility = self.visibility)

922 if self.items is not None:

923 if self.in_pxd and not env.in_cinclude:

924 self.entry.defined_in_pxd = 1

925 for item in self.items:

926 item.analyse_declarations(env, self.entry)

927

928 def analyse_expressions(self, env):

929 pass

930

931 def generate_execution_code(self, code):

932 if self.visibility == 'public':

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

934 for item in self.entry.enum_values:

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

936 temp,

937 item.cname,

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

939 code.put_gotref(temp)

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

941 Naming.module_cname,

942 item.name,

943 temp,

944 code.error_goto(item.pos)))

945 code.put_decref_clear(temp, PyrexTypes.py_object_type)

946 code.funcstate.release_temp(temp)

947

948

949 class CEnumDefItemNode(StatNode):

950 # name string

951 # cname string or None

952 # value ExprNode or None

953

954 child_attrs = ["value"]

955

956 def analyse_declarations(self, env, enum_entry):

957 if self.value:

958 self.value.analyse_const_expression(env)

959 if not self.value.type.is_int:

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

961 self.value.analyse_const_expression(env)

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

963 self.value, self.pos, cname = self.cname,

964 visibility = enum_entry.visibility)

965 enum_entry.enum_values.append(entry)

966

967

968 class CTypeDefNode(StatNode):

969 # base_type CBaseTypeNode

970 # declarator CDeclaratorNode

971 # visibility "public" or "private"

972 # in_pxd boolean

973

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

975

976 def analyse_declarations(self, env):

977 base = self.base_type.analyse(env)

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

979 name = name_declarator.name

980 cname = name_declarator.cname

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

982 cname = cname, visibility = self.visibility)

983 if self.in_pxd and not env.in_cinclude:

984 entry.defined_in_pxd = 1

985

986 def analyse_expressions(self, env):

987 pass

988 def generate_execution_code(self, code):

989 pass

990

991

992 class FuncDefNode(StatNode, BlockNode):

993 # Base class for function definition nodes.

994 #

995 # return_type PyrexType

996 # #filename string C name of filename string const

997 # entry Symtab.Entry

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

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

1000

1001 py_func = None

1002 assmt = None

1003 needs_closure = False

1004 modifiers = []

1005

1006 def analyse_default_values(self, env):

1007 genv = env.global_scope()

1008 default_seen = 0

1009 for arg in self.args:

1010 if arg.default:

1011 default_seen = 1

1012 if arg.is_generic:

1013 arg.default.analyse_types(env)

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

1015 else:

1016 error(arg.pos,

1017 "This argument cannot have a default value")

1018 arg.default = None

1019 elif arg.kw_only:

1020 default_seen = 1

1021 elif default_seen:

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

1023

1024 def need_gil_acquisition(self, lenv):

1025 return 0

1026

1027 def create_local_scope(self, env):

1028 genv = env

1029 while genv.is_py_class_scope or genv.is_c_class_scope:

1030 genv = env.outer_scope

1031 if self.needs_closure:

1032 lenv = GeneratorLocalScope(name = self.entry.name, outer_scope = genv, parent_scope = env)

1033 else:

1034 lenv = LocalScope(name = self.entry.name, outer_scope = genv, parent_scope = env)

1035 lenv.return_type = self.return_type

1036 type = self.entry.type

1037 if type.is_cfunction:

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

1039 self.local_scope = lenv

1040 lenv.directives = env.directives

1041 return lenv

1042

1043 def generate_function_definitions(self, env, code):

1044 import Buffer

1045

1046 lenv = self.local_scope

1047

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

1049 self.entry.scope.is_c_class_scope)

1050

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

1052 if profile:

1053 if lenv.nogil:

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

1055 code.globalstate.use_utility_code(profile_utility_code)

1056

1057 # Generate C code for header and body of function

1058 code.enter_cfunc_scope()

1059 code.return_from_error_cleanup_label = code.new_label()

1060

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

1062 code.mark_pos(self.pos)

1063 self.generate_cached_builtins_decls(lenv, code)

1064 # ----- Function header

1065 code.putln("")

1066 if self.py_func:

1067 self.py_func.generate_function_header(code,

1068 with_pymethdef = env.is_py_class_scope,

1069 proto_only=True)

1070 self.generate_function_header(code,

1071 with_pymethdef = env.is_py_class_scope)

1072 # ----- Local variable declarations

1073 lenv.mangle_closure_cnames(Naming.cur_scope_cname)

1074 self.generate_argument_declarations(lenv, code)

1075 if self.needs_closure:

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

1077 code.put_var_declarations(lenv.var_entries)

1078 init = ""

1079 if not self.return_type.is_void:

1080 if self.return_type.is_pyobject:

1081 init = " = NULL"

1082 code.putln(

1083 "%s%s;" %

1084 (self.return_type.declaration_code(

1085 Naming.retval_cname),

1086 init))

1087 tempvardecl_code = code.insertion_point()

1088 self.generate_keyword_list(code)

1089 # ----- Extern library function declarations

1090 lenv.generate_library_function_declarations(code)

1091 # ----- GIL acquisition

1092 acquire_gil = self.acquire_gil

1093 if acquire_gil:

1094 env.use_utility_code(force_init_threads_utility_code)

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

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

1097 if not lenv.nogil:

1098 code.put_setup_refcount_context(self.entry.name)

1099 if profile:

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

1101 if is_getbuffer_slot:

1102 self.getbuffer_init(code)

1103 # ----- Fetch arguments

1104 self.generate_argument_parsing_code(env, code)

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

1106 # incref it to properly keep track of refcounts.

1107 for entry in lenv.arg_entries:

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

1109 code.put_var_incref(entry)

1110 # ----- Initialise local variables

1111 for entry in lenv.var_entries:

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

1113 code.put_init_var_to_py_none(entry)

1114 # ----- Initialise local buffer auxiliary variables

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

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

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

1118 # ----- Check and convert arguments

1119 self.generate_argument_type_tests(code)

1120 # ----- Acquire buffer arguments

1121 for entry in lenv.arg_entries:

1122 if entry.type.is_buffer:

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

1124 # ----- Function body

1125 self.body.generate_execution_code(code)

1126 # ----- Default return value

1127 code.putln("")

1128 if self.return_type.is_pyobject:

1129 #if self.return_type.is_extension_type:

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

1131 #else:

1132 lhs = Naming.retval_cname

1133 code.put_init_to_py_none(lhs, self.return_type)

1134 else:

1135 val = self.return_type.default_value

1136 if val:

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

1138 # ----- Error cleanup

1139 if code.error_label in code.labels_used:

1140 code.put_goto(code.return_label)

1141 code.put_label(code.error_label)

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

1143 code.put_xdecref(cname, type)

1144

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

1146 # so need to save and restore error state

1147 buffers_present = len(lenv.buffer_entries) > 0

1148 if buffers_present:

1149 code.globalstate.use_utility_code(restore_exception_utility_code)

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

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

1152 for entry in lenv.buffer_entries:

1153 Buffer.put_release_buffer_code(code, entry)

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

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

1156

1157 err_val = self.error_value()

1158 exc_check = self.caller_will_check_exceptions()

1159 if err_val is not None or exc_check:

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

1161 # code.globalstate.use_utility_code(get_exception_tuple_utility_code)

1162 # code.put_trace_exception()

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

1164 else:

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

1166 % self.entry.qualified_name, 0)

1167 code.putln(

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

1169 self.entry.qualified_name)

1170 env.use_utility_code(unraisable_exception_utility_code)

1171 env.use_utility_code(restore_exception_utility_code)

1172 default_retval = self.return_type.default_value

1173 if err_val is None and default_retval:

1174 err_val = default_retval

1175 if err_val is not None:

1176 code.putln(

1177 "%s = %s;" % (

1178 Naming.retval_cname,

1179 err_val))

1180

1181 if is_getbuffer_slot:

1182 self.getbuffer_error_cleanup(code)

1183

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

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

1186 # whether this section is used.

1187 if buffers_present or is_getbuffer_slot:

1188 code.put_goto(code.return_from_error_cleanup_label)

1189

1190

1191 # ----- Non-error return cleanup

1192 code.put_label(code.return_label)

1193 for entry in lenv.buffer_entries:

1194 if entry.used:

1195 Buffer.put_release_buffer_code(code, entry)

1196 if is_getbuffer_slot:

1197 self.getbuffer_normal_cleanup(code)

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

1199 code.put_label(code.return_from_error_cleanup_label)

1200 if not Options.init_local_none:

1201 for entry in lenv.var_entries:

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

1203 entry.xdecref_cleanup = 1

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

1205 # Decref any increfed args

1206 for entry in lenv.arg_entries:

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

1208 code.put_var_decref(entry)

1209

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

1211 # ----- Return

1212 # This code is duplicated in ModuleNode.generate_module_init_func

1213 if not lenv.nogil:

1214 default_retval = self.return_type.default_value

1215 err_val = self.error_value()

1216 if err_val is None and default_retval:

1217 err_val = default_retval

1218 if self.return_type.is_pyobject:

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

1220

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

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

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

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

1225 Naming.retval_cname, Naming.retval_cname))

1226

1227 if profile:

1228 if self.return_type.is_pyobject:

1229 code.put_trace_return(Naming.retval_cname)

1230 else:

1231 code.put_trace_return("Py_None")

1232 if not lenv.nogil:

1233 code.put_finish_refcount_context()

1234

1235 if acquire_gil:

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

1237

1238 if not self.return_type.is_void:

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

1240

1241 code.putln("}")

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

1243 tempvardecl_code.put_temp_declarations(code.funcstate)

1244 # ----- Python version

1245 code.exit_cfunc_scope()

1246 if self.py_func:

1247 self.py_func.generate_function_definitions(env, code)

1248 self.generate_wrapper_functions(code)

1249

1250 def declare_argument(self, env, arg):

1251 if arg.type.is_void:

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

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

1254 error(arg.pos,

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

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

1257

1258 def generate_wrapper_functions(self, code):

1259 pass

1260

1261 def generate_execution_code(self, code):

1262 # Evaluate and store argument default values

1263 for arg in self.args:

1264 default = arg.default

1265 if default:

1266 if not default.is_literal:

1267 default.generate_evaluation_code(code)

1268 default.make_owned_reference(code)

1269 result = default.result_as(arg.type)

1270 code.putln(

1271 "%s = %s;" % (

1272 arg.calculate_default_value_code(code),

1273 result))

1274 if arg.type.is_pyobject:

1275 code.put_giveref(default.result())

1276 default.generate_post_assignment_code(code)

1277 default.free_temps(code)

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

1279 if self.assmt:

1280 self.assmt.generate_execution_code(code)

1281

1282 #

1283 # Special code for the __getbuffer__ function

1284 #

1285 def getbuffer_init(self, code):

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

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

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

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

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

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

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

1293

1294 def getbuffer_error_cleanup(self, code):

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

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

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

1298 (info, info))

1299

1300 def getbuffer_normal_cleanup(self, code):

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

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

1303 code.put_gotref("Py_None")

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

1305 code.putln("}")

1306

1307 class CFuncDefNode(FuncDefNode):

1308 # C function definition.

1309 #

1310 # modifiers ['inline']

1311 # visibility 'private' or 'public' or 'extern'

1312 # base_type CBaseTypeNode

1313 # declarator CDeclaratorNode

1314 # body StatListNode

1315 # api boolean

1316 # decorators [DecoratorNode] list of decorators

1317 #

1318 # with_gil boolean Acquire GIL around body

1319 # type CFuncType

1320 # py_func wrapper for calling from Python

1321 # overridable whether or not this is a cpdef function

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

1323

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

1325

1326 inline_in_pxd = False

1327 decorators = None

1328 directive_locals = {}

1329

1330 def unqualified_name(self):

1331 return self.entry.name

1332

1333 def analyse_declarations(self, env):

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

1335 base_type = self.base_type.analyse(env)

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

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

1338 if not type.is_cfunction:

1339 error(self.pos,

1340 "Suite attached to non-function declaration")

1341 # Remember the actual type according to the function header

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

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

1344 # from the base type of an extension type.

1345 self.type = type

1346 type.is_overridable = self.overridable

1347 declarator = self.declarator

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

1349 declarator = declarator.base

1350 self.args = declarator.args

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

1352 formal_arg.type = type_arg.type

1353 formal_arg.name = type_arg.name

1354 formal_arg.cname = type_arg.cname

1355 name = name_declarator.name

1356 cname = name_declarator.cname

1357 self.entry = env.declare_cfunction(

1358 name, type, self.pos,

1359 cname = cname, visibility = self.visibility,

1360 defining = self.body is not None,

1361 api = self.api, modifiers = self.modifiers)

1362 self.entry.inline_func_in_pxd = self.inline_in_pxd

1363 self.return_type = type.return_type

1364

1365 if self.overridable and not env.is_module_scope:

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

1367 # An error will be produced in the cdef function

1368 self.overridable = False

1369

1370 if self.overridable:

1371 import ExprNodes

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

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

1374 name = self.entry.name,

1375 args = self.args,

1376 star_arg = None,

1377 starstar_arg = None,

1378 doc = self.doc,

1379 body = py_func_body,

1380 is_wrapper = 1)

1381 self.py_func.is_module_scope = env.is_module_scope

1382 self.py_func.analyse_declarations(env)

1383 self.entry.as_variable = self.py_func.entry

1384 # Reset scope entry the above cfunction

1385 env.entries[name] = self.entry

1386 if not env.is_module_scope or Options.lookup_module_cpdef:

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

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

1389 self.create_local_scope(env)

1390

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

1392 import ExprNodes

1393 args = self.type.args

1394 if omit_optional_args:

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

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

1397 if is_module_scope:

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

1399 else:

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

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

1402 skip_dispatch = not is_module_scope or Options.lookup_module_cpdef

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

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

1405

1406 def declare_arguments(self, env):

1407 for arg in self.type.args:

1408 if not arg.name:

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

1410 self.declare_argument(env, arg)

1411

1412 def need_gil_acquisition(self, lenv):

1413 return self.type.with_gil

1414

1415 def nogil_check(self, env):

1416 type = self.type

1417 with_gil = type.with_gil

1418 if type.nogil and not with_gil:

1419 if type.return_type.is_pyobject:

1420 error(self.pos,

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

1422 for entry in self.local_scope.var_entries:

1423 if entry.type.is_pyobject:

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

1425

1426 def analyse_expressions(self, env):

1427 self.local_scope.directives = env.directives

1428 if self.py_func is not None:

1429 # this will also analyse the default values

1430 self.py_func.analyse_expressions(env)

1431 else:

1432 self.analyse_default_values(env)

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

1434

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

1436 arg_decls = []

1437 type = self.type

1438 visibility = self.entry.visibility

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

1440 arg_decls.append(arg.declaration_code())

1441 if with_dispatch and self.overridable:

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

1443 if type.optional_arg_count and with_opt_args:

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

1445 if type.has_varargs:

1446 arg_decls.append("...")

1447 if not arg_decls:

1448 arg_decls = ["void"]

1449 if cname is None:

1450 cname = self.entry.func_cname

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

1452 if visibility == 'public':

1453 dll_linkage = "DL_EXPORT"

1454 else:

1455 dll_linkage = None

1456 header = self.return_type.declaration_code(entity,

1457 dll_linkage = dll_linkage)

1458 if visibility == 'extern':

1459 storage_class = "%s " % Naming.extern_c_macro

1460 elif visibility == 'public':

1461 storage_class = ""

1462 else:

1463 storage_class = "static "

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

1465 storage_class,

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

1467 header))

1468

1469 def generate_argument_declarations(self, env, code):

1470 for arg in self.args:

1471 if arg.default:

1472 result = arg.calculate_default_value_code(code)

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

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

1475

1476 def generate_keyword_list(self, code):

1477 pass

1478

1479 def generate_argument_parsing_code(self, env, code):

1480 i = 0

1481 if self.type.optional_arg_count:

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

1483 for arg in self.args:

1484 if arg.default:

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

1486 declarator = arg.declarator

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

1488 declarator = declarator.base

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

1490 i += 1

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

1492 code.putln('}')

1493 code.putln('}')

1494

1495 def generate_argument_conversion_code(self, code):

1496 pass

1497

1498 def generate_argument_type_tests(self, code):

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

1500 # class is a supertype of the declared type.

1501 for arg in self.type.args:

1502 if arg.needs_type_test:

1503 self.generate_arg_type_test(arg, code)

1504

1505 def generate_arg_type_test(self, arg, code):

1506 # Generate type test for one argument.

1507 if arg.type.typeobj_is_available():

1508 typeptr_cname = arg.type.typeptr_cname

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

1510 code.putln(

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

1512 arg_code,

1513 typeptr_cname,

1514 not arg.not_none,

1515 arg.name,

1516 type.is_builtin_type,

1517 code.error_goto(arg.pos)))

1518 else:

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

1520 "without type object name specification")

1521

1522 def error_value(self):

1523 if self.return_type.is_pyobject:

1524 return "0"

1525 else:

1526 #return None

1527 return self.entry.type.exception_value

1528

1529 def caller_will_check_exceptions(self):

1530 return self.entry.type.exception_check

1531

1532 def generate_wrapper_functions(self, code):

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

1534 # wrappers to put in the slots here.

1535 k = 0

1536 entry = self.entry

1537 func_type = entry.type

1538 while entry.prev_entry is not None:

1539 k += 1

1540 entry = entry.prev_entry

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

1542 code.putln()

1543 self.generate_function_header(code,

1544 0,

1545 with_dispatch = entry.type.is_overridable,

1546 with_opt_args = entry.type.optional_arg_count,

1547 cname = entry.func_cname)

1548 if not self.return_type.is_void:

1549 code.put('return ')

1550 args = self.type.args

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

1552 if entry.type.is_overridable:

1553 arglist.append(Naming.skip_dispatch_cname)

1554 elif func_type.is_overridable:

1555 arglist.append('0')

1556 if entry.type.optional_arg_count:

1557 arglist.append(Naming.optional_args_cname)

1558 elif func_type.optional_arg_count:

1559 arglist.append('NULL')

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

1561 code.putln('}')

1562

1563

1564 class PyArgDeclNode(Node):

1565 # Argument which must be a Python object (used

1566 # for * and ** arguments).

1567 #

1568 # name string

1569 # entry Symtab.Entry

1570 child_attrs = []

1571

1572

1573 class DecoratorNode(Node):

1574 # A decorator

1575 #

1576 # decorator NameNode or CallNode

1577 child_attrs = ['decorator']

1578

1579

1580 class DefNode(FuncDefNode):

1581 # A Python function definition.

1582 #

1583 # name string the Python name of the function

1584 # decorators [DecoratorNode] list of decorators

1585 # args [CArgDeclNode] formal arguments

1586 # star_arg PyArgDeclNode or None * argument

1587 # starstar_arg PyArgDeclNode or None ** argument

1588 # doc EncodedString or None

1589 # body StatListNode

1590 #

1591 # The following subnode is constructed internally

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

1593 #

1594 # assmt AssignmentNode Function construction/assignment

1595

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

1597

1598 assmt = None

1599 num_kwonly_args = 0

1600 num_required_kw_args = 0

1601 reqd_kw_flags_cname = "0"

1602 is_wrapper = 0

1603 decorators = None

1604 entry = None

1605 acquire_gil = 0

1606 self_in_stararg = 0

1607

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

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

1610 k = rk = r = 0

1611 for arg in self.args:

1612 if arg.kw_only:

1613 k += 1

1614 if not arg.default:

1615 rk += 1

1616 if not arg.default:

1617 r += 1

1618 self.num_kwonly_args = k

1619 self.num_required_kw_args = rk

1620 self.num_required_args = r

1621

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

1623 if self.star_arg:

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

1625 if self.starstar_arg:

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

1627 if cfunc is None:

1628 cfunc_args = []

1629 for formal_arg in self.args:

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

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

1632 cname = None,

1633 type = py_object_type,

1634 pos = formal_arg.pos))

1635 cfunc_type = PyrexTypes.CFuncType(return_type = py_object_type,

1636 args = cfunc_args,

1637 has_varargs = False,

1638 exception_value = None,

1639 exception_check = False,

1640 nogil = False,

1641 with_gil = False,

1642 is_overridable = True)

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

1644 else:

1645 cfunc_type = cfunc.type

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

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

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

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

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

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

1652 formal_arg.type = type_arg.type

1653 formal_arg.name_declarator = name_declarator

1654 import ExprNodes

1655 if cfunc_type.exception_value is None:

1656 exception_value = None

1657 else:

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

1659 declarator = CFuncDeclaratorNode(self.pos,

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

1661 args = self.args,

1662 has_varargs = False,

1663 exception_check = cfunc_type.exception_check,

1664 exception_value = exception_value,

1665 with_gil = cfunc_type.with_gil,

1666 nogil = cfunc_type.nogil)

1667 return CFuncDefNode(self.pos,

1668 modifiers = [],

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

1670 declarator = declarator,

1671 body = self.body,

1672 doc = self.doc,

1673 overridable = cfunc_type.is_overridable,

1674 type = cfunc_type,

1675 with_gil = cfunc_type.with_gil,

1676 nogil = cfunc_type.nogil,

1677 visibility = 'private',

1678 api = False,

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

1680

1681 def analyse_declarations(self, env):

1682 self.is_classmethod = self.is_staticmethod = False

1683 if self.decorators:

1684 for decorator in self.decorators:

1685 func = decorator.decorator

1686 if func.is_name:

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

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

1689

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

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

1692 self.is_classmethod = False

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

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

1695 self.is_staticmethod = False

1696

1697 self.analyse_argument_types(env)

1698 self.declare_pyfunction(env)

1699 self.analyse_signature(env)

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

1701 self.create_local_scope(env)

1702

1703 def analyse_argument_types(self, env):

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

1705 for arg in self.args:

1706 if hasattr(arg, 'name'):

1707 type = arg.type

1708 name_declarator = None

1709 else:

1710 base_type = arg.base_type.analyse(env)

1711 name_declarator, type = \

1712 arg.declarator.analyse(base_type, env)

1713 arg.name = name_declarator.name

1714 if arg.name in directive_locals:

1715 type_node = directive_locals[arg.name]

1716 other_type = type_node.analyse_as_type(env)

1717 if other_type is None:

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

1719 elif (type is not PyrexTypes.py_object_type

1720 and not type.same_as(other_type)):

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

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

1723 else:

1724 type = other_type

1725 if name_declarator and name_declarator.cname:

1726 error(self.pos,

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

1728 arg.type = type.as_argument_type()

1729 arg.hdr_type = None

1730 arg.needs_conversion = 0

1731 arg.needs_type_test = 0

1732 arg.is_generic = 1

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

1734 error(self.pos,

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

1736

1737 def analyse_signature(self, env):

1738 any_type_tests_needed = 0

1739 if self.entry.is_special:

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

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

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

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

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

1745 self.entry.signature = TypeSlots.pyfunction_noargs

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

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

1748 self.entry.signature = TypeSlots.pyfunction_onearg

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

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

1751 self.entry.signature = TypeSlots.unaryfunc

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

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

1754 self.entry.signature = TypeSlots.ibinaryfunc

1755

1756 sig = self.entry.signature

1757 nfixed = sig.num_fixed_args()

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

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

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

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

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

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

1764 self.self_in_stararg = 1

1765 nfixed = 0

1766

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

1768 arg = self.args[i]

1769 arg.is_generic = 0

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

1771 if self.is_classmethod:

1772 arg.is_type_arg = 1

1773 arg.hdr_type = arg.type = Builtin.type_type

1774 else:

1775 arg.is_self_arg = 1

1776 arg.hdr_type = arg.type = env.parent_type

1777 arg.needs_conversion = 0

1778 else:

1779 arg.hdr_type = sig.fixed_arg_type(i)

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

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

1782 arg.needs_type_test = 1

1783 any_type_tests_needed = 1

1784 else:

1785 arg.needs_conversion = 1

1786 if arg.needs_conversion:

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

1788 else:

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

1790

1791 if nfixed > len(self.args):

1792 self.bad_signature()

1793 return

1794 elif nfixed < len(self.args):

1795 if not sig.has_generic_args:

1796 self.bad_signature()

1797 for arg in self.args:

1798 if arg.is_generic and \

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

1800 arg.needs_type_test = 1

1801 any_type_tests_needed = 1

1802 if any_type_tests_needed:

1803 env.use_utility_code(arg_type_test_utility_code)

1804

1805 def bad_signature(self):

1806 sig = self.entry.signature

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

1808 if sig.has_generic_args:

1809 expected_str = expected_str + " or more"

1810 name = self.name

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

1812 desc = "Special method"

1813 else:

1814 desc = "Method"

1815 error(self.pos,

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

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

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

1819

1820 def signature_has_nongeneric_args(self):

1821 argcount = len(self.args)

1822 if argcount == 0 or (

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

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

1825 return 0

1826 return 1

1827

1828 def signature_has_generic_args(self):

1829 return self.entry.signature.has_generic_args

1830

1831 def declare_pyfunction(self, env):

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

1833 name = self.name

1834 entry = env.lookup_here(self.name)

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

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

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

1838 self.entry = entry

1839 prefix = env.scope_prefix

1840 entry.func_cname = \

1841 Naming.pyfunc_prefix + prefix + name

1842 entry.pymethdef_cname = \

1843 Naming.pymethdef_prefix + prefix + name

1844 if Options.docstrings:

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

1846 entry.doc_cname = \

1847 Naming.funcdoc_prefix + prefix + name

1848 else:

1849 entry.doc = None

1850

1851 def declare_arguments(self, env):

1852 for arg in self.args:

1853 if not arg.name:

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

1855 if arg.needs_conversion:

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

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

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

1859 if arg.type.is_pyobject:

1860 arg.entry.init = "0"

1861 arg.entry.init_to_none = 0

1862 else:

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

1864 arg.entry.used = 1

1865 arg.entry.is_self_arg = arg.is_self_arg

1866 if arg.hdr_type:

1867 if arg.is_self_arg or arg.is_type_arg or \

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

1869 arg.entry.is_declared_generic = 1

1870 self.declare_python_arg(env, self.star_arg)

1871 self.declare_python_arg(env, self.starstar_arg)

1872

1873 def declare_python_arg(self, env, arg):

1874 if arg:

1875 if env.directives['infer_types'] != 'none':

1876 type = PyrexTypes.unspecified_type

1877 else:

1878 type = py_object_type

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

1880 entry.used = 1

1881 entry.init = "0"

1882 entry.init_to_none = 0

1883 entry.xdecref_cleanup = 1

1884 arg.entry = entry

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

1886

1887 def analyse_expressions(self, env):

1888 self.local_scope.directives = env.directives

1889 self.analyse_default_values(env)

1890 if env.is_py_class_scope:

1891 self.synthesize_assignment_node(env)

1892

1893 def synthesize_assignment_node(self, env):

1894 import ExprNodes

1895 self.assmt = SingleAssignmentNode(self.pos,

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

1897 rhs = ExprNodes.UnboundMethodNode(self.pos,

1898 function = ExprNodes.PyCFunctionNode(self.pos,

1899 pymethdef_cname = self.entry.pymethdef_cname)))

1900 self.assmt.analyse_declarations(env)

1901 self.assmt.analyse_expressions(env)

1902

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

1904 arg_code_list = []

1905 sig = self.entry.signature

1906 if sig.has_dummy_arg or self.self_in_stararg:

1907 arg_code_list.append(

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

1909 for arg in self.args:

1910 if not arg.is_generic:

1911 if arg.is_self_arg or arg.is_type_arg:

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

1913 else:

1914 arg_code_list.append(

1915 arg.hdr_type.declaration_code(arg.hdr_cname))

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

1917 arg_code_list.append("PyObject *unused")

1918 if sig.has_generic_args:

1919 arg_code_list.append(

1920 "PyObject *%s, PyObject *%s"

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

1922 arg_code = ", ".join(arg_code_list)

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

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

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

1926 if proto_only:

1927 return

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

1929 docstr = self.entry.doc

1930 if docstr.is_unicode:

1931 docstr = docstr.utf8encode()

1932 code.putln(

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

1934 self.entry.doc_cname,

1935 split_docstring(escape_byte_string(docstr))))

1936 if with_pymethdef:

1937 code.put(

1938 "static PyMethodDef %s = " %

1939 self.entry.pymethdef_cname)

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

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

1942

1943 def generate_argument_declarations(self, env, code):

1944 for arg in self.args:

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

1946 if arg.needs_conversion:

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

1948 else:

1949 code.put_var_declaration(arg.entry)

1950

1951 def generate_keyword_list(self, code):

1952 if self.signature_has_generic_args() and \

1953 self.signature_has_nongeneric_args():

1954 code.put(

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

1956 Naming.pykwdlist_cname)

1957 for arg in self.args:

1958 if arg.is_generic:

1959 pystring_cname = code.intern_identifier(arg.name)

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

1961 code.putln("0};")

1962

1963 def generate_argument_parsing_code(self, env, code):

1964 # Generate PyArg_ParseTuple call for generic

1965 # arguments, if any.

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

1967 # get rid of unused argument warning

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

1969

1970 old_error_label = code.new_error_label()

1971 our_error_label = code.error_label

1972 end_label = code.new_label("argument_unpacking_done")

1973

1974 has_kwonly_args = self.num_kwonly_args > 0

1975 has_star_or_kw_args = self.star_arg is not None \

1976 or self.starstar_arg is not None or has_kwonly_args

1977

1978 for arg in self.args:

1979 if not arg.type.is_pyobject:

1980 done = arg.type.create_from_py_utility_code(env)

1981 if not done: pass # will fail later

1982

1983 if not self.signature_has_generic_args():

1984 if has_star_or_kw_args:

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

1986 self.generate_argument_conversion_code(code)

1987

1988 elif not self.signature_has_nongeneric_args():

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

1990 self.generate_stararg_copy_code(code)

1991

1992 else:

1993 positional_args = []

1994 kw_only_args = []

1995 for arg in self.args:

1996 arg_entry = arg.entry

1997 if arg.is_generic:

1998 if arg.default:

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

2000 if arg.kw_only:

2001 kw_only_args.append(arg)

2002 else:

2003 positional_args.append(arg)

2004 elif arg.kw_only:

2005 kw_only_args.append(arg)

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

2007 positional_args.append(arg)

2008

2009 self.generate_tuple_and_keyword_parsing_code(

2010 positional_args, kw_only_args, end_label, code)

2011

2012 code.error_label = old_error_label

2013 if code.label_used(our_error_label):

2014 if not code.label_used(end_label):

2015 code.put_goto(end_label)

2016 code.put_label(our_error_label)

2017 if has_star_or_kw_args:

2018 self.generate_arg_decref(self.star_arg, code)

2019 if self.starstar_arg:

2020 if self.starstar_arg.entry.xdecref_cleanup:

2021 code.put_var_xdecref(self.starstar_arg.entry)

2022 else:

2023 code.put_var_decref(self.starstar_arg.entry)

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

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

2026 if code.label_used(end_label):

2027 code.put_label(end_label)

2028

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

2030 if arg.type.is_pyobject:

2031 if arg.is_generic:

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

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

2034 else:

2035 func = arg.type.from_py_function

2036 if func:

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

2038 arg.entry.cname,

2039 func,

2040 item,

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

2042 else:

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

2044

2045 def generate_arg_xdecref(self, arg, code):

2046 if arg:

2047 code.put_var_xdecref(arg.entry)

2048

2049 def generate_arg_decref(self, arg, code):

2050 if arg:

2051 code.put_var_decref(arg.entry)

2052

2053 def generate_stararg_copy_code(self, code):

2054 if not self.star_arg:

2055 code.globalstate.use_utility_code(raise_argtuple_invalid_utility_code)

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

2057 Naming.args_cname)

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

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

2060 code.putln("}")

2061

2062 code.globalstate.use_utility_code(keyword_string_check_utility_code)

2063

2064 if self.starstar_arg:

2065 if self.star_arg:

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

2067 else:

2068 kwarg_check = "%s" % Naming.kwds_cname

2069 else:

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

2071 Naming.kwds_cname, Naming.kwds_cname)

2072 code.putln(

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

2074 kwarg_check, Naming.kwds_cname, self.name,

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

2076

2077 if self.starstar_arg:

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

2079 self.starstar_arg.entry.cname,

2080 Naming.kwds_cname,

2081 Naming.kwds_cname))

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

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

2084 self.starstar_arg.entry.xdecref_cleanup = 0

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

2086

2087 if self.self_in_stararg:

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

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

2090 self.star_arg.entry.cname,

2091 Naming.args_cname,

2092 self.star_arg.entry.cname))

2093 if self.starstar_arg:

2094 code.putln("{")

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

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

2097 code.putln("}")

2098 else:

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

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

2101 code.put_incref(Naming.self_cname, py_object_type)

2102 code.put_giveref(Naming.self_cname)

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

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

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

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

2107 temp, temp, Naming.args_cname, temp))

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

2109 Naming.args_cname, temp))

2110 code.put_incref("item", py_object_type)

2111 code.put_giveref("item")

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

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

2114 code.putln("}")

2115 code.funcstate.release_temp(temp)

2116 self.star_arg.entry.xdecref_cleanup = 0

2117 elif self.star_arg:

2118 code.put_incref(Naming.args_cname, py_object_type)

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

2120 self.star_arg.entry.cname,

2121 Naming.args_cname))

2122 self.star_arg.entry.xdecref_cleanup = 0

2123

2124 def generate_tuple_and_keyword_parsing_code(self, positional_args,

2125 kw_only_args, success_label, code):

2126 argtuple_error_label = code.new_label("argtuple_error")

2127

2128 min_positional_args = self.num_required_args - self.num_required_kw_args

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

2130 min_positional_args -= 1

2131 max_positional_args = len(positional_args)

2132 has_fixed_positional_count = not self.star_arg and \

2133 min_positional_args == max_positional_args

2134

2135 code.globalstate.use_utility_code(raise_double_keywords_utility_code)

2136 code.globalstate.use_utility_code(raise_argtuple_invalid_utility_code)

2137 if self.num_required_kw_args:

2138 code.globalstate.use_utility_code(raise_keyword_required_utility_code)

2139

2140 if self.starstar_arg or self.star_arg:

2141 self.generate_stararg_init_code(max_positional_args, code)

2142

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

2144 if self.num_required_kw_args:

2145 likely_hint = "likely"

2146 else:

2147 likely_hint = "unlikely"

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

2149 self.generate_keyword_unpacking_code(

2150 min_positional_args, max_positional_args,

2151 has_fixed_positional_count,

2152 positional_args, kw_only_args, argtuple_error_label, code)

2153

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

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

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

2157 # check the length here

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

2159 compare = '!='

2160 else:

2161 compare = '<'

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

2163 Naming.args_cname, compare, min_positional_args))

2164 code.put_goto(argtuple_error_label)

2165

2166 if self.num_required_kw_args:

2167 # pure error case: keywords required but not passed

2168 if max_positional_args > min_positional_args and not self.star_arg:

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

2170 Naming.args_cname, max_positional_args))

2171 code.put_goto(argtuple_error_label)

2172 code.putln('} else {')

2173 for i, arg in enumerate(kw_only_args):

2174 if not arg.default:

2175 pystring_cname = code.intern_identifier(arg.name)

2176 # required keyword-only argument missing

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

2178 self.name,

2179 pystring_cname))

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

2181 break

2182

2183 elif min_positional_args == max_positional_args:

2184 # parse the exact number of positional arguments from the

2185 # args tuple

2186 code.putln('} else {')

2187 for i, arg in enumerate(positional_args):

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

2189 self.generate_arg_assignment(arg, item, code)

2190 self.generate_arg_default_assignments(code)

2191

2192 else:

2193 # parse the positional arguments from the variable length

2194 # args tuple

2195 code.putln('} else {')

2196 self.generate_arg_default_assignments(code)

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

2198 if self.star_arg:

2199 code.putln('default:')

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

2201 for i, arg in reversed_args:

2202 if i >= min_positional_args-1:

2203 if min_positional_args > 1:

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

2205 else:

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

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

2208 self.generate_arg_assignment(arg, item, code)

2209 if min_positional_args == 0:

2210 code.put('case 0: ')

2211 code.putln('break;')

2212 if self.star_arg:

2213 if min_positional_args:

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

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

2216 code.put_goto(argtuple_error_label)

2217 else:

2218 code.put('default: ')

2219 code.put_goto(argtuple_error_label)

2220 code.putln('}')

2221

2222 code.putln('}')

2223

2224 if code.label_used(argtuple_error_label):

2225 code.put_goto(success_label)

2226 code.put_label(argtuple_error_label)

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

2228 self.name, has_fixed_positional_count,

2229 min_positional_args, max_positional_args,

2230 Naming.args_cname))

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

2232

2233 def generate_arg_default_assignments(self, code):

2234 for arg in self.args:

2235 if arg.is_generic and arg.default:

2236 code.putln(

2237 "%s = %s;" % (

2238 arg.entry.cname,

2239 arg.calculate_default_value_code(code)))

2240

2241 def generate_stararg_init_code(self, max_positional_args, code):

2242 if self.starstar_arg:

2243 self.starstar_arg.entry.xdecref_cleanup = 0

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

2245 self.starstar_arg.entry.cname,

2246 self.starstar_arg.entry.cname,

2247 self.error_value()))

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

2249 if self.star_arg:

2250 self.star_arg.entry.xdecref_cleanup = 0

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

2252 Naming.args_cname,

2253 max_positional_args))

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

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

2256 max_positional_args, Naming.args_cname))

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

2258 if self.starstar_arg:

2259 code.putln("")

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

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

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

2263 code.putln('}')

2264 else:

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

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

2267 code.putln('} else {')

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

2269 code.put_incref(Naming.empty_tuple, py_object_type)

2270 code.putln('}')

2271

2272 def generate_keyword_unpacking_code(self, min_positional_args, max_positional_args,

2273 has_fixed_positional_count, positional_args,

2274 kw_only_args, argtuple_error_label, code):

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

2276 max_args = len(all_args)

2277

2278 default_args = []

2279 for i, arg in enumerate(all_args):

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

2281 default_value = arg.calculate_default_value_code(code)

2282 if arg.type is not PyrexTypes.py_object_type:

2283 default_value = "(PyObject*)"+default_value

2284 default_args.append((i, default_value))

2285

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

2287 Naming.kwds_cname)

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

2289 # default value, but C89 needs this

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

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

2292 for i, default_value in default_args:

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

2294

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

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

2297 if self.star_arg:

2298 code.putln('default:')

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

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

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

2302 i, Naming.args_cname, i))

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

2304 if not self.star_arg:

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

2306 code.put_goto(argtuple_error_label)

2307 code.putln('}')

2308

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

2310 # from the kw dict

2311 if self.num_required_args or max_positional_args > 0:

2312 last_required_arg = -1

2313 for i, arg in enumerate(all_args):

2314 if not arg.default:

2315 last_required_arg = i

2316 if last_required_arg < max_positional_args:

2317 last_required_arg = max_positional_args-1

2318 num_required_args = self.num_required_args

2319 if max_positional_args > 0:

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

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

2322 if max_positional_args > 0 and i <= max_positional_args:

2323 if self.star_arg and i == max_positional_args:

2324 code.putln('default:')

2325 else:

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

2327 pystring_cname = code.intern_identifier(arg.name)

2328 if arg.default:

2329 if arg.kw_only:

2330 # handled separately below

2331 continue

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

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

2334 Naming.kwds_cname, pystring_cname))

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

2336 code.putln('}')

2337 else:

2338 num_required_args -= 1

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

2340 i, Naming.kwds_cname, pystring_cname))

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

2342 if i < min_positional_args:

2343 if i == 0:

2344 # special case: we know arg 0 is missing

2345 code.put('else ')

2346 code.put_goto(argtuple_error_label)

2347 else:

2348 # print the correct number of values (args or

2349 # kwargs) that were passed into positional

2350 # arguments up to this point

2351 code.putln('else {')

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

2353 self.name, has_fixed_positional_count,

2354 min_positional_args, max_positional_args, i))

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

2356 code.putln('}')

2357 elif arg.kw_only:

2358 code.putln('else {')

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

2360 self.name, pystring_cname))

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

2362 code.putln('}')

2363 if max_positional_args > 0:

2364 code.putln('}')

2365

2366 if kw_only_args and not self.starstar_arg:

2367 # unpack optional keyword-only arguments

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

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

2370 optional_args = []

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

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

2373 continue

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

2375 if optional_args:

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

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

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

2379 for i, arg in optional_args:

2380 pystring_cname = code.intern_identifier(arg.name)

2381 code.putln(

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

2383 Naming.kwds_cname, pystring_cname))

2384 code.putln(

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

2386 code.putln('break;')

2387 code.putln('}')

2388

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

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

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

2392 #

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

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

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

2396 # common cases above.

2397 if max_positional_args == 0:

2398 pos_arg_count = "0"

2399 elif self.star_arg:

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

2401 Naming.args_cname, max_positional_args,

2402 Naming.args_cname, max_positional_args))

2403 pos_arg_count = "used_pos_args"

2404 else:

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

2406 code.globalstate.use_utility_code(parse_keywords_utility_code)

2407 code.put(

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

2409 Naming.kwds_cname,

2410 Naming.pykwdlist_cname,

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

2412 pos_arg_count,

2413 self.name))

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

2415 code.putln('}')

2416

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

2418 for i, arg in enumerate(all_args):

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

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

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

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

2423 code.putln('} else {')

2424 code.putln(

2425 "%s = %s;" % (

2426 arg.entry.cname,

2427 arg.calculate_default_value_code(code)))

2428 code.putln('}')

2429

2430 def generate_argument_conversion_code(self, code):

2431 # Generate code to convert arguments from

2432 # signature type to declared type, if needed.

2433 for arg in self.args:

2434 if arg.needs_conversion:

2435 self.generate_arg_conversion(arg, code)

2436

2437 def generate_arg_conversion(self, arg, code):

2438 # Generate conversion code for one argument.

2439 old_type = arg.hdr_type

2440 new_type = arg.type

2441 if old_type.is_pyobject:

2442 if arg.default:

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

2444 else:

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

2446 self.generate_arg_conversion_from_pyobject(arg, code)

2447 code.putln("}")

2448 elif new_type.is_pyobject:

2449 self.generate_arg_conversion_to_pyobject(arg, code)

2450 else:

2451 if new_type.assignable_from(old_type):

2452 code.putln(

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

2454 else:

2455 error(arg.pos,

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

2457 (old_type, new_type))

2458

2459 def generate_arg_conversion_from_pyobject(self, arg, code):

2460 new_type = arg.type

2461 func = new_type.from_py_function

2462 # copied from CoerceFromPyTypeNode

2463 if func:

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

2465 arg.entry.cname,

2466 func,

2467 arg.hdr_cname,

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

2469 else:

2470 error(arg.pos,

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

2472 % new_type)

2473

2474 def generate_arg_conversion_to_pyobject(self, arg, code):

2475 old_type = arg.hdr_type

2476 func = old_type.to_py_function

2477 if func:

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

2479 arg.entry.cname,

2480 func,

2481 arg.hdr_cname,

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

2483 code.put_var_gotref(arg.entry)

2484 else:

2485 error(arg.pos,

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

2487 % old_type)

2488

2489 def generate_argument_type_tests(self, code):

2490 # Generate type tests for args whose signature

2491 # type is PyObject * and whose declared type is

2492 # a subtype thereof.

2493 for arg in self.args:

2494 if arg.needs_type_test:

2495 self.generate_arg_type_test(arg, code)

2496

2497 def generate_arg_type_test(self, arg, code):

2498 # Generate type test for one argument.

2499 if arg.type.typeobj_is_available():

2500 typeptr_cname = arg.type.typeptr_cname

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

2502 code.putln(

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

2504 arg_code,

2505 typeptr_cname,

2506 not arg.not_none,

2507 arg.name,

2508 arg.type.is_builtin_type,

2509 code.error_goto(arg.pos)))

2510 else:

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

2512 "without type object name specification")

2513

2514 def error_value(self):

2515 return self.entry.signature.error_value

2516

2517 def caller_will_check_exceptions(self):

2518 return 1

2519

2520 class OverrideCheckNode(StatNode):

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

2522 # is overriden.

2523 #

2524 # py_func

2525 #

2526 # args

2527 # func_temp

2528 # body

2529

2530 child_attrs = ['body']

2531

2532 body = None

2533

2534 def analyse_expressions(self, env):

2535 self.args = env.arg_entries

2536 if self.py_func.is_module_scope:

2537 first_arg = 0

2538 else:

2539 first_arg = 1

2540 import ExprNodes

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

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

2543 call_node = ExprNodes.SimpleCallNode(self.pos,

2544 function=self.func_node,

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

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

2547 self.body.analyse_expressions(env)

2548

2549 def generate_execution_code(self, code):

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

2551 # Check to see if we are an extension type

2552 if self.py_func.is_module_scope:

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

2554 else:

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

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

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

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

2559 if self.py_func.is_module_scope:

2560 code.putln("else {")

2561 else:

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

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

2564 self.func_node.set_cname(func_node_temp)

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

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

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

2568 func_node_temp, self_arg, interned_attr_cname, err))

2569 code.put_gotref(func_node_temp)

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

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

2572 func_node_temp, self.py_func.entry.func_cname)

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

2574 self.body.generate_execution_code(code)

2575 code.putln("}")

2576 code.put_decref_clear(func_node_temp, PyrexTypes.py_object_type)

2577 code.funcstate.release_temp(func_node_temp)

2578 code.putln("}")

2579

2580 class ClassDefNode(StatNode, BlockNode):

2581 pass

2582

2583 class PyClassDefNode(ClassDefNode):

2584 # A Python class definition.

2585 #

2586 # name EncodedString Name of the class

2587 # doc string or None

2588 # body StatNode Attribute definition code

2589 # entry Symtab.Entry

2590 # scope PyClassScope

2591 # decorators [DecoratorNode] list of decorators or None

2592 #

2593 # The following subnodes are constructed internally:

2594 #

2595 # dict DictNode Class dictionary

2596 # classobj ClassNode Class object

2597 # target NameNode Variable to assign class object to

2598

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

2600 decorators = None

2601

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

2603 StatNode.__init__(self, pos)

2604 self.name = name

2605 self.doc = doc

2606 self.body = body

2607 self.decorators = decorators

2608 import ExprNodes

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

2610 if self.doc and Options.docstrings:

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

2612 # FIXME: correct string node?

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

2614 else:

2615 doc_node = None

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

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

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

2619

2620 def as_cclass(self):

2621 """

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

2623 """

2624 bases = self.classobj.bases.args

2625 if len(bases) == 0:

2626 base_class_name = None

2627 base_class_module = None

2628 elif len(bases) == 1:

2629 base = bases[0]

2630 path = []

2631 from ExprNodes import AttributeNode, NameNode

2632 while isinstance(base, AttributeNode):

2633 path.insert(0, base.attribute)

2634 base = base.obj

2635 if isinstance(base, NameNode):

2636 path.insert(0, base.name)

2637 base_class_name = path[-1]

2638 if len(path) > 1:

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

2640 else:

2641 base_class_module = None

2642 else:

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

2644 else:

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

2646 return None

2647

2648 return CClassDefNode(self.pos,

2649 visibility = 'private',

2650 module_name = None,

2651 class_name = self.name,

2652 base_class_module = base_class_module,

2653 base_class_name = base_class_name,

2654 decorators = self.decorators,

2655 body = self.body,

2656 in_pxd = False,

2657 doc = self.doc)

2658

2659 def create_scope(self, env):

2660 genv = env

2661 while env.is_py_class_scope or env.is_c_class_scope:

2662 env = env.outer_scope

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

2664 return cenv

2665

2666 def analyse_declarations(self, env):

2667 self.target.analyse_target_declaration(env)

2668 cenv = self.create_scope(env)

2669 cenv.directives = env.directives

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

2671 self.body.analyse_declarations(cenv)

2672

2673 def analyse_expressions(self, env):

2674 self.dict.analyse_expressions(env)

2675 self.classobj.analyse_expressions(env)

2676 genv = env.global_scope()

2677 cenv = self.scope

2678 self.body.analyse_expressions(cenv)

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

2680

2681 def generate_function_definitions(self, env, code):

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

2683

2684 def generate_execution_code(self, code):

2685 code.pyclass_stack.append(self)

2686 cenv = self.scope

2687 self.dict.generate_evaluation_code(code)

2688 self.classobj.generate_evaluation_code(code)

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

2690 self.body.generate_execution_code(code)

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

2692 self.dict.generate_disposal_code(code)

2693 self.dict.free_temps(code)

2694 code.pyclass_stack.pop()

2695

2696

2697 class CClassDefNode(ClassDefNode):

2698 # An extension type definition.

2699 #

2700 # visibility 'private' or 'public' or 'extern'

2701 # typedef_flag boolean

2702 # api boolean

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

2704 # class_name string Unqualified name of class

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

2706 # base_class_module string or None Module containing the base class

2707 # base_class_name string or None Name of the base class

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

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

2710 # in_pxd boolean Is in a .pxd file

2711 # decorators [DecoratorNode] list of decorators or None

2712 # doc string or None

2713 # body StatNode or None

2714 # entry Symtab.Entry

2715 # base_type PyExtensionType or None

2716 # buffer_defaults_node DictNode or None Declares defaults for a buffer

2717 # buffer_defaults_pos

2718

2719 child_attrs = ["body"]

2720 buffer_defaults_node = None

2721 buffer_defaults_pos = None

2722 typedef_flag = False

2723 api = False

2724 objstruct_name = None

2725 typeobj_name = None

2726 decorators = None

2727

2728 def analyse_declarations(self, env):

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

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

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

2732

2733 import Buffer

2734 if self.buffer_defaults_node:

2735 buffer_defaults = Buffer.analyse_buffer_options(self.buffer_defaults_pos,

2736 env, [], self.buffer_defaults_node,

2737 need_complete=False)

2738 else:

2739 buffer_defaults = None

2740

2741 if env.in_cinclude and not self.objstruct_name:

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

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

2744 self.base_type = None

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

2746 # import the modules for extern classes.

2747 if self.module_name:

2748 self.module = None

2749 for module in env.cimported_modules:

2750 if module.name == self.module_name:

2751 self.module = module

2752 if self.module is None:

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

2754 self.module.has_extern_class = 1

2755 env.add_imported_module(self.module)

2756

2757 if self.base_class_name:

2758 if self.base_class_module:

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

2760 else:

2761 base_class_scope = env

2762 if self.base_class_name == 'object':

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

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

2765 self.base_class_name = None

2766 self.base_class_module = None

2767 base_class_scope = None

2768 if base_class_scope:

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

2770 if base_class_entry:

2771 if not base_class_entry.is_type:

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

2773 elif not base_class_entry.type.is_extension_type:

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

2775 elif not base_class_entry.type.is_complete():

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

2777 else:

2778 self.base_type = base_class_entry.type

2779 has_body = self.body is not None

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

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

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

2783 if not home_scope:

2784 return

2785 else:

2786 home_scope = env

2787

2788 if self.visibility == 'extern':

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

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

2791

2792 self.entry = home_scope.declare_c_class(

2793 name = self.class_name,

2794 pos = self.pos,

2795 defining = has_body and self.in_pxd,

2796 implementing = has_body and not self.in_pxd,

2797 module_name = self.module_name,

2798 base_type = self.base_type,

2799 objstruct_cname = self.objstruct_name,

2800 typeobj_cname = self.typeobj_name,

2801 visibility = self.visibility,

2802 typedef_flag = self.typedef_flag,

2803 api = self.api,

2804 buffer_defaults = buffer_defaults)

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

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

2807 self.scope = scope = self.entry.type.scope

2808 if scope is not None:

2809 scope.directives = env.directives

2810

2811 if self.doc and Options.docstrings:

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

2813

2814 if has_body:

2815 self.body.analyse_declarations(scope)

2816 if self.in_pxd:

2817 scope.defined = 1

2818 else:

2819 scope.implemented = 1

2820 env.allocate_vtable_names(self.entry)

2821

2822 def analyse_expressions(self, env):

2823 if self.body:

2824 scope = self.entry.type.scope

2825 self.body.analyse_expressions(scope)

2826

2827 def generate_function_definitions(self, env, code):

2828 if self.body:

2829 self.body.generate_function_definitions(

2830 self.entry.type.scope, code)

2831

2832 def generate_execution_code(self, code):

2833 # This is needed to generate evaluation code for

2834 # default values of method arguments.

2835 if self.body:

2836 self.body.generate_execution_code(code)

2837

2838 def annotate(self, code):

2839 if self.body:

2840 self.body.annotate(code)

2841

2842

2843 class PropertyNode(StatNode):

2844 # Definition of a property in an extension type.

2845 #

2846 # name string

2847 # doc EncodedString or None Doc string

2848 # body StatListNode

2849

2850 child_attrs = ["body"]

2851

2852 def analyse_declarations(self, env):

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

2854 if entry:

2855 entry.scope.directives = env.directives

2856 self.body.analyse_declarations(entry.scope)

2857

2858 def analyse_expressions(self, env):

2859 self.body.analyse_expressions(env)

2860

2861 def generate_function_definitions(self, env, code):

2862 self.body.generate_function_definitions(env, code)

2863

2864 def generate_execution_code(self, code):

2865 pass

2866

2867 def annotate(self, code):

2868 self.body.annotate(code)

2869

2870

2871 class GlobalNode(StatNode):

2872 # Global variable declaration.

2873 #

2874 # names [string]

2875

2876 child_attrs = []

2877

2878 def analyse_declarations(self, env):

2879 for name in self.names:

2880 env.declare_global(name, self.pos)

2881

2882 def analyse_expressions(self, env):

2883 pass

2884

2885 def generate_execution_code(self, code):

2886 pass

2887

2888

2889 class ExprStatNode(StatNode):

2890 # Expression used as a statement.

2891 #

2892 # expr ExprNode

2893

2894 child_attrs = ["expr"]

2895

2896 def analyse_declarations(self, env):

2897 import ExprNodes

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

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

2900 if func == u'declare':

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

2902 if len(args):

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

2904 for var, type_node in kwds.key_value_pairs:

2905 type = type_node.analyse_as_type(env)

2906 if type is None:

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

2908 else:

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

2910 self.__class__ = PassStatNode

2911

2912 def analyse_expressions(self, env):

2913 self.expr.analyse_expressions(env)

2914

2915 def generate_execution_code(self, code):

2916 self.expr.generate_evaluation_code(code)

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

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

2919 self.expr.generate_disposal_code(code)

2920 self.expr.free_temps(code)

2921

2922 def annotate(self, code):

2923 self.expr.annotate(code)

2924

2925

2926 class AssignmentNode(StatNode):

2927 # Abstract base class for assignment nodes.

2928 #

2929 # The analyse_expressions and generate_execution_code

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

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

2932 # parallel assignment to be evaluated before assigning

2933 # to any of the left hand sides.

2934

2935 def analyse_expressions(self, env):

2936 self.analyse_types(env)

2937

2938 # def analyse_expressions(self, env):

2939 # self.analyse_expressions_1(env)

2940 # self.analyse_expressions_2(env)

2941

2942 def generate_execution_code(self, code):

2943 self.generate_rhs_evaluation_code(code)

2944 self.generate_assignment_code(code)

2945

2946

2947 class SingleAssignmentNode(AssignmentNode):

2948 # The simplest case:

2949 #

2950 # a = b

2951 #

2952 # lhs ExprNode Left hand side

2953 # rhs ExprNode Right hand side

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

2955

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

2957 first = False

2958 declaration_only = False

2959

2960 def analyse_declarations(self, env):

2961 import ExprNodes

2962

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

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

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

2966 if func_name:

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

2968

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

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

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

2972 return

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

2974 if type is None:

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

2976 return

2977 lhs = self.lhs

2978 if func_name == 'declare':

2979 if isinstance(lhs, ExprNodes.NameNode):

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

2981 elif isinstance(lhs, ExprNodes.TupleNode):

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

2983 else:

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

2985 return

2986 for var, pos in vars:

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

2988 if len(args) == 2:

2989 # we have a value

2990 self.rhs = args[1]

2991 else:

2992 self.declaration_only = True

2993 else:

2994 self.declaration_only = True

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

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

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

2998

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

3000 self.declaration_only = True

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

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

3003 return

3004 members = []

3005 for member, type_node in kwds.key_value_pairs:

3006 type = type_node.analyse_as_type(env)

3007 if type is None:

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

3009 else:

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

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

3012 return

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

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

3015 name = self.lhs.name

3016 scope = StructOrUnionScope(name)

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

3018 for member, type, pos in members:

3019 scope.declare_var(member, type, pos)

3020

3021 if self.declaration_only:

3022 return

3023 else:

3024 self.lhs.analyse_target_declaration(env)

3025

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

3027 self.rhs.analyse_types(env)

3028 self.lhs.analyse_target_types(env)

3029 self.lhs.gil_assignment_check(env)

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

3031 if use_temp:

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

3033

3034 def generate_rhs_evaluation_code(self, code):

3035 self.rhs.generate_evaluation_code(code)

3036

3037 def generate_assignment_code(self, code):

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

3039

3040 def annotate(self, code):

3041 self.lhs.annotate(code)

3042 self.rhs.annotate(code)

3043

3044

3045 class CascadedAssignmentNode(AssignmentNode):

3046 # An assignment with multiple left hand sides:

3047 #

3048 # a = b = c

3049 #

3050 # lhs_list [ExprNode] Left hand sides

3051 # rhs ExprNode Right hand sides

3052 #

3053 # Used internally:

3054 #

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

3056

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

3058 coerced_rhs_list = None

3059

3060 def analyse_declarations(self, env):

3061 for lhs in self.lhs_list:

3062 lhs.analyse_target_declaration(env)

3063

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

3065 self.rhs.analyse_types(env)

3066 if not self.rhs.is_simple():

3067 if use_temp:

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

3069 else:

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

3071 from ExprNodes import CloneNode

3072 self.coerced_rhs_list = []

3073 for lhs in self.lhs_list:

3074 lhs.analyse_target_types(env)

3075 lhs.gil_assignment_check(env)

3076 rhs = CloneNode(self.rhs)

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

3078 self.coerced_rhs_list.append(rhs)

3079

3080 def generate_rhs_evaluation_code(self, code):

3081 self.rhs.generate_evaluation_code(code)

3082

3083 def generate_assignment_code(self, code):

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

3085 lhs = self.lhs_list[i]

3086 rhs = self.coerced_rhs_list[i]

3087 rhs.generate_evaluation_code(code)

3088 lhs.generate_assignment_code(rhs, code)

3089 # Assignment has disposed of the cloned RHS

3090 self.rhs.generate_disposal_code(code)

3091 self.rhs.free_temps(code)

3092

3093 def annotate(self, code):

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

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

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

3097 self.rhs.annotate(code)

3098

3099

3100 class ParallelAssignmentNode(AssignmentNode):

3101 # A combined packing/unpacking assignment:

3102 #

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

3104 #

3105 # This has been rearranged by the parser into

3106 #

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

3108 #

3109 # but we must evaluate all the right hand sides

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

3111 #

3112 # stats [AssignmentNode] The constituent assignments

3113

3114 child_attrs = ["stats"]

3115

3116 def analyse_declarations(self, env):

3117 for stat in self.stats:

3118 stat.analyse_declarations(env)

3119

3120 def analyse_expressions(self, env):

3121 for stat in self.stats:

3122 stat.analyse_types(env, use_temp = 1)

3123

3124 # def analyse_expressions(self, env):

3125 # for stat in self.stats:

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

3127 # for stat in self.stats:

3128 # stat.analyse_expressions_2(env)

3129

3130 def generate_execution_code(self, code):

3131 for stat in self.stats:

3132 stat.generate_rhs_evaluation_code(code)

3133 for stat in self.stats:

3134 stat.generate_assignment_code(code)

3135

3136 def annotate(self, code):

3137 for stat in self.stats:

3138 stat.annotate(code)

3139

3140

3141 class InPlaceAssignmentNode(AssignmentNode):

3142 # An in place arithmatic operand:

3143 #

3144 # a += b

3145 # a -= b

3146 # ...

3147 #

3148 # lhs ExprNode Left hand side

3149 # rhs ExprNode Right hand side

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

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

3152 #

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

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

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

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

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

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

3159

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

3161 dup = None

3162

3163 def analyse_declarations(self, env):

3164 self.lhs.analyse_target_declaration(env)

3165

3166 def analyse_types(self, env):

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

3168 self.rhs.analyse_types(env)

3169 self.lhs.analyse_target_types(env)

3170 import ExprNodes

3171 if self.lhs.type.is_pyobject:

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

3173 elif self.rhs.type.is_pyobject:

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

3175 if self.lhs.type.is_pyobject:

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

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

3178

3179 def generate_execution_code(self, code):

3180 import ExprNodes

3181 self.rhs.generate_evaluation_code(code)

3182 self.dup.generate_subexpr_evaluation_code(code)

3183 if self.dup.is_temp:

3184 self.dup.allocate_temp_result(code)

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

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

3187 extra = ", Py_None"

3188 else:

3189 extra = ""

3190 if self.lhs.type.is_pyobject:

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

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

3193 self.dup.generate_result_code(code)

3194 self.result_value_temp.allocate(code)

3195 code.putln(

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

3197 self.result_value.result(),

3198 self.py_operation_function(),

3199 self.dup.py_result(),

3200 self.rhs.py_result(),

3201 extra,

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

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

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

3205 self.rhs.generate_disposal_code(code)

3206 self.rhs.free_temps(code)

3207 self.dup.generate_disposal_code(code)

3208 self.dup.free_temps(code)

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

3210 self.result_value_temp.release(code)

3211 else:

3212 c_op = self.operator

3213 if c_op == "//":

3214 c_op = "/"

3215 elif c_op == "**":

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

3217 elif self.lhs.type.is_complex:

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

3219

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

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

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

3223 else:

3224 self.dup.generate_result_code(code)

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

3226 self.rhs.generate_disposal_code(code)

3227 self.rhs.free_temps(code)

3228 if self.dup.is_temp:

3229 self.dup.generate_subexpr_disposal_code(code)

3230 self.dup.free_subexpr_temps(code)

3231

3232 def create_dup_node(self, env):

3233 import ExprNodes

3234 self.dup = self.lhs

3235 self.dup.analyse_types(env)

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

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

3238 name = self.dup.name,

3239 is_temp = self.dup.is_temp,

3240 entry = self.dup.entry)

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

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

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

3244 attribute = self.dup.attribute,

3245 is_temp = self.dup.is_temp)

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

3247 if self.lhs.index:

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

3249 else:

3250 index = None

3251 if self.lhs.indices:

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

3253 else:

3254 indices = []

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

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

3257 index = index,

3258 indices = indices,

3259 is_temp = self.dup.is_temp)

3260 else:

3261 assert False

3262 self.lhs = target_lhs

3263 return self.dup

3264

3265 def py_operation_function(self):

3266 return self.py_functions[self.operator]

3267

3268 py_functions = {

3269 "|": "PyNumber_InPlaceOr",

3270 "^": "PyNumber_InPlaceXor",

3271 "&": "PyNumber_InPlaceAnd",

3272 "+": "PyNumber_InPlaceAdd",

3273 "-": "PyNumber_InPlaceSubtract",

3274 "*": "PyNumber_InPlaceMultiply",

3275 "/": "__Pyx_PyNumber_InPlaceDivide",

3276 "%": "PyNumber_InPlaceRemainder",

3277 "<<": "PyNumber_InPlaceLshift",

3278 ">>": "PyNumber_InPlaceRshift",

3279 "**": "PyNumber_InPlacePower",

3280 "//": "PyNumber_InPlaceFloorDivide",

3281 }

3282

3283 def annotate(self, code):

3284 self.lhs.annotate(code)

3285 self.rhs.annotate(code)

3286 self.dup.annotate(code)

3287

3288 def create_binop_node(self):

3289 import ExprNodes

3290 return ExprNodes.binop_node(self.pos, self.operator, self.lhs, self.rhs)

3291

3292

3293 class PrintStatNode(StatNode):

3294 # print statement

3295 #

3296 # arg_tuple TupleNode

3297 # append_newline boolean

3298

3299 child_attrs = ["arg_tuple"]

3300

3301 def analyse_expressions(self, env):

3302 self.arg_tuple.analyse_expressions(env)

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

3304 env.use_utility_code(printing_utility_code)

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

3306 env.use_utility_code(printing_one_utility_code)

3307

3308 nogil_check = Node.gil_error

3309 gil_message = "Python print statement"

3310

3311 def generate_execution_code(self, code):

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

3313 arg = self.arg_tuple.args[0]

3314 arg.generate_evaluation_code(code)

3315

3316 code.putln(

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

3318 arg.py_result(),

3319 code.error_goto(self.pos)))

3320 arg.generate_disposal_code(code)

3321 arg.free_temps(code)

3322 else:

3323 self.arg_tuple.generate_evaluation_code(code)

3324 code.putln(

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

3326 self.arg_tuple.py_result(),

3327 self.append_newline,

3328 code.error_goto(self.pos)))

3329 self.arg_tuple.generate_disposal_code(code)

3330 self.arg_tuple.free_temps(code)

3331

3332 def annotate(self, code):

3333 self.arg_tuple.annotate(code)

3334

3335

3336 class ExecStatNode(StatNode):

3337 # exec statement

3338 #

3339 # args [ExprNode]

3340

3341 child_attrs = ["args"]

3342

3343 def analyse_expressions(self, env):

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

3345 arg.analyse_expressions(env)

3346 arg = arg.coerce_to_pyobject(env)

3347 self.args[i] = arg

3348 env.use_utility_code(Builtin.pyexec_utility_code)

3349

3350 nogil_check = Node.gil_error

3351 gil_message = "Python exec statement"

3352

3353 def generate_execution_code(self, code):

3354 args = []

3355 for arg in self.args:

3356 arg.generate_evaluation_code(code)

3357 args.append( arg.py_result() )

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

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

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

3361 (temp_result,) + args))

3362 for arg in self.args:

3363 arg.generate_disposal_code(code)

3364 arg.free_temps(code)

3365 code.putln(

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

3367 code.put_gotref(temp_result)

3368 code.put_decref_clear(temp_result, py_object_type)

3369 code.funcstate.release_temp(temp_result)

3370

3371 def annotate(self, code):

3372 for arg in self.args:

3373 arg.annotate(code)

3374

3375

3376 class DelStatNode(StatNode):

3377 # del statement

3378 #

3379 # args [ExprNode]

3380

3381 child_attrs = ["args"]

3382

3383 def analyse_declarations(self, env):

3384 for arg in self.args:

3385 arg.analyse_target_declaration(env)

3386

3387 def analyse_expressions(self, env):

3388 for arg in self.args:

3389 arg.analyse_target_expression(env, None)

3390 if not arg.type.is_pyobject:

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

3392 #arg.release_target_temp(env)

3393

3394 def nogil_check(self, env):

3395 for arg in self.args:

3396 if arg.type.is_pyobject:

3397 self.gil_error()

3398

3399 gil_message = "Deleting Python object"

3400

3401 def generate_execution_code(self, code):

3402 for arg in self.args:

3403 if arg.type.is_pyobject:

3404 arg.generate_deletion_code(code)

3405 # else error reported earlier

3406

3407 def annotate(self, code):

3408 for arg in self.args:

3409 arg.annotate(code)

3410

3411

3412 class PassStatNode(StatNode):

3413 # pass statement

3414

3415 child_attrs = []

3416

3417 def analyse_expressions(self, env):

3418 pass

3419

3420 def generate_execution_code(self, code):

3421 pass

3422

3423

3424 class BreakStatNode(StatNode):

3425

3426 child_attrs = []

3427

3428 def analyse_expressions(self, env):

3429 pass

3430

3431 def generate_execution_code(self, code):

3432 if not code.break_label:

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

3434 else:

3435 code.put_goto(code.break_label)

3436

3437

3438 class ContinueStatNode(StatNode):

3439

3440 child_attrs = []

3441

3442 def analyse_expressions(self, env):

3443 pass

3444

3445 def generate_execution_code(self, code):

3446 if code.funcstate.in_try_finally:

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

3448 elif not code.continue_label:

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

3450 else:

3451 code.put_goto(code.continue_label)

3452

3453

3454 class ReturnStatNode(StatNode):

3455 # return statement

3456 #

3457 # value ExprNode or None

3458 # return_type PyrexType

3459

3460 child_attrs = ["value"]

3461

3462 def analyse_expressions(self, env):

3463 return_type = env.return_type

3464 self.return_type = return_type

3465 if not return_type:

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

3467 return

3468 if self.value:

3469 self.value.analyse_types(env)

3470 if return_type.is_void or return_type.is_returncode:

3471 error(self.value.pos,

3472 "Return with value in void function")

3473 else:

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

3475 else:

3476 if (not return_type.is_void

3477 and not return_type.is_pyobject

3478 and not return_type.is_returncode):

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

3480

3481 def nogil_check(self, env):

3482 if self.return_type.is_pyobject:

3483 self.gil_error()

3484

3485 gil_message = "Returning Python object"

3486

3487 def generate_execution_code(self, code):

3488 code.mark_pos(self.pos)

3489 if not self.return_type:

3490 # error reported earlier

3491 return

3492 if self.return_type.is_pyobject:

3493 code.put_xdecref(Naming.retval_cname,

3494 self.return_type)

3495 if self.value:

3496 self.value.generate_evaluation_code(code)

3497 self.value.make_owned_reference(code)

3498 code.putln(

3499 "%s = %s;" % (

3500 Naming.retval_cname,

3501 self.value.result_as(self.return_type)))

3502 self.value.generate_post_assignment_code(code)

3503 self.value.free_temps(code)

3504 else:

3505 if self.return_type.is_pyobject:

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

3507 elif self.return_type.is_returncode:

3508 code.putln(

3509 "%s = %s;" % (

3510 Naming.retval_cname,

3511 self.return_type.default_value))

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

3513 code.put_decref_clear(cname, type)

3514 code.put_goto(code.return_label)

3515

3516 def annotate(self, code):

3517 if self.value:

3518 self.value.annotate(code)

3519

3520

3521 class RaiseStatNode(StatNode):

3522 # raise statement

3523 #

3524 # exc_type ExprNode or None

3525 # exc_value ExprNode or None

3526 # exc_tb ExprNode or None

3527

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

3529

3530 def analyse_expressions(self, env):

3531 if self.exc_type:

3532 self.exc_type.analyse_types(env)

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

3534 if self.exc_value:

3535 self.exc_value.analyse_types(env)

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

3537 if self.exc_tb:

3538 self.exc_tb.analyse_types(env)

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

3540 env.use_utility_code(raise_utility_code)

3541

3542 nogil_check = Node.gil_error

3543 gil_message = "Raising exception"

3544

3545 def generate_execution_code(self, code):

3546 if self.exc_type:

3547 self.exc_type.generate_evaluation_code(code)

3548 type_code = self.exc_type.py_result()

3549 else:

3550 type_code = "0"

3551 if self.exc_value:

3552 self.exc_value.generate_evaluation_code(code)

3553 value_code = self.exc_value.py_result()

3554 else:

3555 value_code = "0"

3556 if self.exc_tb:

3557 self.exc_tb.generate_evaluation_code(code)

3558 tb_code = self.exc_tb.py_result()

3559 else:

3560 tb_code = "0"

3561 code.putln(

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

3563 type_code,

3564 value_code,

3565 tb_code))

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

3567 if obj:

3568 obj.generate_disposal_code(code)

3569 obj.free_temps(code)

3570 code.putln(

3571 code.error_goto(self.pos))

3572

3573 def annotate(self, code):

3574 if self.exc_type:

3575 self.exc_type.annotate(code)

3576 if self.exc_value:

3577 self.exc_value.annotate(code)

3578 if self.exc_tb:

3579 self.exc_tb.annotate(code)

3580

3581

3582 class ReraiseStatNode(StatNode):

3583

3584 child_attrs = []

3585

3586 def analyse_expressions(self, env):

3587 env.use_utility_code(restore_exception_utility_code)

3588

3589 nogil_check = Node.gil_error

3590 gil_message = "Raising exception"

3591

3592 def generate_execution_code(self, code):

3593 vars = code.funcstate.exc_vars

3594 if vars:

3595 for varname in vars:

3596 code.put_giveref(varname)

3597 code.putln("__Pyx_ErrRestore(%s, %s, %s);" % tuple(vars))

3598 for varname in vars:

3599 code.put("%s = 0; " % varname)

3600 code.putln()

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

3602 else:

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

3604

3605

3606 class AssertStatNode(StatNode):

3607 # assert statement

3608 #

3609 # cond ExprNode

3610 # value ExprNode or None

3611

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

3613

3614 def analyse_expressions(self, env):

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

3616 if self.value:

3617 self.value.analyse_types(env)

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

3619

3620 nogil_check = Node.gil_error

3621 gil_message = "Raising exception"

3622

3623 def generate_execution_code(self, code):

3624 code.putln("#ifndef PYREX_WITHOUT_ASSERTIONS")

3625 self.cond.generate_evaluation_code(code)

3626 code.putln(

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

3628 self.cond.result())

3629 if self.value:

3630 self.value.generate_evaluation_code(code)

3631 code.putln(

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

3633 self.value.py_result())

3634 self.value.generate_disposal_code(code)

3635 self.value.free_temps(code)

3636 else:

3637 code.putln(

3638 "PyErr_SetNone(PyExc_AssertionError);")

3639 code.putln(

3640 code.error_goto(self.pos))

3641 code.putln(

3642 "}")

3643 self.cond.generate_disposal_code(code)

3644 self.cond.free_temps(code)

3645 code.putln("#endif")

3646

3647 def annotate(self, code):

3648 self.cond.annotate(code)

3649 if self.value:

3650 self.value.annotate(code)

3651

3652

3653 class IfStatNode(StatNode):

3654 # if statement

3655 #

3656 # if_clauses [IfClauseNode]

3657 # else_clause StatNode or None

3658

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

3660

3661 def analyse_control_flow(self, env):

3662 env.start_branching(self.pos)

3663 for if_clause in self.if_clauses:

3664 if_clause.analyse_control_flow(env)

3665 env.next_branch(if_clause.end_pos())

3666 if self.else_clause:

3667 self.else_clause.analyse_control_flow(env)

3668 env.finish_branching(self.end_pos())

3669

3670 def analyse_declarations(self, env):

3671 for if_clause in self.if_clauses:

3672 if_clause.analyse_declarations(env)

3673 if self.else_clause:

3674 self.else_clause.analyse_declarations(env)

3675

3676 def analyse_expressions(self, env):

3677 for if_clause in self.if_clauses:

3678 if_clause.analyse_expressions(env)

3679 if self.else_clause:

3680 self.else_clause.analyse_expressions(env)

3681

3682 def generate_execution_code(self, code):

3683 code.mark_pos(self.pos)

3684 end_label = code.new_label()

3685 for if_clause in self.if_clauses:

3686 if_clause.generate_execution_code(code, end_label)

3687 if self.else_clause:

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

3689 self.else_clause.generate_execution_code(code)

3690 code.putln("}")

3691 code.put_label(end_label)

3692

3693 def annotate(self, code):

3694 for if_clause in self.if_clauses:

3695 if_clause.annotate(code)

3696 if self.else_clause:

3697 self.else_clause.annotate(code)

3698

3699

3700 class IfClauseNode(Node):

3701 # if or elif clause in an if statement

3702 #

3703 # condition ExprNode

3704 # body StatNode

3705

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

3707

3708 def analyse_control_flow(self, env):

3709 self.body.analyse_control_flow(env)

3710

3711 def analyse_declarations(self, env):

3712 self.condition.analyse_declarations(env)

3713 self.body.analyse_declarations(env)

3714

3715 def analyse_expressions(self, env):

3716 self.condition = \

3717 self.condition.analyse_temp_boolean_expression(env)

3718 self.body.analyse_expressions(env)

3719

3720 def generate_execution_code(self, code, end_label):

3721 self.condition.generate_evaluation_code(code)

3722 code.putln(

3723 "if (%s) {" %

3724 self.condition.result())

3725 self.condition.generate_disposal_code(code)

3726 self.condition.free_temps(code)

3727 self.body.generate_execution_code(code)

3728 #code.putln(

3729 # "goto %s;" %

3730 # end_label)

3731 code.put_goto(end_label)

3732 code.putln("}")

3733

3734 def annotate(self, code):

3735 self.condition.annotate(code)

3736 self.body.annotate(code)

3737

3738

3739 class SwitchCaseNode(StatNode):

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

3741 #

3742 # conditions [ExprNode]

3743 # body StatNode

3744

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

3746

3747 def generate_execution_code(self, code):

3748 for cond in self.conditions:

3749 code.mark_pos(cond.pos)

3750 cond.generate_evaluation_code(code)

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

3752 self.body.generate_execution_code(code)

3753 code.putln("break;")

3754

3755 def annotate(self, code):

3756 for cond in self.conditions:

3757 cond.annotate(code)

3758 self.body.annotate(code)

3759

3760 class SwitchStatNode(StatNode):

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

3762 #

3763 # test ExprNode

3764 # cases [SwitchCaseNode]

3765 # else_clause StatNode or None

3766

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

3768

3769 def generate_execution_code(self, code):

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

3771 for case in self.cases:

3772 case.generate_execution_code(code)

3773 if self.else_clause is not None:

3774 code.putln("default:")

3775 self.else_clause.generate_execution_code(code)

3776 code.putln("break;")

3777 code.putln("}")

3778

3779 def annotate(self, code):

3780 self.test.annotate(code)

3781 for case in self.cases:

3782 case.annotate(code)

3783 if self.else_clause is not None:

3784 self.else_clause.annotate(code)

3785

3786 class LoopNode(object):

3787

3788 def analyse_control_flow(self, env):

3789 env.start_branching(self.pos)

3790 self.body.analyse_control_flow(env)

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

3792 if self.else_clause:

3793 self.else_clause.analyse_control_flow(env)

3794 env.finish_branching(self.end_pos())

3795

3796

3797 class WhileStatNode(LoopNode, StatNode):

3798 # while statement

3799 #

3800 # condition ExprNode

3801 # body StatNode

3802 # else_clause StatNode

3803

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

3805

3806 def analyse_declarations(self, env):

3807 self.body.analyse_declarations(env)

3808 if self.else_clause:

3809 self.else_clause.analyse_declarations(env)

3810

3811 def analyse_expressions(self, env):

3812 self.condition = \

3813 self.condition.analyse_temp_boolean_expression(env)

3814 self.body.analyse_expressions(env)

3815 if self.else_clause:

3816 self.else_clause.analyse_expressions(env)

3817

3818 def generate_execution_code(self, code):

3819 old_loop_labels = code.new_loop_labels()

3820 code.putln(

3821 "while (1) {")

3822 self.condition.generate_evaluation_code(code)

3823 self.condition.generate_disposal_code(code)

3824 code.putln(

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

3826 self.condition.result())

3827 self.condition.free_temps(code)

3828 self.body.generate_execution_code(code)

3829 code.put_label(code.continue_label)

3830 code.putln("}")

3831 break_label = code.break_label

3832 code.set_loop_labels(old_loop_labels)

3833 if self.else_clause:

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

3835 self.else_clause.generate_execution_code(code)

3836 code.putln("}")

3837 code.put_label(break_label)

3838

3839 def annotate(self, code):

3840 self.condition.annotate(code)

3841 self.body.annotate(code)

3842 if self.else_clause:

3843 self.else_clause.annotate(code)

3844

3845

3846 def ForStatNode(pos, **kw):

3847 if 'iterator' in kw:

3848 return ForInStatNode(pos, **kw)

3849 else:

3850 return ForFromStatNode(pos, **kw)

3851

3852 class ForInStatNode(LoopNode, StatNode):

3853 # for statement

3854 #

3855 # target ExprNode

3856 # iterator IteratorNode

3857 # body StatNode

3858 # else_clause StatNode

3859 # item NextNode used internally

3860

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

3862 item = None

3863

3864 def analyse_declarations(self, env):

3865 self.target.analyse_target_declaration(env)

3866 self.body.analyse_declarations(env)

3867 if self.else_clause:

3868 self.else_clause.analyse_declarations(env)

3869

3870 def analyse_expressions(self, env):

3871 import ExprNodes

3872 self.target.analyse_target_types(env)

3873 self.iterator.analyse_expressions(env)

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

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

3876 self.body.analyse_expressions(env)

3877 if self.else_clause:

3878 self.else_clause.analyse_expressions(env)

3879

3880 def generate_execution_code(self, code):

3881 old_loop_labels = code.new_loop_labels()

3882 self.iterator.allocate_counter_temp(code)

3883 self.iterator.generate_evaluation_code(code)

3884 code.putln(

3885 "for (;;) {")

3886 self.item.generate_evaluation_code(code)

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

3888 self.body.generate_execution_code(code)

3889 code.put_label(code.continue_label)

3890 code.putln(

3891 "}")

3892 break_label = code.break_label

3893 code.set_loop_labels(old_loop_labels)

3894 if self.else_clause:

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

3896 self.else_clause.generate_execution_code(code)

3897 code.putln("}")

3898 code.put_label(break_label)

3899 self.iterator.release_counter_temp(code)

3900 self.iterator.generate_disposal_code(code)

3901 self.iterator.free_temps(code)

3902

3903 def annotate(self, code):

3904 self.target.annotate(code)

3905 self.iterator.annotate(code)

3906 self.body.annotate(code)

3907 if self.else_clause:

3908 self.else_clause.annotate(code)

3909 self.item.annotate(code)

3910

3911

3912 class ForFromStatNode(LoopNode, StatNode):

3913 # for name from expr rel name rel expr

3914 #

3915 # target NameNode

3916 # bound1 ExprNode

3917 # relation1 string

3918 # relation2 string

3919 # bound2 ExprNode

3920 # step ExprNode or None

3921 # body StatNode

3922 # else_clause StatNode or None

3923 #

3924 # Used internally:

3925 #

3926 # from_range bool

3927 # is_py_target bool

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

3929 # py_loopvar_node PyTempNode or None

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

3931

3932 is_py_target = False

3933 loopvar_node = None

3934 py_loopvar_node = None

3935 from_range = False

3936

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

3938

3939 def nogil_check(self, env):

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

3941 if x.type.is_pyobject:

3942 self.gil_error()

3943

3944 def analyse_declarations(self, env):

3945 self.target.analyse_target_declaration(env)

3946 self.body.analyse_declarations(env)

3947 if self.else_clause:

3948 self.else_clause.analyse_declarations(env)

3949

3950 def analyse_expressions(self, env):

3951 import ExprNodes

3952 self.target.analyse_target_types(env)

3953 self.bound1.analyse_types(env)

3954 self.bound2.analyse_types(env)

3955 if self.step is not None:

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

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

3958 self.step.analyse_types(env)

3959

3960 target_type = self.target.type

3961 if self.target.type.is_numeric:

3962 loop_type = self.target.type

3963 else:

3964 loop_type = PyrexTypes.c_int_type

3965 if not self.bound1.type.is_pyobject:

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

3967 if not self.bound2.type.is_pyobject:

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

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

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

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

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