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 entry = env.declare_var(arg.name,

1876 PyrexTypes.py_object_type, arg.pos)

1877 entry.used = 1

1878 entry.init = "0"

1879 entry.init_to_none = 0

1880 entry.xdecref_cleanup = 1

1881 arg.entry = entry

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

1883

1884 def analyse_expressions(self, env):

1885 self.local_scope.directives = env.directives

1886 self.analyse_default_values(env)

1887 if env.is_py_class_scope:

1888 self.synthesize_assignment_node(env)

1889

1890 def synthesize_assignment_node(self, env):

1891 import ExprNodes

1892 self.assmt = SingleAssignmentNode(self.pos,

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

1894 rhs = ExprNodes.UnboundMethodNode(self.pos,

1895 function = ExprNodes.PyCFunctionNode(self.pos,

1896 pymethdef_cname = self.entry.pymethdef_cname)))

1897 self.assmt.analyse_declarations(env)

1898 self.assmt.analyse_expressions(env)

1899

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

1901 arg_code_list = []

1902 sig = self.entry.signature

1903 if sig.has_dummy_arg or self.self_in_stararg:

1904 arg_code_list.append(

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

1906 for arg in self.args:

1907 if not arg.is_generic:

1908 if arg.is_self_arg or arg.is_type_arg:

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

1910 else:

1911 arg_code_list.append(

1912 arg.hdr_type.declaration_code(arg.hdr_cname))

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

1914 arg_code_list.append("PyObject *unused")

1915 if sig.has_generic_args:

1916 arg_code_list.append(

1917 "PyObject *%s, PyObject *%s"

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

1919 arg_code = ", ".join(arg_code_list)

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

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

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

1923 if proto_only:

1924 return

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

1926 docstr = self.entry.doc

1927 if docstr.is_unicode:

1928 docstr = docstr.utf8encode()

1929 code.putln(

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

1931 self.entry.doc_cname,

1932 split_docstring(escape_byte_string(docstr))))

1933 if with_pymethdef:

1934 code.put(

1935 "static PyMethodDef %s = " %

1936 self.entry.pymethdef_cname)

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

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

1939

1940 def generate_argument_declarations(self, env, code):

1941 for arg in self.args:

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

1943 if arg.needs_conversion:

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

1945 else:

1946 code.put_var_declaration(arg.entry)

1947

1948 def generate_keyword_list(self, code):

1949 if self.signature_has_generic_args() and \

1950 self.signature_has_nongeneric_args():

1951 code.put(

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

1953 Naming.pykwdlist_cname)

1954 for arg in self.args:

1955 if arg.is_generic:

1956 pystring_cname = code.intern_identifier(arg.name)

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

1958 code.putln("0};")

1959

1960 def generate_argument_parsing_code(self, env, code):

1961 # Generate PyArg_ParseTuple call for generic

1962 # arguments, if any.

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

1964 # get rid of unused argument warning

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

1966

1967 old_error_label = code.new_error_label()

1968 our_error_label = code.error_label

1969 end_label = code.new_label("argument_unpacking_done")

1970

1971 has_kwonly_args = self.num_kwonly_args > 0

1972 has_star_or_kw_args = self.star_arg is not None \

1973 or self.starstar_arg is not None or has_kwonly_args

1974

1975 for arg in self.args:

1976 if not arg.type.is_pyobject:

1977 done = arg.type.create_from_py_utility_code(env)

1978 if not done: pass # will fail later

1979

1980 if not self.signature_has_generic_args():

1981 if has_star_or_kw_args:

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

1983 self.generate_argument_conversion_code(code)

1984

1985 elif not self.signature_has_nongeneric_args():

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

1987 self.generate_stararg_copy_code(code)

1988

1989 else:

1990 positional_args = []

1991 kw_only_args = []

1992 for arg in self.args:

1993 arg_entry = arg.entry

1994 if arg.is_generic:

1995 if arg.default:

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

1997 if arg.kw_only:

1998 kw_only_args.append(arg)

1999 else:

2000 positional_args.append(arg)

2001 elif arg.kw_only:

2002 kw_only_args.append(arg)

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

2004 positional_args.append(arg)

2005

2006 self.generate_tuple_and_keyword_parsing_code(

2007 positional_args, kw_only_args, end_label, code)

2008

2009 code.error_label = old_error_label

2010 if code.label_used(our_error_label):

2011 if not code.label_used(end_label):

2012 code.put_goto(end_label)

2013 code.put_label(our_error_label)

2014 if has_star_or_kw_args:

2015 self.generate_arg_decref(self.star_arg, code)

2016 if self.starstar_arg:

2017 if self.starstar_arg.entry.xdecref_cleanup:

2018 code.put_var_xdecref(self.starstar_arg.entry)

2019 else:

2020 code.put_var_decref(self.starstar_arg.entry)

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

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

2023 if code.label_used(end_label):

2024 code.put_label(end_label)

2025

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

2027 if arg.type.is_pyobject:

2028 if arg.is_generic:

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

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

2031 else:

2032 func = arg.type.from_py_function

2033 if func:

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

2035 arg.entry.cname,

2036 func,

2037 item,

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

2039 else:

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

2041

2042 def generate_arg_xdecref(self, arg, code):

2043 if arg:

2044 code.put_var_xdecref(arg.entry)

2045

2046 def generate_arg_decref(self, arg, code):

2047 if arg:

2048 code.put_var_decref(arg.entry)

2049

2050 def generate_stararg_copy_code(self, code):

2051 if not self.star_arg:

2052 code.globalstate.use_utility_code(raise_argtuple_invalid_utility_code)

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

2054 Naming.args_cname)

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

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

2057 code.putln("}")

2058

2059 code.globalstate.use_utility_code(keyword_string_check_utility_code)

2060

2061 if self.starstar_arg:

2062 if self.star_arg:

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

2064 else:

2065 kwarg_check = "%s" % Naming.kwds_cname

2066 else:

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

2068 Naming.kwds_cname, Naming.kwds_cname)

2069 code.putln(

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

2071 kwarg_check, Naming.kwds_cname, self.name,

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

2073

2074 if self.starstar_arg:

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

2076 self.starstar_arg.entry.cname,

2077 Naming.kwds_cname,

2078 Naming.kwds_cname))

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

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

2081 self.starstar_arg.entry.xdecref_cleanup = 0

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

2083

2084 if self.self_in_stararg:

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

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

2087 self.star_arg.entry.cname,

2088 Naming.args_cname,

2089 self.star_arg.entry.cname))

2090 if self.starstar_arg:

2091 code.putln("{")

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

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

2094 code.putln("}")

2095 else:

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

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

2098 code.put_incref(Naming.self_cname, py_object_type)

2099 code.put_giveref(Naming.self_cname)

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

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

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

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

2104 temp, temp, Naming.args_cname, temp))

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

2106 Naming.args_cname, temp))

2107 code.put_incref("item", py_object_type)

2108 code.put_giveref("item")

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

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

2111 code.putln("}")

2112 code.funcstate.release_temp(temp)

2113 self.star_arg.entry.xdecref_cleanup = 0

2114 elif self.star_arg:

2115 code.put_incref(Naming.args_cname, py_object_type)

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

2117 self.star_arg.entry.cname,

2118 Naming.args_cname))

2119 self.star_arg.entry.xdecref_cleanup = 0

2120

2121 def generate_tuple_and_keyword_parsing_code(self, positional_args,

2122 kw_only_args, success_label, code):

2123 argtuple_error_label = code.new_label("argtuple_error")

2124

2125 min_positional_args = self.num_required_args - self.num_required_kw_args

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

2127 min_positional_args -= 1

2128 max_positional_args = len(positional_args)

2129 has_fixed_positional_count = not self.star_arg and \

2130 min_positional_args == max_positional_args

2131

2132 code.globalstate.use_utility_code(raise_double_keywords_utility_code)

2133 code.globalstate.use_utility_code(raise_argtuple_invalid_utility_code)

2134 if self.num_required_kw_args:

2135 code.globalstate.use_utility_code(raise_keyword_required_utility_code)

2136

2137 if self.starstar_arg or self.star_arg:

2138 self.generate_stararg_init_code(max_positional_args, code)

2139

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

2141 if self.num_required_kw_args:

2142 likely_hint = "likely"

2143 else:

2144 likely_hint = "unlikely"

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

2146 self.generate_keyword_unpacking_code(

2147 min_positional_args, max_positional_args,

2148 has_fixed_positional_count,

2149 positional_args, kw_only_args, argtuple_error_label, code)

2150

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

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

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

2154 # check the length here

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

2156 compare = '!='

2157 else:

2158 compare = '<'

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

2160 Naming.args_cname, compare, min_positional_args))

2161 code.put_goto(argtuple_error_label)

2162

2163 if self.num_required_kw_args:

2164 # pure error case: keywords required but not passed

2165 if max_positional_args > min_positional_args and not self.star_arg:

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

2167 Naming.args_cname, max_positional_args))

2168 code.put_goto(argtuple_error_label)

2169 code.putln('} else {')

2170 for i, arg in enumerate(kw_only_args):

2171 if not arg.default:

2172 pystring_cname = code.intern_identifier(arg.name)

2173 # required keyword-only argument missing

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

2175 self.name,

2176 pystring_cname))

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

2178 break

2179

2180 elif min_positional_args == max_positional_args:

2181 # parse the exact number of positional arguments from the

2182 # args tuple

2183 code.putln('} else {')

2184 for i, arg in enumerate(positional_args):

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

2186 self.generate_arg_assignment(arg, item, code)

2187 self.generate_arg_default_assignments(code)

2188

2189 else:

2190 # parse the positional arguments from the variable length

2191 # args tuple

2192 code.putln('} else {')

2193 self.generate_arg_default_assignments(code)

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

2195 if self.star_arg:

2196 code.putln('default:')

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

2198 for i, arg in reversed_args:

2199 if i >= min_positional_args-1:

2200 if min_positional_args > 1:

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

2202 else:

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

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

2205 self.generate_arg_assignment(arg, item, code)

2206 if min_positional_args == 0:

2207 code.put('case 0: ')

2208 code.putln('break;')

2209 if self.star_arg:

2210 if min_positional_args:

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

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

2213 code.put_goto(argtuple_error_label)

2214 else:

2215 code.put('default: ')

2216 code.put_goto(argtuple_error_label)

2217 code.putln('}')

2218

2219 code.putln('}')

2220

2221 if code.label_used(argtuple_error_label):

2222 code.put_goto(success_label)

2223 code.put_label(argtuple_error_label)

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

2225 self.name, has_fixed_positional_count,

2226 min_positional_args, max_positional_args,

2227 Naming.args_cname))

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

2229

2230 def generate_arg_default_assignments(self, code):

2231 for arg in self.args:

2232 if arg.is_generic and arg.default:

2233 code.putln(

2234 "%s = %s;" % (

2235 arg.entry.cname,

2236 arg.calculate_default_value_code(code)))

2237

2238 def generate_stararg_init_code(self, max_positional_args, code):

2239 if self.starstar_arg:

2240 self.starstar_arg.entry.xdecref_cleanup = 0

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

2242 self.starstar_arg.entry.cname,

2243 self.starstar_arg.entry.cname,

2244 self.error_value()))

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

2246 if self.star_arg:

2247 self.star_arg.entry.xdecref_cleanup = 0

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

2249 Naming.args_cname,

2250 max_positional_args))

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

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

2253 max_positional_args, Naming.args_cname))

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

2255 if self.starstar_arg:

2256 code.putln("")

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

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

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

2260 code.putln('}')

2261 else:

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

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

2264 code.putln('} else {')

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

2266 code.put_incref(Naming.empty_tuple, py_object_type)

2267 code.putln('}')

2268

2269 def generate_keyword_unpacking_code(self, min_positional_args, max_positional_args,

2270 has_fixed_positional_count, positional_args,

2271 kw_only_args, argtuple_error_label, code):

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

2273 max_args = len(all_args)

2274

2275 default_args = []

2276 for i, arg in enumerate(all_args):

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

2278 default_value = arg.calculate_default_value_code(code)

2279 if arg.type is not PyrexTypes.py_object_type:

2280 default_value = "(PyObject*)"+default_value

2281 default_args.append((i, default_value))

2282

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

2284 Naming.kwds_cname)

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

2286 # default value, but C89 needs this

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

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

2289 for i, default_value in default_args:

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

2291

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

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

2294 if self.star_arg:

2295 code.putln('default:')

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

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

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

2299 i, Naming.args_cname, i))

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

2301 if not self.star_arg:

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

2303 code.put_goto(argtuple_error_label)

2304 code.putln('}')

2305

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

2307 # from the kw dict

2308 if self.num_required_args or max_positional_args > 0:

2309 last_required_arg = -1

2310 for i, arg in enumerate(all_args):

2311 if not arg.default:

2312 last_required_arg = i

2313 if last_required_arg < max_positional_args:

2314 last_required_arg = max_positional_args-1

2315 num_required_args = self.num_required_args

2316 if max_positional_args > 0:

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

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

2319 if max_positional_args > 0 and i <= max_positional_args:

2320 if self.star_arg and i == max_positional_args:

2321 code.putln('default:')

2322 else:

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

2324 pystring_cname = code.intern_identifier(arg.name)

2325 if arg.default:

2326 if arg.kw_only:

2327 # handled separately below

2328 continue

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

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

2331 Naming.kwds_cname, pystring_cname))

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

2333 code.putln('}')

2334 else:

2335 num_required_args -= 1

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

2337 i, Naming.kwds_cname, pystring_cname))

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

2339 if i < min_positional_args:

2340 if i == 0:

2341 # special case: we know arg 0 is missing

2342 code.put('else ')

2343 code.put_goto(argtuple_error_label)

2344 else:

2345 # print the correct number of values (args or

2346 # kwargs) that were passed into positional

2347 # arguments up to this point

2348 code.putln('else {')

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

2350 self.name, has_fixed_positional_count,

2351 min_positional_args, max_positional_args, i))

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

2353 code.putln('}')

2354 elif arg.kw_only:

2355 code.putln('else {')

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

2357 self.name, pystring_cname))

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

2359 code.putln('}')

2360 if max_positional_args > 0:

2361 code.putln('}')

2362

2363 if kw_only_args and not self.starstar_arg:

2364 # unpack optional keyword-only arguments

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

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

2367 optional_args = []

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

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

2370 continue

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

2372 if optional_args:

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

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

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

2376 for i, arg in optional_args:

2377 pystring_cname = code.intern_identifier(arg.name)

2378 code.putln(

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

2380 Naming.kwds_cname, pystring_cname))

2381 code.putln(

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

2383 code.putln('break;')

2384 code.putln('}')

2385

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

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

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

2389 #

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

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

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

2393 # common cases above.

2394 if max_positional_args == 0:

2395 pos_arg_count = "0"

2396 elif self.star_arg:

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

2398 Naming.args_cname, max_positional_args,

2399 Naming.args_cname, max_positional_args))

2400 pos_arg_count = "used_pos_args"

2401 else:

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

2403 code.globalstate.use_utility_code(parse_keywords_utility_code)

2404 code.put(

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

2406 Naming.kwds_cname,

2407 Naming.pykwdlist_cname,

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

2409 pos_arg_count,

2410 self.name))

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

2412 code.putln('}')

2413

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

2415 for i, arg in enumerate(all_args):

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

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

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

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

2420 code.putln('} else {')

2421 code.putln(

2422 "%s = %s;" % (

2423 arg.entry.cname,

2424 arg.calculate_default_value_code(code)))

2425 code.putln('}')

2426

2427 def generate_argument_conversion_code(self, code):

2428 # Generate code to convert arguments from

2429 # signature type to declared type, if needed.

2430 for arg in self.args:

2431 if arg.needs_conversion:

2432 self.generate_arg_conversion(arg, code)

2433

2434 def generate_arg_conversion(self, arg, code):

2435 # Generate conversion code for one argument.

2436 old_type = arg.hdr_type

2437 new_type = arg.type

2438 if old_type.is_pyobject:

2439 if arg.default:

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

2441 else:

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

2443 self.generate_arg_conversion_from_pyobject(arg, code)

2444 code.putln("}")

2445 elif new_type.is_pyobject:

2446 self.generate_arg_conversion_to_pyobject(arg, code)

2447 else:

2448 if new_type.assignable_from(old_type):

2449 code.putln(

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

2451 else:

2452 error(arg.pos,

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

2454 (old_type, new_type))

2455

2456 def generate_arg_conversion_from_pyobject(self, arg, code):

2457 new_type = arg.type

2458 func = new_type.from_py_function

2459 # copied from CoerceFromPyTypeNode

2460 if func:

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

2462 arg.entry.cname,

2463 func,

2464 arg.hdr_cname,

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

2466 else:

2467 error(arg.pos,

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

2469 % new_type)

2470

2471 def generate_arg_conversion_to_pyobject(self, arg, code):

2472 old_type = arg.hdr_type

2473 func = old_type.to_py_function

2474 if func:

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

2476 arg.entry.cname,

2477 func,

2478 arg.hdr_cname,

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

2480 code.put_var_gotref(arg.entry)

2481 else:

2482 error(arg.pos,

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

2484 % old_type)

2485

2486 def generate_argument_type_tests(self, code):

2487 # Generate type tests for args whose signature

2488 # type is PyObject * and whose declared type is

2489 # a subtype thereof.

2490 for arg in self.args:

2491 if arg.needs_type_test:

2492 self.generate_arg_type_test(arg, code)

2493

2494 def generate_arg_type_test(self, arg, code):

2495 # Generate type test for one argument.

2496 if arg.type.typeobj_is_available():

2497 typeptr_cname = arg.type.typeptr_cname

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

2499 code.putln(

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

2501 arg_code,

2502 typeptr_cname,

2503 not arg.not_none,

2504 arg.name,

2505 arg.type.is_builtin_type,

2506 code.error_goto(arg.pos)))

2507 else:

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

2509 "without type object name specification")

2510

2511 def error_value(self):

2512 return self.entry.signature.error_value

2513

2514 def caller_will_check_exceptions(self):

2515 return 1

2516

2517 class OverrideCheckNode(StatNode):

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

2519 # is overriden.

2520 #

2521 # py_func

2522 #

2523 # args

2524 # func_temp

2525 # body

2526

2527 child_attrs = ['body']

2528

2529 body = None

2530

2531 def analyse_expressions(self, env):

2532 self.args = env.arg_entries

2533 if self.py_func.is_module_scope:

2534 first_arg = 0

2535 else:

2536 first_arg = 1

2537 import ExprNodes

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

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

2540 call_node = ExprNodes.SimpleCallNode(self.pos,

2541 function=self.func_node,

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

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

2544 self.body.analyse_expressions(env)

2545

2546 def generate_execution_code(self, code):

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

2548 # Check to see if we are an extension type

2549 if self.py_func.is_module_scope:

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

2551 else:

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

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

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

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

2556 if self.py_func.is_module_scope:

2557 code.putln("else {")

2558 else:

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

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

2561 self.func_node.set_cname(func_node_temp)

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

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

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

2565 func_node_temp, self_arg, interned_attr_cname, err))

2566 code.put_gotref(func_node_temp)

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

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

2569 func_node_temp, self.py_func.entry.func_cname)

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

2571 self.body.generate_execution_code(code)

2572 code.putln("}")

2573 code.put_decref_clear(func_node_temp, PyrexTypes.py_object_type)

2574 code.funcstate.release_temp(func_node_temp)

2575 code.putln("}")

2576

2577 class ClassDefNode(StatNode, BlockNode):

2578 pass

2579

2580 class PyClassDefNode(ClassDefNode):

2581 # A Python class definition.

2582 #

2583 # name EncodedString Name of the class

2584 # doc string or None

2585 # body StatNode Attribute definition code

2586 # entry Symtab.Entry

2587 # scope PyClassScope

2588 # decorators [DecoratorNode] list of decorators or None

2589 #

2590 # The following subnodes are constructed internally:

2591 #

2592 # dict DictNode Class dictionary

2593 # classobj ClassNode Class object

2594 # target NameNode Variable to assign class object to

2595

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

2597 decorators = None

2598

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

2600 StatNode.__init__(self, pos)

2601 self.name = name

2602 self.doc = doc

2603 self.body = body

2604 self.decorators = decorators

2605 import ExprNodes

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

2607 if self.doc and Options.docstrings:

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

2609 # FIXME: correct string node?

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

2611 else:

2612 doc_node = None

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

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

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

2616

2617 def as_cclass(self):

2618 """

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

2620 """

2621 bases = self.classobj.bases.args

2622 if len(bases) == 0:

2623 base_class_name = None

2624 base_class_module = None

2625 elif len(bases) == 1:

2626 base = bases[0]

2627 path = []

2628 from ExprNodes import AttributeNode, NameNode

2629 while isinstance(base, AttributeNode):

2630 path.insert(0, base.attribute)

2631 base = base.obj

2632 if isinstance(base, NameNode):

2633 path.insert(0, base.name)

2634 base_class_name = path[-1]

2635 if len(path) > 1:

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

2637 else:

2638 base_class_module = None

2639 else:

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

2641 else:

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

2643 return None

2644

2645 return CClassDefNode(self.pos,

2646 visibility = 'private',

2647 module_name = None,

2648 class_name = self.name,

2649 base_class_module = base_class_module,

2650 base_class_name = base_class_name,

2651 decorators = self.decorators,

2652 body = self.body,

2653 in_pxd = False,

2654 doc = self.doc)

2655

2656 def create_scope(self, env):

2657 genv = env

2658 while env.is_py_class_scope or env.is_c_class_scope:

2659 env = env.outer_scope

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

2661 return cenv

2662

2663 def analyse_declarations(self, env):

2664 self.target.analyse_target_declaration(env)

2665 cenv = self.create_scope(env)

2666 cenv.directives = env.directives

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

2668 self.body.analyse_declarations(cenv)

2669

2670 def analyse_expressions(self, env):

2671 self.dict.analyse_expressions(env)

2672 self.classobj.analyse_expressions(env)

2673 genv = env.global_scope()

2674 cenv = self.scope

2675 self.body.analyse_expressions(cenv)

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

2677

2678 def generate_function_definitions(self, env, code):

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

2680

2681 def generate_execution_code(self, code):

2682 code.pyclass_stack.append(self)

2683 cenv = self.scope

2684 self.dict.generate_evaluation_code(code)

2685 self.classobj.generate_evaluation_code(code)

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

2687 self.body.generate_execution_code(code)

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

2689 self.dict.generate_disposal_code(code)

2690 self.dict.free_temps(code)

2691 code.pyclass_stack.pop()

2692

2693

2694 class CClassDefNode(ClassDefNode):

2695 # An extension type definition.

2696 #

2697 # visibility 'private' or 'public' or 'extern'

2698 # typedef_flag boolean

2699 # api boolean

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

2701 # class_name string Unqualified name of class

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

2703 # base_class_module string or None Module containing the base class

2704 # base_class_name string or None Name of the base class

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

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

2707 # in_pxd boolean Is in a .pxd file

2708 # decorators [DecoratorNode] list of decorators or None

2709 # doc string or None

2710 # body StatNode or None

2711 # entry Symtab.Entry

2712 # base_type PyExtensionType or None

2713 # buffer_defaults_node DictNode or None Declares defaults for a buffer

2714 # buffer_defaults_pos

2715

2716 child_attrs = ["body"]

2717 buffer_defaults_node = None

2718 buffer_defaults_pos = None

2719 typedef_flag = False

2720 api = False

2721 objstruct_name = None

2722 typeobj_name = None

2723 decorators = None

2724

2725 def analyse_declarations(self, env):

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

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

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

2729

2730 import Buffer

2731 if self.buffer_defaults_node:

2732 buffer_defaults = Buffer.analyse_buffer_options(self.buffer_defaults_pos,

2733 env, [], self.buffer_defaults_node,

2734 need_complete=False)

2735 else:

2736 buffer_defaults = None

2737

2738 if env.in_cinclude and not self.objstruct_name:

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

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

2741 self.base_type = None

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

2743 # import the modules for extern classes.

2744 if self.module_name:

2745 self.module = None

2746 for module in env.cimported_modules:

2747 if module.name == self.module_name:

2748 self.module = module

2749 if self.module is None:

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

2751 self.module.has_extern_class = 1

2752 env.add_imported_module(self.module)

2753

2754 if self.base_class_name:

2755 if self.base_class_module:

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

2757 else:

2758 base_class_scope = env

2759 if self.base_class_name == 'object':

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

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

2762 self.base_class_name = None

2763 self.base_class_module = None

2764 base_class_scope = None

2765 if base_class_scope:

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

2767 if base_class_entry:

2768 if not base_class_entry.is_type:

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

2770 elif not base_class_entry.type.is_extension_type:

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

2772 elif not base_class_entry.type.is_complete():

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

2774 else:

2775 self.base_type = base_class_entry.type

2776 has_body = self.body is not None

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

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

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

2780 if not home_scope:

2781 return

2782 else:

2783 home_scope = env

2784

2785 if self.visibility == 'extern':

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

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

2788

2789 self.entry = home_scope.declare_c_class(

2790 name = self.class_name,

2791 pos = self.pos,

2792 defining = has_body and self.in_pxd,

2793 implementing = has_body and not self.in_pxd,

2794 module_name = self.module_name,

2795 base_type = self.base_type,

2796 objstruct_cname = self.objstruct_name,

2797 typeobj_cname = self.typeobj_name,

2798 visibility = self.visibility,

2799 typedef_flag = self.typedef_flag,

2800 api = self.api,

2801 buffer_defaults = buffer_defaults)

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

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

2804 self.scope = scope = self.entry.type.scope

2805 if scope is not None:

2806 scope.directives = env.directives

2807

2808 if self.doc and Options.docstrings:

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

2810

2811 if has_body:

2812 self.body.analyse_declarations(scope)

2813 if self.in_pxd:

2814 scope.defined = 1

2815 else:

2816 scope.implemented = 1

2817 env.allocate_vtable_names(self.entry)

2818

2819 def analyse_expressions(self, env):

2820 if self.body:

2821 scope = self.entry.type.scope

2822 self.body.analyse_expressions(scope)

2823

2824 def generate_function_definitions(self, env, code):

2825 if self.body:

2826 self.body.generate_function_definitions(

2827 self.entry.type.scope, code)

2828

2829 def generate_execution_code(self, code):

2830 # This is needed to generate evaluation code for

2831 # default values of method arguments.

2832 if self.body:

2833 self.body.generate_execution_code(code)

2834

2835 def annotate(self, code):

2836 if self.body:

2837 self.body.annotate(code)

2838

2839

2840 class PropertyNode(StatNode):

2841 # Definition of a property in an extension type.

2842 #

2843 # name string

2844 # doc EncodedString or None Doc string

2845 # body StatListNode

2846

2847 child_attrs = ["body"]

2848

2849 def analyse_declarations(self, env):

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

2851 if entry:

2852 entry.scope.directives = env.directives

2853 self.body.analyse_declarations(entry.scope)

2854

2855 def analyse_expressions(self, env):

2856 self.body.analyse_expressions(env)

2857

2858 def generate_function_definitions(self, env, code):

2859 self.body.generate_function_definitions(env, code)

2860

2861 def generate_execution_code(self, code):

2862 pass

2863

2864 def annotate(self, code):

2865 self.body.annotate(code)

2866

2867

2868 class GlobalNode(StatNode):

2869 # Global variable declaration.

2870 #

2871 # names [string]

2872

2873 child_attrs = []

2874

2875 def analyse_declarations(self, env):

2876 for name in self.names:

2877 env.declare_global(name, self.pos)

2878

2879 def analyse_expressions(self, env):

2880 pass

2881

2882 def generate_execution_code(self, code):

2883 pass

2884

2885

2886 class ExprStatNode(StatNode):

2887 # Expression used as a statement.

2888 #

2889 # expr ExprNode

2890

2891 child_attrs = ["expr"]

2892

2893 def analyse_declarations(self, env):

2894 import ExprNodes

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

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

2897 if func == u'declare':

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

2899 if len(args):

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

2901 for var, type_node in kwds.key_value_pairs:

2902 type = type_node.analyse_as_type(env)

2903 if type is None:

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

2905 else:

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

2907 self.__class__ = PassStatNode

2908

2909 def analyse_expressions(self, env):

2910 self.expr.analyse_expressions(env)

2911

2912 def generate_execution_code(self, code):

2913 self.expr.generate_evaluation_code(code)

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

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

2916 self.expr.generate_disposal_code(code)

2917 self.expr.free_temps(code)

2918

2919 def annotate(self, code):

2920 self.expr.annotate(code)

2921

2922

2923 class AssignmentNode(StatNode):

2924 # Abstract base class for assignment nodes.

2925 #

2926 # The analyse_expressions and generate_execution_code

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

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

2929 # parallel assignment to be evaluated before assigning

2930 # to any of the left hand sides.

2931

2932 def analyse_expressions(self, env):

2933 self.analyse_types(env)

2934

2935 # def analyse_expressions(self, env):

2936 # self.analyse_expressions_1(env)

2937 # self.analyse_expressions_2(env)

2938

2939 def generate_execution_code(self, code):

2940 self.generate_rhs_evaluation_code(code)

2941 self.generate_assignment_code(code)

2942

2943

2944 class SingleAssignmentNode(AssignmentNode):

2945 # The simplest case:

2946 #

2947 # a = b

2948 #

2949 # lhs ExprNode Left hand side

2950 # rhs ExprNode Right hand side

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

2952

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

2954 first = False

2955 declaration_only = False

2956

2957 def analyse_declarations(self, env):

2958 import ExprNodes

2959

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

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

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

2963 if func_name:

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

2965

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

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

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

2969 return

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

2971 if type is None:

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

2973 return

2974 lhs = self.lhs

2975 if func_name == 'declare':

2976 if isinstance(lhs, ExprNodes.NameNode):

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

2978 elif isinstance(lhs, ExprNodes.TupleNode):

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

2980 else:

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

2982 return

2983 for var, pos in vars:

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

2985 if len(args) == 2:

2986 # we have a value

2987 self.rhs = args[1]

2988 else:

2989 self.declaration_only = True

2990 else:

2991 self.declaration_only = True

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

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

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

2995

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

2997 self.declaration_only = True

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

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

3000 return

3001 members = []

3002 for member, type_node in kwds.key_value_pairs:

3003 type = type_node.analyse_as_type(env)

3004 if type is None:

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

3006 else:

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

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

3009 return

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

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

3012 name = self.lhs.name

3013 scope = StructOrUnionScope(name)

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

3015 for member, type, pos in members:

3016 scope.declare_var(member, type, pos)

3017

3018 if self.declaration_only:

3019 return

3020 else:

3021 self.lhs.analyse_target_declaration(env)

3022

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

3024 self.rhs.analyse_types(env)

3025 self.lhs.analyse_target_types(env)

3026 self.lhs.gil_assignment_check(env)

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

3028 if use_temp:

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

3030

3031 def generate_rhs_evaluation_code(self, code):

3032 self.rhs.generate_evaluation_code(code)

3033

3034 def generate_assignment_code(self, code):

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

3036

3037 def annotate(self, code):

3038 self.lhs.annotate(code)

3039 self.rhs.annotate(code)

3040

3041

3042 class CascadedAssignmentNode(AssignmentNode):

3043 # An assignment with multiple left hand sides:

3044 #

3045 # a = b = c

3046 #

3047 # lhs_list [ExprNode] Left hand sides

3048 # rhs ExprNode Right hand sides

3049 #

3050 # Used internally:

3051 #

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

3053

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

3055 coerced_rhs_list = None

3056

3057 def analyse_declarations(self, env):

3058 for lhs in self.lhs_list:

3059 lhs.analyse_target_declaration(env)

3060

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

3062 self.rhs.analyse_types(env)

3063 if use_temp:

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

3065 else:

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

3067 from ExprNodes import CloneNode

3068 self.coerced_rhs_list = []

3069 for lhs in self.lhs_list:

3070 lhs.analyse_target_types(env)

3071 lhs.gil_assignment_check(env)

3072 rhs = CloneNode(self.rhs)

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

3074 self.coerced_rhs_list.append(rhs)

3075

3076 def generate_rhs_evaluation_code(self, code):

3077 self.rhs.generate_evaluation_code(code)

3078

3079 def generate_assignment_code(self, code):

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

3081 lhs = self.lhs_list[i]

3082 rhs = self.coerced_rhs_list[i]

3083 rhs.generate_evaluation_code(code)

3084 lhs.generate_assignment_code(rhs, code)

3085 # Assignment has disposed of the cloned RHS

3086 self.rhs.generate_disposal_code(code)

3087 self.rhs.free_temps(code)

3088

3089 def annotate(self, code):

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

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

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

3093 self.rhs.annotate(code)

3094

3095

3096 class ParallelAssignmentNode(AssignmentNode):

3097 # A combined packing/unpacking assignment:

3098 #

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

3100 #

3101 # This has been rearranged by the parser into

3102 #

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

3104 #

3105 # but we must evaluate all the right hand sides

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

3107 #

3108 # stats [AssignmentNode] The constituent assignments

3109

3110 child_attrs = ["stats"]

3111

3112 def analyse_declarations(self, env):

3113 for stat in self.stats:

3114 stat.analyse_declarations(env)

3115

3116 def analyse_expressions(self, env):

3117 for stat in self.stats:

3118 stat.analyse_types(env, use_temp = 1)

3119

3120 # def analyse_expressions(self, env):

3121 # for stat in self.stats:

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

3123 # for stat in self.stats:

3124 # stat.analyse_expressions_2(env)

3125

3126 def generate_execution_code(self, code):

3127 for stat in self.stats:

3128 stat.generate_rhs_evaluation_code(code)

3129 for stat in self.stats:

3130 stat.generate_assignment_code(code)

3131

3132 def annotate(self, code):

3133 for stat in self.stats:

3134 stat.annotate(code)

3135

3136

3137 class InPlaceAssignmentNode(AssignmentNode):

3138 # An in place arithmatic operand:

3139 #

3140 # a += b

3141 # a -= b

3142 # ...

3143 #

3144 # lhs ExprNode Left hand side

3145 # rhs ExprNode Right hand side

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

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

3148 #

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

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

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

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

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

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

3155

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

3157 dup = None

3158

3159 def analyse_declarations(self, env):

3160 self.lhs.analyse_target_declaration(env)

3161

3162 def analyse_types(self, env):

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

3164 self.rhs.analyse_types(env)

3165 self.lhs.analyse_target_types(env)

3166 import ExprNodes

3167 if self.lhs.type.is_pyobject:

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

3169 elif self.rhs.type.is_pyobject:

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

3171 if self.lhs.type.is_pyobject:

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

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

3174

3175 def generate_execution_code(self, code):

3176 import ExprNodes

3177 self.rhs.generate_evaluation_code(code)

3178 self.dup.generate_subexpr_evaluation_code(code)

3179 if self.dup.is_temp:

3180 self.dup.allocate_temp_result(code)

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

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

3183 extra = ", Py_None"

3184 else:

3185 extra = ""

3186 if self.lhs.type.is_pyobject:

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

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

3189 self.dup.generate_result_code(code)

3190 self.result_value_temp.allocate(code)

3191 code.putln(

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

3193 self.result_value.result(),

3194 self.py_operation_function(),

3195 self.dup.py_result(),

3196 self.rhs.py_result(),

3197 extra,

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

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

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

3201 self.rhs.generate_disposal_code(code)

3202 self.rhs.free_temps(code)

3203 self.dup.generate_disposal_code(code)

3204 self.dup.free_temps(code)

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

3206 self.result_value_temp.release(code)

3207 else:

3208 c_op = self.operator

3209 if c_op == "//":

3210 c_op = "/"

3211 elif c_op == "**":

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

3213 elif self.lhs.type.is_complex:

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

3215

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

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

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

3219 else:

3220 self.dup.generate_result_code(code)

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

3222 self.rhs.generate_disposal_code(code)

3223 self.rhs.free_temps(code)

3224 if self.dup.is_temp:

3225 self.dup.generate_subexpr_disposal_code(code)

3226 self.dup.free_subexpr_temps(code)

3227

3228 def create_dup_node(self, env):

3229 import ExprNodes

3230 self.dup = self.lhs

3231 self.dup.analyse_types(env)

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

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

3234 name = self.dup.name,

3235 is_temp = self.dup.is_temp,

3236 entry = self.dup.entry)

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

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

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

3240 attribute = self.dup.attribute,

3241 is_temp = self.dup.is_temp)

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

3243 if self.lhs.index:

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

3245 else:

3246 index = None

3247 if self.lhs.indices:

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

3249 else:

3250 indices = []

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

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

3253 index = index,

3254 indices = indices,

3255 is_temp = self.dup.is_temp)

3256 else:

3257 assert False

3258 self.lhs = target_lhs

3259 return self.dup

3260

3261 def py_operation_function(self):

3262 return self.py_functions[self.operator]

3263

3264 py_functions = {

3265 "|": "PyNumber_InPlaceOr",

3266 "^": "PyNumber_InPlaceXor",

3267 "&": "PyNumber_InPlaceAnd",

3268 "+": "PyNumber_InPlaceAdd",

3269 "-": "PyNumber_InPlaceSubtract",

3270 "*": "PyNumber_InPlaceMultiply",

3271 "/": "__Pyx_PyNumber_InPlaceDivide",

3272 "%": "PyNumber_InPlaceRemainder",

3273 "<<": "PyNumber_InPlaceLshift",

3274 ">>": "PyNumber_InPlaceRshift",

3275 "**": "PyNumber_InPlacePower",

3276 "//": "PyNumber_InPlaceFloorDivide",

3277 }

3278

3279 def annotate(self, code):

3280 self.lhs.annotate(code)

3281 self.rhs.annotate(code)

3282 self.dup.annotate(code)

3283

3284 def create_binop_node(self):

3285 import ExprNodes

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

3287

3288

3289 class PrintStatNode(StatNode):

3290 # print statement

3291 #

3292 # arg_tuple TupleNode

3293 # append_newline boolean

3294

3295 child_attrs = ["arg_tuple"]

3296

3297 def analyse_expressions(self, env):

3298 self.arg_tuple.analyse_expressions(env)

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

3300 env.use_utility_code(printing_utility_code)

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

3302 env.use_utility_code(printing_one_utility_code)

3303

3304 nogil_check = Node.gil_error

3305 gil_message = "Python print statement"

3306

3307 def generate_execution_code(self, code):

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

3309 arg = self.arg_tuple.args[0]

3310 arg.generate_evaluation_code(code)

3311

3312 code.putln(

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

3314 arg.py_result(),

3315 code.error_goto(self.pos)))

3316 arg.generate_disposal_code(code)

3317 arg.free_temps(code)

3318 else:

3319 self.arg_tuple.generate_evaluation_code(code)

3320 code.putln(

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

3322 self.arg_tuple.py_result(),

3323 self.append_newline,

3324 code.error_goto(self.pos)))

3325 self.arg_tuple.generate_disposal_code(code)

3326 self.arg_tuple.free_temps(code)

3327

3328 def annotate(self, code):

3329 self.arg_tuple.annotate(code)

3330

3331

3332 class ExecStatNode(StatNode):

3333 # exec statement

3334 #

3335 # args [ExprNode]

3336

3337 child_attrs = ["args"]

3338

3339 def analyse_expressions(self, env):

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

3341 arg.analyse_expressions(env)

3342 arg = arg.coerce_to_pyobject(env)

3343 self.args[i] = arg

3344 env.use_utility_code(Builtin.pyexec_utility_code)

3345

3346 nogil_check = Node.gil_error

3347 gil_message = "Python exec statement"

3348

3349 def generate_execution_code(self, code):

3350 args = []

3351 for arg in self.args:

3352 arg.generate_evaluation_code(code)

3353 args.append( arg.py_result() )

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

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

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

3357 (temp_result,) + args))

3358 for arg in self.args:

3359 arg.generate_disposal_code(code)

3360 arg.free_temps(code)

3361 code.putln(

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

3363 code.put_gotref(temp_result)

3364 code.put_decref_clear(temp_result, py_object_type)

3365 code.funcstate.release_temp(temp_result)

3366

3367 def annotate(self, code):

3368 for arg in self.args:

3369 arg.annotate(code)

3370

3371

3372 class DelStatNode(StatNode):

3373 # del statement

3374 #

3375 # args [ExprNode]

3376

3377 child_attrs = ["args"]

3378

3379 def analyse_declarations(self, env):

3380 for arg in self.args:

3381 arg.analyse_target_declaration(env)

3382

3383 def analyse_expressions(self, env):

3384 for arg in self.args:

3385 arg.analyse_target_expression(env, None)

3386 if not arg.type.is_pyobject:

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

3388 #arg.release_target_temp(env)

3389

3390 def nogil_check(self, env):

3391 for arg in self.args:

3392 if arg.type.is_pyobject:

3393 self.gil_error()

3394

3395 gil_message = "Deleting Python object"

3396

3397 def generate_execution_code(self, code):

3398 for arg in self.args:

3399 if arg.type.is_pyobject:

3400 arg.generate_deletion_code(code)

3401 # else error reported earlier

3402

3403 def annotate(self, code):

3404 for arg in self.args:

3405 arg.annotate(code)

3406

3407

3408 class PassStatNode(StatNode):

3409 # pass statement

3410

3411 child_attrs = []

3412

3413 def analyse_expressions(self, env):

3414 pass

3415

3416 def generate_execution_code(self, code):

3417 pass

3418

3419

3420 class BreakStatNode(StatNode):

3421

3422 child_attrs = []

3423

3424 def analyse_expressions(self, env):

3425 pass

3426

3427 def generate_execution_code(self, code):

3428 if not code.break_label:

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

3430 else:

3431 code.put_goto(code.break_label)

3432

3433

3434 class ContinueStatNode(StatNode):

3435

3436 child_attrs = []

3437

3438 def analyse_expressions(self, env):

3439 pass

3440

3441 def generate_execution_code(self, code):

3442 if code.funcstate.in_try_finally:

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

3444 elif not code.continue_label:

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

3446 else:

3447 code.put_goto(code.continue_label)

3448

3449

3450 class ReturnStatNode(StatNode):

3451 # return statement

3452 #

3453 # value ExprNode or None

3454 # return_type PyrexType

3455

3456 child_attrs = ["value"]

3457

3458 def analyse_expressions(self, env):

3459 return_type = env.return_type

3460 self.return_type = return_type

3461 if not return_type:

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

3463 return

3464 if self.value:

3465 self.value.analyse_types(env)

3466 if return_type.is_void or return_type.is_returncode:

3467 error(self.value.pos,

3468 "Return with value in void function")

3469 else:

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

3471 else:

3472 if (not return_type.is_void

3473 and not return_type.is_pyobject

3474 and not return_type.is_returncode):

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

3476

3477 def nogil_check(self, env):

3478 if self.return_type.is_pyobject:

3479 self.gil_error()

3480

3481 gil_message = "Returning Python object"

3482

3483 def generate_execution_code(self, code):

3484 code.mark_pos(self.pos)

3485 if not self.return_type:

3486 # error reported earlier

3487 return

3488 if self.return_type.is_pyobject:

3489 code.put_xdecref(Naming.retval_cname,

3490 self.return_type)

3491 if self.value:

3492 self.value.generate_evaluation_code(code)

3493 self.value.make_owned_reference(code)

3494 code.putln(

3495 "%s = %s;" % (

3496 Naming.retval_cname,

3497 self.value.result_as(self.return_type)))

3498 self.value.generate_post_assignment_code(code)

3499 self.value.free_temps(code)

3500 else:

3501 if self.return_type.is_pyobject:

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

3503 elif self.return_type.is_returncode:

3504 code.putln(

3505 "%s = %s;" % (

3506 Naming.retval_cname,

3507 self.return_type.default_value))

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

3509 code.put_decref_clear(cname, type)

3510 code.put_goto(code.return_label)

3511

3512 def annotate(self, code):

3513 if self.value:

3514 self.value.annotate(code)

3515

3516

3517 class RaiseStatNode(StatNode):

3518 # raise statement

3519 #

3520 # exc_type ExprNode or None

3521 # exc_value ExprNode or None

3522 # exc_tb ExprNode or None

3523

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

3525

3526 def analyse_expressions(self, env):

3527 if self.exc_type:

3528 self.exc_type.analyse_types(env)

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

3530 if self.exc_value:

3531 self.exc_value.analyse_types(env)

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

3533 if self.exc_tb:

3534 self.exc_tb.analyse_types(env)

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

3536 env.use_utility_code(raise_utility_code)

3537

3538 nogil_check = Node.gil_error

3539 gil_message = "Raising exception"

3540

3541 def generate_execution_code(self, code):

3542 if self.exc_type:

3543 self.exc_type.generate_evaluation_code(code)

3544 type_code = self.exc_type.py_result()

3545 else:

3546 type_code = "0"

3547 if self.exc_value:

3548 self.exc_value.generate_evaluation_code(code)

3549 value_code = self.exc_value.py_result()

3550 else:

3551 value_code = "0"

3552 if self.exc_tb:

3553 self.exc_tb.generate_evaluation_code(code)

3554 tb_code = self.exc_tb.py_result()

3555 else:

3556 tb_code = "0"

3557 code.putln(

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

3559 type_code,

3560 value_code,

3561 tb_code))

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

3563 if obj:

3564 obj.generate_disposal_code(code)

3565 obj.free_temps(code)

3566 code.putln(

3567 code.error_goto(self.pos))

3568

3569 def annotate(self, code):

3570 if self.exc_type:

3571 self.exc_type.annotate(code)

3572 if self.exc_value:

3573 self.exc_value.annotate(code)

3574 if self.exc_tb:

3575 self.exc_tb.annotate(code)

3576

3577

3578 class ReraiseStatNode(StatNode):

3579

3580 child_attrs = []

3581

3582 def analyse_expressions(self, env):

3583 env.use_utility_code(restore_exception_utility_code)

3584

3585 nogil_check = Node.gil_error

3586 gil_message = "Raising exception"

3587

3588 def generate_execution_code(self, code):

3589 vars = code.funcstate.exc_vars

3590 if vars:

3591 for varname in vars:

3592 code.put_giveref(varname)

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

3594 for varname in vars:

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

3596 code.putln()

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

3598 else:

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

3600

3601

3602 class AssertStatNode(StatNode):

3603 # assert statement

3604 #

3605 # cond ExprNode

3606 # value ExprNode or None

3607

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

3609

3610 def analyse_expressions(self, env):

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

3612 if self.value:

3613 self.value.analyse_types(env)

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

3615

3616 nogil_check = Node.gil_error

3617 gil_message = "Raising exception"

3618

3619 def generate_execution_code(self, code):

3620 code.putln("#ifndef PYREX_WITHOUT_ASSERTIONS")

3621 self.cond.generate_evaluation_code(code)

3622 code.putln(

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

3624 self.cond.result())

3625 if self.value:

3626 self.value.generate_evaluation_code(code)

3627 code.putln(

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

3629 self.value.py_result())

3630 self.value.generate_disposal_code(code)

3631 self.value.free_temps(code)

3632 else:

3633 code.putln(

3634 "PyErr_SetNone(PyExc_AssertionError);")

3635 code.putln(

3636 code.error_goto(self.pos))

3637 code.putln(

3638 "}")

3639 self.cond.generate_disposal_code(code)

3640 self.cond.free_temps(code)

3641 code.putln("#endif")

3642

3643 def annotate(self, code):

3644 self.cond.annotate(code)

3645 if self.value:

3646 self.value.annotate(code)

3647

3648

3649 class IfStatNode(StatNode):

3650 # if statement

3651 #

3652 # if_clauses [IfClauseNode]

3653 # else_clause StatNode or None

3654

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

3656

3657 def analyse_control_flow(self, env):

3658 env.start_branching(self.pos)

3659 for if_clause in self.if_clauses:

3660 if_clause.analyse_control_flow(env)

3661 env.next_branch(if_clause.end_pos())

3662 if self.else_clause:

3663 self.else_clause.analyse_control_flow(env)

3664 env.finish_branching(self.end_pos())

3665

3666 def analyse_declarations(self, env):

3667 for if_clause in self.if_clauses:

3668 if_clause.analyse_declarations(env)

3669 if self.else_clause:

3670 self.else_clause.analyse_declarations(env)

3671

3672 def analyse_expressions(self, env):

3673 for if_clause in self.if_clauses:

3674 if_clause.analyse_expressions(env)

3675 if self.else_clause:

3676 self.else_clause.analyse_expressions(env)

3677

3678 def generate_execution_code(self, code):

3679 code.mark_pos(self.pos)

3680 end_label = code.new_label()

3681 for if_clause in self.if_clauses:

3682 if_clause.generate_execution_code(code, end_label)

3683 if self.else_clause:

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

3685 self.else_clause.generate_execution_code(code)

3686 code.putln("}")

3687 code.put_label(end_label)

3688

3689 def annotate(self, code):

3690 for if_clause in self.if_clauses:

3691 if_clause.annotate(code)

3692 if self.else_clause:

3693 self.else_clause.annotate(code)

3694

3695

3696 class IfClauseNode(Node):

3697 # if or elif clause in an if statement

3698 #

3699 # condition ExprNode

3700 # body StatNode

3701

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

3703

3704 def analyse_control_flow(self, env):

3705 self.body.analyse_control_flow(env)

3706

3707 def analyse_declarations(self, env):

3708 self.condition.analyse_declarations(env)

3709 self.body.analyse_declarations(env)

3710

3711 def analyse_expressions(self, env):

3712 self.condition = \

3713 self.condition.analyse_temp_boolean_expression(env)

3714 self.body.analyse_expressions(env)

3715

3716 def generate_execution_code(self, code, end_label):

3717 self.condition.generate_evaluation_code(code)

3718 code.putln(

3719 "if (%s) {" %

3720 self.condition.result())

3721 self.condition.generate_disposal_code(code)

3722 self.condition.free_temps(code)

3723 self.body.generate_execution_code(code)

3724 #code.putln(

3725 # "goto %s;" %

3726 # end_label)

3727 code.put_goto(end_label)

3728 code.putln("}")

3729

3730 def annotate(self, code):

3731 self.condition.annotate(code)

3732 self.body.annotate(code)

3733

3734

3735 class SwitchCaseNode(StatNode):

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

3737 #

3738 # conditions [ExprNode]

3739 # body StatNode

3740

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

3742

3743 def generate_execution_code(self, code):

3744 for cond in self.conditions:

3745 code.mark_pos(cond.pos)

3746 cond.generate_evaluation_code(code)

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

3748 self.body.generate_execution_code(code)

3749 code.putln("break;")

3750

3751 def annotate(self, code):

3752 for cond in self.conditions:

3753 cond.annotate(code)

3754 self.body.annotate(code)

3755

3756 class SwitchStatNode(StatNode):

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

3758 #

3759 # test ExprNode

3760 # cases [SwitchCaseNode]

3761 # else_clause StatNode or None

3762

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

3764

3765 def generate_execution_code(self, code):

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

3767 for case in self.cases:

3768 case.generate_execution_code(code)

3769 if self.else_clause is not None:

3770 code.putln("default:")

3771 self.else_clause.generate_execution_code(code)

3772 code.putln("break;")

3773 code.putln("}")

3774

3775 def annotate(self, code):

3776 self.test.annotate(code)

3777 for case in self.cases:

3778 case.annotate(code)

3779 if self.else_clause is not None:

3780 self.else_clause.annotate(code)

3781

3782 class LoopNode(object):

3783

3784 def analyse_control_flow(self, env):

3785 env.start_branching(self.pos)

3786 self.body.analyse_control_flow(env)

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

3788 if self.else_clause:

3789 self.else_clause.analyse_control_flow(env)

3790 env.finish_branching(self.end_pos())

3791

3792

3793 class WhileStatNode(LoopNode, StatNode):

3794 # while statement

3795 #

3796 # condition ExprNode

3797 # body StatNode

3798 # else_clause StatNode

3799

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

3801

3802 def analyse_declarations(self, env):

3803 self.body.analyse_declarations(env)

3804 if self.else_clause:

3805 self.else_clause.analyse_declarations(env)

3806

3807 def analyse_expressions(self, env):

3808 self.condition = \

3809 self.condition.analyse_temp_boolean_expression(env)

3810 self.body.analyse_expressions(env)

3811 if self.else_clause:

3812 self.else_clause.analyse_expressions(env)

3813

3814 def generate_execution_code(self, code):

3815 old_loop_labels = code.new_loop_labels()

3816 code.putln(

3817 "while (1) {")

3818 self.condition.generate_evaluation_code(code)

3819 self.condition.generate_disposal_code(code)

3820 code.putln(

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

3822 self.condition.result())

3823 self.condition.free_temps(code)

3824 self.body.generate_execution_code(code)

3825 code.put_label(code.continue_label)

3826 code.putln("}")

3827 break_label = code.break_label

3828 code.set_loop_labels(old_loop_labels)

3829 if self.else_clause:

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

3831 self.else_clause.generate_execution_code(code)

3832 code.putln("}")

3833 code.put_label(break_label)

3834

3835 def annotate(self, code):

3836 self.condition.annotate(code)

3837 self.body.annotate(code)

3838 if self.else_clause:

3839 self.else_clause.annotate(code)

3840

3841

3842 def ForStatNode(pos, **kw):

3843 if 'iterator' in kw:

3844 return ForInStatNode(pos, **kw)

3845 else:

3846 return ForFromStatNode(pos, **kw)

3847

3848 class ForInStatNode(LoopNode, StatNode):

3849 # for statement

3850 #

3851 # target ExprNode

3852 # iterator IteratorNode

3853 # body StatNode

3854 # else_clause StatNode

3855 # item NextNode used internally

3856

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

3858 item = None

3859

3860 def analyse_declarations(self, env):

3861 self.target.analyse_target_declaration(env)

3862 self.body.analyse_declarations(env)

3863 if self.else_clause:

3864 self.else_clause.analyse_declarations(env)

3865

3866 def analyse_expressions(self, env):

3867 import ExprNodes

3868 self.target.analyse_target_types(env)

3869 self.iterator.analyse_expressions(env)

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

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

3872 self.body.analyse_expressions(env)

3873 if self.else_clause:

3874 self.else_clause.analyse_expressions(env)

3875

3876 def generate_execution_code(self, code):

3877 old_loop_labels = code.new_loop_labels()

3878 self.iterator.allocate_counter_temp(code)

3879 self.iterator.generate_evaluation_code(code)

3880 code.putln(

3881 "for (;;) {")

3882 self.item.generate_evaluation_code(code)

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

3884 self.body.generate_execution_code(code)

3885 code.put_label(code.continue_label)

3886 code.putln(

3887 "}")

3888 break_label = code.break_label

3889 code.set_loop_labels(old_loop_labels)

3890 if self.else_clause:

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

3892 self.else_clause.generate_execution_code(code)

3893 code.putln("}")

3894 code.put_label(break_label)

3895 self.iterator.release_counter_temp(code)

3896 self.iterator.generate_disposal_code(code)

3897 self.iterator.free_temps(code)

3898

3899 def annotate(self, code):

3900 self.target.annotate(code)

3901 self.iterator.annotate(code)

3902 self.body.annotate(code)

3903 if self.else_clause:

3904 self.else_clause.annotate(code)

3905 self.item.annotate(code)

3906

3907

3908 class ForFromStatNode(LoopNode, StatNode):

3909 # for name from expr rel name rel expr

3910 #

3911 # target NameNode

3912 # bound1 ExprNode

3913 # relation1 string

3914 # relation2 string

3915 # bound2 ExprNode

3916 # step ExprNode or None

3917 # body StatNode

3918 # else_clause StatNode or None

3919 #

3920 # Used internally:

3921 #

3922 # from_range bool

3923 # is_py_target bool

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

3925 # py_loopvar_node PyTempNode or None

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

3927

3928 is_py_target = False

3929 loopvar_node = None

3930 py_loopvar_node = None

3931 from_range = False

3932

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

3934

3935 def nogil_check(self, env):

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

3937 if x.type.is_pyobject:

3938 self.gil_error()

3939

3940 def analyse_declarations(self, env):

3941 self.target.analyse_target_declaration(env)

3942 self.body.analyse_declarations(env)

3943 if self.else_clause:

3944 self.else_clause.analyse_declarations(env)

3945

3946 def analyse_expressions(self, env):

3947 import ExprNodes

3948 self.target.analyse_target_types(env)

3949 self.bound1.analyse_types(env)

3950 self.bound2.analyse_types(env)

3951 if self.step is not None:

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

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

3954 self.step.analyse_types(env)

3955

3956 target_type = self.target.type

3957 if self.target.type.is_numeric:

3958 loop_type = self.target.type

3959 else:

3960 loop_type = PyrexTypes.c_int_type

3961 if not self.bound1.type.is_pyobject:

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

3963 if not self.bound2.type.is_pyobject:

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

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

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

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

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

3969 if not self.bound2.is_literal:

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

3971 if self.step is not None:

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