1 #

2 # Pyrex - Parse tree nodes

3 #

4

5 import sys, os, time, copy

6

7 import Code

8 import Builtin

9 from Errors import error, warning, InternalError

10 import Naming

11 import PyrexTypes

12 import TypeSlots

13 from PyrexTypes import py_object_type, error_type, CTypedefType, CFuncType

14 from Symtab import ModuleScope, LocalScope, GeneratorLocalScope, \

15 StructOrUnionScope, PyClassScope, CClassScope

16 from Cython.Utils import open_new_file, replace_suffix, UtilityCode

17 from StringEncoding import EncodedString, escape_byte_string, split_docstring

18 import Options

19 import ControlFlow

20 import DebugFlags

21

22 absolute_path_length = 0

23

24 def relative_position(pos):

25 """

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

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

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

29 e.g,. when distributing binaries.)

30

31 INPUT:

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

33

34 OUTPUT:

35 relative filename

36 line number

37

38 AUTHOR: William Stein

39 """

40 global absolute_path_length

41 if absolute_path_length==0:

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

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

44

45 def embed_position(pos, docstring):

46 if not Options.embed_pos_in_docstring:

47 return docstring

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

49 if docstring is None:

50 # unicode string

51 return EncodedString(pos_line)

52

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

54 # otherwise make the docstring a unicode string

55 encoding = docstring.encoding

56 if encoding is not None:

57 try:

58 encoded_bytes = pos_line.encode(encoding)

59 except UnicodeEncodeError:

60 encoding = None

61

62 if not docstring:

63 # reuse the string encoding of the original docstring

64 doc = EncodedString(pos_line)

65 else:

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

67 doc.encoding = encoding

68 return doc

69

70

71 from Code import CCodeWriter

72 from types import FunctionType

73

74 def write_func_call(func):

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

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

77 # here we annotate the code with this function call

78 # but only if new code is generated

79 node, code = args[:2]

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

81 ' ' * code.call_level,

82 node.__class__.__name__,

83 func.__name__,

84 node.pos[1:])

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

86 code.putln(marker)

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

88 code.call_level += 4

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

90 code.call_level -= 4

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

92 code.buffer.stream.seek(pristine)

93 else:

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

95 code.putln(marker)

96 return res

97 else:

98 return func(*args, **kwds)

99 return f

100

101 class VerboseCodeWriter(type):

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

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

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

105 attrs = dict(attrs)

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

107 if isinstance(m, FunctionType):

108 attrs[mname] = write_func_call(m)

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

110

111

112 class Node(object):

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

114 # is_name boolean Is a NameNode

115 # is_literal boolean Is a ConstNode

116

117 if DebugFlags.debug_trace_code_generation:

118 __metaclass__ = VerboseCodeWriter

119

120 is_name = 0

121 is_literal = 0

122 temps = None

123

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

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

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

127 child_attrs = None

128

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

130 self.pos = pos

131 self.__dict__.update(kw)

132

133 gil_message = "Operation"

134

135 def gil_check(self, env):

136 if env.nogil:

137 self.gil_error()

138

139 def gil_error(self):

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

141

142 def clone_node(self):

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

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

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

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

147 level in the tree."""

148 result = copy.copy(self)

149 for attrname in result.child_attrs:

150 value = getattr(result, attrname)

151 if isinstance(value, list):

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

153 return result

154

155

156 #

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

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

159 #

160 # (0) analyse_control_flow

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

162 # queried.

163 #

164 # (1) analyse_declarations

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

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

167 # to an otherwise undeclared name).

168 #

169 # (2) analyse_expressions

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

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

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

173 # Allocate temporary locals for intermediate results. Fill

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

175 # fragment.

176 #

177 # (3) generate_code

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

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

180 # functions.

181 #

182

183 def analyse_control_flow(self, env):

184 pass

185

186 def analyse_declarations(self, env):

187 pass

188

189 def analyse_expressions(self, env):

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

191 self.__class__.__name__)

192

193 def generate_code(self, code):

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

195 self.__class__.__name__)

196

197 def annotate(self, code):

198 # mro does the wrong thing

199 if isinstance(self, BlockNode):

200 self.body.annotate(code)

201

202 def end_pos(self):

203 try:

204 return self._end_pos

205 except AttributeError:

206 pos = self.pos

207 if not self.child_attrs:

208 self._end_pos = pos

209 return pos

210 for attr in self.child_attrs:

211 child = getattr(self, attr)

212 # Sometimes lists, sometimes nodes

213 if child is None:

214 pass

215 elif isinstance(child, list):

216 for c in child:

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

218 else:

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

220 self._end_pos = pos

221 return pos

222

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

224 if cutoff == 0:

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

226 if encountered is None:

227 encountered = set()

228 if id(self) in encountered:

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

230 encountered.add(id(self))

231

232 def dump_child(x, level):

233 if isinstance(x, Node):

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

235 elif isinstance(x, list):

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

237 else:

238 return repr(x)

239

240

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

242 if len(attrs) == 0:

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

244 else:

245 indent = " " * level

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

247 for key, value in attrs:

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

249 res += "%s>" % indent

250 return res

251

252 class CompilerDirectivesNode(Node):

253 """

254 Sets compiler directives for the children nodes

255 """

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

257 # *all* possible directives.

258 # body Node

259 child_attrs = ["body"]

260

261 def analyse_control_flow(self, env):

262 old = env.directives

263 env.directives = self.directives

264 self.body.analyse_control_flow(env)

265 env.directives = old

266

267 def analyse_declarations(self, env):

268 old = env.directives

269 env.directives = self.directives

270 self.body.analyse_declarations(env)

271 env.directives = old

272

273 def analyse_expressions(self, env):

274 old = env.directives

275 env.directives = self.directives

276 self.body.analyse_expressions(env)

277 env.directives = old

278

279 def generate_function_definitions(self, env, code):

280 env_old = env.directives

281 code_old = code.globalstate.directives

282 code.globalstate.directives = self.directives

283 self.body.generate_function_definitions(env, code)

284 env.directives = env_old

285 code.globalstate.directives = code_old

286

287 def generate_execution_code(self, code):

288 old = code.globalstate.directives

289 code.globalstate.directives = self.directives

290 self.body.generate_execution_code(code)

291 code.globalstate.directives = old

292

293 def annotate(self, code):

294 old = code.globalstate.directives

295 code.globalstate.directives = self.directives

296 self.body.annotate(code)

297 code.globalstate.directives = old

298

299 class BlockNode(object):

300 # Mixin class for nodes representing a declaration block.

301

302 def generate_const_definitions(self, env, code):

303 if env.const_entries:

304 for entry in env.const_entries:

305 if not entry.is_interned:

306 code.globalstate.add_const_definition(entry)

307

308 def generate_interned_string_decls(self, env, code):

309 entries = env.global_scope().new_interned_string_entries

310 if entries:

311 for entry in entries:

312 code.globalstate.add_interned_string_decl(entry)

313 del entries[:]

314

315 def generate_py_string_decls(self, env, code):

316 if env is None:

317 return # earlier error

318 entries = env.pystring_entries

319 if entries:

320 for entry in entries:

321 if not entry.is_interned:

322 code.globalstate.add_py_string_decl(entry)

323

324 def generate_interned_num_decls(self, env, code):

325 # Flush accumulated interned nums from the global scope

326 # and generate declarations for them.

327 genv = env.global_scope()

328 entries = genv.interned_nums

329 if entries:

330 for entry in entries:

331 code.globalstate.add_interned_num_decl(entry)

332 del entries[:]

333

334 def generate_cached_builtins_decls(self, env, code):

335 entries = env.global_scope().undeclared_cached_builtins

336 for entry in entries:

337 code.globalstate.add_cached_builtin_decl(entry)

338 del entries[:]

339

340

341 class StatListNode(Node):

342 # stats a list of StatNode

343

344 child_attrs = ["stats"]

345

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

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

348 return node # No node-specific analysis necesarry

349 create_analysed = staticmethod(create_analysed)

350

351 def analyse_control_flow(self, env):

352 for stat in self.stats:

353 stat.analyse_control_flow(env)

354

355 def analyse_declarations(self, env):

356 #print "StatListNode.analyse_declarations" ###

357 for stat in self.stats:

358 stat.analyse_declarations(env)

359

360 def analyse_expressions(self, env):

361 #print "StatListNode.analyse_expressions" ###

362 for stat in self.stats:

363 stat.analyse_expressions(env)

364

365 def generate_function_definitions(self, env, code):

366 #print "StatListNode.generate_function_definitions" ###

367 for stat in self.stats:

368 stat.generate_function_definitions(env, code)

369

370 def generate_execution_code(self, code):

371 #print "StatListNode.generate_execution_code" ###

372 for stat in self.stats:

373 code.mark_pos(stat.pos)

374 stat.generate_execution_code(code)

375

376 def annotate(self, code):

377 for stat in self.stats:

378 stat.annotate(code)

379

380

381 class StatNode(Node):

382 #

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

384 #

385 # (1) generate_function_definitions

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

387 # unions, enums and functions defined in the current

388 # scope-block.

389 #

390 # (2) generate_execution_code

391 # Emit C code for executable statements.

392 #

393

394 def generate_function_definitions(self, env, code):

395 pass

396

397 def generate_execution_code(self, code):

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

399 self.__class__.__name__)

400

401

402 class CDefExternNode(StatNode):

403 # include_file string or None

404 # body StatNode

405

406 child_attrs = ["body"]

407

408 def analyse_declarations(self, env):

409 if self.include_file:

410 env.add_include_file(self.include_file)

411 old_cinclude_flag = env.in_cinclude

412 env.in_cinclude = 1

413 self.body.analyse_declarations(env)

414 env.in_cinclude = old_cinclude_flag

415

416 def analyse_expressions(self, env):

417 pass

418

419 def generate_execution_code(self, code):

420 pass

421

422 def annotate(self, code):

423 self.body.annotate(code)

424

425

426 class CDeclaratorNode(Node):

427 # Part of a C declaration.

428 #

429 # Processing during analyse_declarations phase:

430 #

431 # analyse

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

433 # CNameDeclaratorNode of the name being declared

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

435 #

436 # calling_convention string Calling convention of CFuncDeclaratorNode

437 # for which this is a base

438

439 child_attrs = []

440

441 calling_convention = ""

442

443

444 class CNameDeclaratorNode(CDeclaratorNode):

445 # name string The Pyrex name being declared

446 # cname string or None C name, if specified

447 # default ExprNode or None the value assigned on declaration

448

449 child_attrs = ['default']

450

451 default = None

452

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

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

455 # May have mistaken the name for the type.

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

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

458 elif base_type.is_void:

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

460 else:

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

462 base_type = py_object_type

463 self.type = base_type

464 return self, base_type

465

466 class CPtrDeclaratorNode(CDeclaratorNode):

467 # base CDeclaratorNode

468

469 child_attrs = ["base"]

470

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

472 if base_type.is_pyobject:

473 error(self.pos,

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

475 ptr_type = PyrexTypes.c_ptr_type(base_type)

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

477

478 class CArrayDeclaratorNode(CDeclaratorNode):

479 # base CDeclaratorNode

480 # dimension ExprNode

481

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

483

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

485 if self.dimension:

486 self.dimension.analyse_const_expression(env)

487 if not self.dimension.type.is_int:

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

489 size = self.dimension.result()

490 try:

491 size = int(size)

492 except ValueError:

493 # runtime constant?

494 pass

495 else:

496 size = None

497 if not base_type.is_complete():

498 error(self.pos,

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

500 if base_type.is_pyobject:

501 error(self.pos,

502 "Array element cannot be a Python object")

503 if base_type.is_cfunction:

504 error(self.pos,

505 "Array element cannot be a function")

506 array_type = PyrexTypes.c_array_type(base_type, size)

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

508

509

510 class CFuncDeclaratorNode(CDeclaratorNode):

511 # base CDeclaratorNode

512 # args [CArgDeclNode]

513 # has_varargs boolean

514 # exception_value ConstNode

515 # exception_check boolean True if PyErr_Occurred check needed

516 # nogil boolean Can be called without gil

517 # with_gil boolean Acquire gil around function body

518

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

520

521 overridable = 0

522 optional_arg_count = 0

523

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

525 if nonempty:

526 nonempty -= 1

527 func_type_args = []

528 for arg_node in self.args:

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

530 name = name_declarator.name

531 if name_declarator.cname:

532 error(self.pos,

533 "Function argument cannot have C name specification")

534 # Turn *[] argument into **

535 if type.is_array:

536 type = PyrexTypes.c_ptr_type(type.base_type)

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

538 if type.is_void:

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

540 # if type.is_pyobject and self.nogil:

541 # error(self.pos,

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

543 func_type_args.append(

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

545 if arg_node.default:

546 self.optional_arg_count += 1

547 elif self.optional_arg_count:

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

549

550 if self.optional_arg_count:

551 scope = StructOrUnionScope()

552 arg_count_member = '%sn' % Naming.pyrex_prefix

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

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

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

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

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

558 kind = 'struct',

559 scope = scope,

560 typedef_flag = 0,

561 pos = self.pos,

562 cname = struct_cname)

563 self.op_args_struct.defined_in_pxd = 1

564 self.op_args_struct.used = 1

565

566 exc_val = None

567 exc_check = 0

568 if self.exception_check == '+':

569 env.add_include_file('stdexcept')

570 if return_type.is_pyobject \

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

572 and self.exception_check != '+':

573 error(self.pos,

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

575 else:

576 if self.exception_value:

577 self.exception_value.analyse_const_expression(env)

578 if self.exception_check == '+':

579 exc_val_type = self.exception_value.type

580 if not exc_val_type.is_error and \

581 not exc_val_type.is_pyobject and \

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

583 error(self.exception_value.pos,

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

585 exc_val = self.exception_value

586 else:

587 exc_val = self.exception_value.result()

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

589 error(self.exception_value.pos,

590 "Exception value incompatible with function return type")

591 exc_check = self.exception_check

592 if return_type.is_array:

593 error(self.pos,

594 "Function cannot return an array")

595 if return_type.is_cfunction:

596 error(self.pos,

597 "Function cannot return a function")

598 func_type = PyrexTypes.CFuncType(

599 return_type, func_type_args, self.has_varargs,

600 optional_arg_count = self.optional_arg_count,

601 exception_value = exc_val, exception_check = exc_check,

602 calling_convention = self.base.calling_convention,

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

604 if self.optional_arg_count:

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

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

607

608

609 class CArgDeclNode(Node):

610 # Item in a function declaration argument list.

611 #

612 # base_type CBaseTypeNode

613 # declarator CDeclaratorNode

614 # not_none boolean Tagged with 'not None'

615 # default ExprNode or None

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

617 # default_result_code string cname or code fragment for default value

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

619 # is_kw_only boolean Is a keyword-only argument

620

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

622

623 is_self_arg = 0

624 is_generic = 1

625 type = None

626 name_declarator = None

627

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

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

630 if self.type is None:

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

632 # We fix that here.

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

634 if nonempty:

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

636 self.base_type.name = None

637 self.base_type.is_basic_c_type = False

638 could_be_name = True

639 else:

640 could_be_name = False

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

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

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

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

645 else:

646 return self.name_declarator, self.type

647

648 def annotate(self, code):

649 if self.default:

650 self.default.annotate(code)

651

652

653 class CBaseTypeNode(Node):

654 # Abstract base class for C base type nodes.

655 #

656 # Processing during analyse_declarations phase:

657 #

658 # analyse

659 # Returns the type.

660

661 pass

662

663 class CAnalysedBaseTypeNode(Node):

664 # type type

665

666 child_attrs = []

667

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

669 return self.type

670

671 class CSimpleBaseTypeNode(CBaseTypeNode):

672 # name string

673 # module_path [string] Qualifying name components

674 # is_basic_c_type boolean

675 # signed boolean

676 # longness integer

677 # complex boolean

678 # is_self_arg boolean Is self argument of C method

679

680 child_attrs = []

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

682

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

684 # Return type descriptor.

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

686 type = None

687 if self.is_basic_c_type:

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

689 if not type:

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

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

692 type = py_object_type

693 elif self.name is None:

694 if self.is_self_arg and env.is_c_class_scope:

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

696 type = env.parent_type

697 else:

698 type = py_object_type

699 else:

700 if self.module_path:

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

702 else:

703 scope = env

704 if scope:

705 if scope.is_c_class_scope:

706 scope = scope.global_scope()

707 entry = scope.lookup(self.name)

708 if entry and entry.is_type:

709 type = entry.type

710 elif could_be_name:

711 if self.is_self_arg and env.is_c_class_scope:

712 type = env.parent_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 self.type = PyrexTypes.BufferType(base_type, **options)

758 return self.type

759

760 class CComplexBaseTypeNode(CBaseTypeNode):

761 # base_type CBaseTypeNode

762 # declarator CDeclaratorNode

763

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

765

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

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

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

769 return type

770

771

772 class CVarDefNode(StatNode):

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

774 #

775 # visibility 'private' or 'public' or 'extern'

776 # base_type CBaseTypeNode

777 # declarators [CDeclaratorNode]

778 # in_pxd boolean

779 # api boolean

780 # need_properties [entry]

781

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

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

784

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

786 need_properties = ()

787

788 decorators = None

789 directive_locals = {}

790

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

792 if not dest_scope:

793 dest_scope = env

794 self.dest_scope = dest_scope

795 base_type = self.base_type.analyse(env)

796

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

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

799 # a property; made in AnalyseDeclarationsTransform).

800 # Also, if the type is an extension type, then the CPython mechanism does

801 # not do enough type-checking for us.

802 if (dest_scope.is_c_class_scope and

803 ((self.visibility == 'public'

804 and base_type.is_pyobject

805 and (base_type.is_builtin_type or base_type.is_extension_type)

806 or (base_type.is_typedef and base_type.typedef_is_external)))):

807 self.need_properties = []

808 need_property = True

809 visibility = 'private'

810 else:

811 need_property = False

812 visibility = self.visibility

813

814 for declarator in self.declarators:

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

816 if not type.is_complete():

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

818 error(declarator.pos,

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

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

821 error(declarator.pos,

822 "Python object cannot be declared extern")

823 name = name_declarator.name

824 cname = name_declarator.cname

825 if name == '':

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

827 return

828 if type.is_cfunction:

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

830 cname = cname, visibility = self.visibility, in_pxd = self.in_pxd,

831 api = self.api)

832 if entry is not None:

833 entry.directive_locals = self.directive_locals

834 else:

835 if self.directive_locals:

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

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

838 error(self.pos,

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

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

841 cname = cname, visibility = visibility, is_cdef = 1)

842 if need_property:

843 self.need_properties.append(entry)

844 entry.needs_property = 1

845

846

847 class CStructOrUnionDefNode(StatNode):

848 # name string

849 # cname string or None

850 # kind "struct" or "union"

851 # typedef_flag boolean

852 # visibility "public" or "private"

853 # in_pxd boolean

854 # attributes [CVarDefNode] or None

855 # entry Entry

856 # packed boolean

857

858 child_attrs = ["attributes"]

859

860 def analyse_declarations(self, env):

861 scope = None

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

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

864 if self.attributes is not None:

865 scope = StructOrUnionScope(self.name)

866 self.entry = env.declare_struct_or_union(

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

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

869 if self.attributes is not None:

870 if self.in_pxd and not env.in_cinclude:

871 self.entry.defined_in_pxd = 1

872 for attr in self.attributes:

873 attr.analyse_declarations(env, scope)

874 if self.visibility != 'extern':

875 need_typedef_indirection = False

876 for attr in scope.var_entries:

877 type = attr.type

878 while type.is_array:

879 type = type.base_type

880 if type == self.entry.type:

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

882 if self.typedef_flag:

883 while type.is_ptr:

884 type = type.base_type

885 if type == self.entry.type:

886 need_typedef_indirection = True

887 if need_typedef_indirection:

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

889 struct_entry = self.entry

890 cname = env.new_const_cname()

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

892 struct_entry.type.typedef_flag = False

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

894

895 def analyse_expressions(self, env):

896 pass

897

898 def generate_execution_code(self, code):

899 pass

900

901

902 class CEnumDefNode(StatNode):

903 # name string or None

904 # cname string or None

905 # items [CEnumDefItemNode]

906 # typedef_flag boolean

907 # visibility "public" or "private"

908 # in_pxd boolean

909 # entry Entry

910

911 child_attrs = ["items"]

912

913 def analyse_declarations(self, env):

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

915 cname = self.cname, typedef_flag = self.typedef_flag,

916 visibility = self.visibility)

917 if self.items is not None:

918 if self.in_pxd and not env.in_cinclude:

919 self.entry.defined_in_pxd = 1

920 for item in self.items:

921 item.analyse_declarations(env, self.entry)

922

923 def analyse_expressions(self, env):

924 if self.visibility == 'public':

925 self.temp = env.allocate_temp_pyobject()

926 env.release_temp(self.temp)

927

928 def generate_execution_code(self, code):

929 if self.visibility == 'public':

930 for item in self.entry.enum_values:

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

932 self.temp,

933 item.cname,

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

935 code.put_gotref(self.temp)

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

937 Naming.module_cname,

938 item.name,

939 self.temp,

940 code.error_goto(item.pos)))

941 code.put_decref_clear(self.temp, PyrexTypes.py_object_type)

942

943

944 class CEnumDefItemNode(StatNode):

945 # name string

946 # cname string or None

947 # value ExprNode or None

948

949 child_attrs = ["value"]

950

951 def analyse_declarations(self, env, enum_entry):

952 if self.value:

953 self.value.analyse_const_expression(env)

954 if not self.value.type.is_int:

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

956 self.value.analyse_const_expression(env)

957 value = self.value.result()

958 else:

959 value = self.name

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

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

962 enum_entry.enum_values.append(entry)

963

964

965 class CTypeDefNode(StatNode):

966 # base_type CBaseTypeNode

967 # declarator CDeclaratorNode

968 # visibility "public" or "private"

969 # in_pxd boolean

970

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

972

973 def analyse_declarations(self, env):

974 base = self.base_type.analyse(env)

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

976 name = name_declarator.name

977 cname = name_declarator.cname

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

979 cname = cname, visibility = self.visibility)

980 if self.in_pxd and not env.in_cinclude:

981 entry.defined_in_pxd = 1

982

983 def analyse_expressions(self, env):

984 pass

985 def generate_execution_code(self, code):

986 pass

987

988

989 class FuncDefNode(StatNode, BlockNode):

990 # Base class for function definition nodes.

991 #

992 # return_type PyrexType

993 # #filename string C name of filename string const

994 # entry Symtab.Entry

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

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

997

998 py_func = None

999 assmt = None

1000 needs_closure = False

1001

1002 def analyse_default_values(self, env):

1003 genv = env.global_scope()

1004 for arg in self.args:

1005 if arg.default:

1006 if arg.is_generic:

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

1008 arg.default.analyse_types(env)

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

1010 if arg.default.is_literal:

1011 arg.default_entry = arg.default

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

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

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

1015 else:

1016 arg.default.allocate_temps(genv)

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

1018 if arg.type.is_pyobject:

1019 arg.default_entry.init = 0

1020 arg.default_entry.used = 1

1021 arg.default_result_code = arg.default_entry.cname

1022 else:

1023 error(arg.pos,

1024 "This argument cannot have a default value")

1025 arg.default = None

1026

1027 def need_gil_acquisition(self, lenv):

1028 return 0

1029

1030 def create_local_scope(self, env):

1031 genv = env

1032 while env.is_py_class_scope or env.is_c_class_scope:

1033 env = env.outer_scope

1034 if self.needs_closure:

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

1036 else:

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

1038 lenv.return_type = self.return_type

1039 type = self.entry.type

1040 if type.is_cfunction:

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

1042 self.local_scope = lenv

1043 lenv.directives = env.directives

1044 return lenv

1045

1046 def generate_function_definitions(self, env, code):

1047 import Buffer

1048

1049 lenv = self.local_scope

1050

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

1052 self.entry.scope.is_c_class_scope)

1053

1054 # Generate C code for header and body of function

1055 code.enter_cfunc_scope()

1056 code.return_from_error_cleanup_label = code.new_label()

1057

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

1059 code.mark_pos(self.pos)

1060 self.generate_interned_num_decls(lenv, code)

1061 self.generate_interned_string_decls(lenv, code)

1062 self.generate_py_string_decls(lenv, code)

1063 self.generate_cached_builtins_decls(lenv, code)

1064 #code.putln("")

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

1066 self.generate_const_definitions(lenv, code)

1067 # ----- Function header

1068 code.putln("")

1069 if self.py_func:

1070 self.py_func.generate_function_header(code,

1071 with_pymethdef = env.is_py_class_scope,

1072 proto_only=True)

1073 self.generate_function_header(code,

1074 with_pymethdef = env.is_py_class_scope)

1075 # ----- Local variable declarations

1076 lenv.mangle_closure_cnames(Naming.cur_scope_cname)

1077 self.generate_argument_declarations(lenv, code)

1078 if self.needs_closure:

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

1080 code.put_var_declarations(lenv.var_entries)

1081 init = ""

1082 if not self.return_type.is_void:

1083 if self.return_type.is_pyobject:

1084 init = " = NULL"

1085 code.putln(

1086 "%s%s;" %

1087 (self.return_type.declaration_code(

1088 Naming.retval_cname),

1089 init))

1090 tempvardecl_code = code.insertion_point()

1091 self.generate_keyword_list(code)

1092 # ----- Extern library function declarations

1093 lenv.generate_library_function_declarations(code)

1094 # ----- GIL acquisition

1095 acquire_gil = self.need_gil_acquisition(lenv)

1096 if acquire_gil:

1097 env.use_utility_code(force_init_threads_utility_code)

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

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

1100 if not lenv.nogil:

1101 code.put_setup_refcount_context(self.entry.name)

1102 if is_getbuffer_slot:

1103 self.getbuffer_init(code)

1104 # ----- Fetch arguments

1105 self.generate_argument_parsing_code(env, code)

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

1107 # incref it to properly keep track of refcounts.

1108 for entry in lenv.arg_entries:

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

1110 code.put_var_incref(entry)

1111 # ----- Initialise local variables

1112 for entry in lenv.var_entries:

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

1114 code.put_init_var_to_py_none(entry)

1115 # ----- Initialise local buffer auxiliary variables

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

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

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

1119 # ----- Check and convert arguments

1120 self.generate_argument_type_tests(code)

1121 # ----- Acquire buffer arguments

1122 for entry in lenv.arg_entries:

1123 if entry.type.is_buffer:

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

1125 # ----- Function body

1126 self.body.generate_execution_code(code)

1127 # ----- Default return value

1128 code.putln("")

1129 if self.return_type.is_pyobject:

1130 #if self.return_type.is_extension_type:

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

1132 #else:

1133 lhs = Naming.retval_cname

1134 code.put_init_to_py_none(lhs, self.return_type)

1135 else:

1136 val = self.return_type.default_value

1137 if val:

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

1139 # ----- Error cleanup

1140 if code.error_label in code.labels_used:

1141 code.put_goto(code.return_label)

1142 code.put_label(code.error_label)

1143 # cleanup temps the old way

1144 code.put_var_xdecrefs(lenv.temp_entries)

1145 # cleanup temps the new way

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

1147 code.put_xdecref(cname, type)

1148

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

1150 # so need to save and restore error state

1151 buffers_present = len(lenv.buffer_entries) > 0

1152 if buffers_present:

1153 code.globalstate.use_utility_code(restore_exception_utility_code)

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

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

1156 for entry in lenv.buffer_entries:

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

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

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

1160

1161 err_val = self.error_value()

1162 exc_check = self.caller_will_check_exceptions()

1163 if err_val is not None or exc_check:

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

1165 else:

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

1167 % self.entry.qualified_name, 0)

1168 code.putln(

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

1170 self.entry.qualified_name)

1171 env.use_utility_code(unraisable_exception_utility_code)

1172 env.use_utility_code(restore_exception_utility_code)

1173 default_retval = self.return_type.default_value

1174 if err_val is None and default_retval:

1175 err_val = default_retval

1176 if err_val is not None:

1177 code.putln(

1178 "%s = %s;" % (

1179 Naming.retval_cname,

1180 err_val))

1181

1182 if is_getbuffer_slot:

1183 self.getbuffer_error_cleanup(code)

1184

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

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

1187 # whether this section is used.

1188 if buffers_present or is_getbuffer_slot:

1189 code.put_goto(code.return_from_error_cleanup_label)

1190

1191

1192 # ----- Non-error return cleanup

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

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

1195 # block).

1196 code.put_label(code.return_label)

1197 for entry in lenv.buffer_entries:

1198 if entry.used:

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

1200 if is_getbuffer_slot:

1201 self.getbuffer_normal_cleanup(code)

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

1203 code.put_label(code.return_from_error_cleanup_label)

1204 if not Options.init_local_none:

1205 for entry in lenv.var_entries:

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

1207 entry.xdecref_cleanup = 1

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

1209 # Decref any increfed args

1210 for entry in lenv.arg_entries:

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

1212 code.put_var_decref(entry)

1213

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

1215 # ----- Return

1216 # This code is duplicated in ModuleNode.generate_module_init_func

1217 if not lenv.nogil:

1218 default_retval = self.return_type.default_value

1219 err_val = self.error_value()

1220 if err_val is None and default_retval:

1221 err_val = default_retval

1222 if self.return_type.is_pyobject:

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

1224

1225 code.put_finish_refcount_context()

1226

1227 if acquire_gil:

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

1229

1230 if not self.return_type.is_void:

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

1232

1233 code.putln("}")

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

1235 tempvardecl_code.put_var_declarations(lenv.temp_entries)

1236 tempvardecl_code.put_temp_declarations(code.funcstate)

1237 # ----- Python version

1238 code.exit_cfunc_scope()

1239 if self.py_func:

1240 self.py_func.generate_function_definitions(env, code)

1241 self.generate_wrapper_functions(code)

1242

1243 def declare_argument(self, env, arg):

1244 if arg.type.is_void:

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

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

1247 error(arg.pos,

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

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

1250

1251 def generate_wrapper_functions(self, code):

1252 pass

1253

1254 def generate_execution_code(self, code):

1255 # Evaluate and store argument default values

1256 for arg in self.args:

1257 default = arg.default

1258 if default:

1259 if not default.is_literal:

1260 default.generate_evaluation_code(code)

1261 default.make_owned_reference(code)

1262 code.putln(

1263 "%s = %s;" % (

1264 arg.default_entry.cname,

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

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

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

1268 default.free_temps(code)

1269 code.put_var_giveref(arg.default_entry)

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

1271 if self.assmt:

1272 self.assmt.generate_execution_code(code)

1273

1274 #

1275 # Special code for the __getbuffer__ function

1276 #

1277 def getbuffer_init(self, code):

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

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

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

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

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

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

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

1285

1286 def getbuffer_error_cleanup(self, code):

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

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

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

1290 (info, info))

1291

1292 def getbuffer_normal_cleanup(self, code):

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

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

1295 code.put_gotref("Py_None")

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

1297 code.putln("}")

1298

1299 class CFuncDefNode(FuncDefNode):

1300 # C function definition.

1301 #

1302 # modifiers ['inline']

1303 # visibility 'private' or 'public' or 'extern'

1304 # base_type CBaseTypeNode

1305 # declarator CDeclaratorNode

1306 # body StatListNode

1307 # api boolean

1308 # decorators [DecoratorNode] list of decorators

1309 #

1310 # with_gil boolean Acquire GIL around body

1311 # type CFuncType

1312 # py_func wrapper for calling from Python

1313 # overridable whether or not this is a cpdef function

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

1315

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

1317

1318 inline_in_pxd = False

1319 decorators = None

1320 directive_locals = {}

1321

1322 def unqualified_name(self):

1323 return self.entry.name

1324

1325 def analyse_declarations(self, env):

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

1327 base_type = self.base_type.analyse(env)

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

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

1330 if not type.is_cfunction:

1331 error(self.pos,

1332 "Suite attached to non-function declaration")

1333 # Remember the actual type according to the function header

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

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

1336 # from the base type of an extension type.

1337 self.type = type

1338 type.is_overridable = self.overridable

1339 declarator = self.declarator

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

1341 declarator = declarator.base

1342 self.args = declarator.args

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

1344 formal_arg.type = type_arg.type

1345 formal_arg.name = type_arg.name

1346 formal_arg.cname = type_arg.cname

1347 name = name_declarator.name

1348 cname = name_declarator.cname

1349 self.entry = env.declare_cfunction(

1350 name, type, self.pos,

1351 cname = cname, visibility = self.visibility,

1352 defining = self.body is not None,

1353 api = self.api, modifiers = self.modifiers)

1354 self.entry.inline_func_in_pxd = self.inline_in_pxd

1355 self.return_type = type.return_type

1356

1357 if self.overridable and not env.is_module_scope:

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

1359 # An error will be produced in the cdef function

1360 self.overridable = False

1361

1362 if self.overridable:

1363 import ExprNodes

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

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

1366 name = self.entry.name,

1367 args = self.args,

1368 star_arg = None,

1369 starstar_arg = None,

1370 doc = self.doc,

1371 body = py_func_body,

1372 is_wrapper = 1)

1373 self.py_func.is_module_scope = env.is_module_scope

1374 self.py_func.analyse_declarations(env)

1375 self.entry.as_variable = self.py_func.entry

1376 # Reset scope entry the above cfunction

1377 env.entries[name] = self.entry

1378 self.py_func.interned_attr_cname = env.intern_identifier(

1379 self.py_func.entry.name)

1380 if not env.is_module_scope or Options.lookup_module_cpdef:

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

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

1383

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

1385 import ExprNodes

1386 args = self.type.args

1387 if omit_optional_args:

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

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

1390 if is_module_scope:

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

1392 else:

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

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

1395 skip_dispatch = not is_module_scope or Options.lookup_module_cpdef

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

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

1398

1399 def declare_arguments(self, env):

1400 for arg in self.type.args:

1401 if not arg.name:

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

1403 self.declare_argument(env, arg)

1404

1405 def need_gil_acquisition(self, lenv):

1406 type = self.type

1407 with_gil = self.type.with_gil

1408 if type.nogil and not with_gil:

1409 if type.return_type.is_pyobject:

1410 error(self.pos,

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

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

1413 if entry.type.is_pyobject:

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

1415 return with_gil

1416

1417 def analyse_expressions(self, env):

1418 self.local_scope.directives = env.directives

1419 self.analyse_default_values(env)

1420 if self.py_func is not None:

1421 self.py_func.analyse_expressions(env)

1422

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

1424 arg_decls = []

1425 type = self.type

1426 visibility = self.entry.visibility

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

1428 arg_decls.append(arg.declaration_code())

1429 if with_dispatch and self.overridable:

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

1431 if type.optional_arg_count and with_opt_args:

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

1433 if type.has_varargs:

1434 arg_decls.append("...")

1435 if not arg_decls:

1436 arg_decls = ["void"]

1437 if cname is None:

1438 cname = self.entry.func_cname

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

1440 if visibility == 'public':

1441 dll_linkage = "DL_EXPORT"

1442 else:

1443 dll_linkage = None

1444 header = self.return_type.declaration_code(entity,

1445 dll_linkage = dll_linkage)

1446 if visibility == 'extern':

1447 storage_class = "%s " % Naming.extern_c_macro

1448 elif visibility == 'public':

1449 storage_class = ""

1450 else:

1451 storage_class = "static "

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

1453 storage_class,

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

1455 header))

1456

1457 def generate_argument_declarations(self, env, code):

1458 for arg in self.args:

1459 if arg.default:

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

1461

1462 def generate_keyword_list(self, code):

1463 pass

1464

1465 def generate_argument_parsing_code(self, env, code):

1466 i = 0

1467 if self.type.optional_arg_count:

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

1469 for arg in self.args:

1470 if arg.default:

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

1472 # argument name mangling is in place

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

1474 declarator = arg.declarator

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

1476 declarator = declarator.base

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

1478 i += 1

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

1480 code.putln('}')

1481 code.putln('}')

1482

1483 def generate_argument_conversion_code(self, code):

1484 pass

1485

1486 def generate_argument_type_tests(self, code):

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

1488 # class is a supertype of the declared type.

1489 for arg in self.type.args:

1490 if arg.needs_type_test:

1491 self.generate_arg_type_test(arg, code)

1492

1493 def generate_arg_type_test(self, arg, code):

1494 # Generate type test for one argument.

1495 if arg.type.typeobj_is_available():

1496 typeptr_cname = arg.type.typeptr_cname

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

1498 code.putln(

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

1500 arg_code,

1501 typeptr_cname,

1502 not arg.not_none,

1503 arg.name,

1504 type.is_builtin_type,

1505 code.error_goto(arg.pos)))

1506 else:

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

1508 "without type object name specification")

1509

1510 def error_value(self):

1511 if self.return_type.is_pyobject:

1512 return "0"

1513 else:

1514 #return None

1515 return self.entry.type.exception_value

1516

1517 def caller_will_check_exceptions(self):

1518 return self.entry.type.exception_check

1519

1520 def generate_wrapper_functions(self, code):

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

1522 # wrappers to put in the slots here.

1523 k = 0

1524 entry = self.entry

1525 func_type = entry.type

1526 while entry.prev_entry is not None:

1527 k += 1

1528 entry = entry.prev_entry

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

1530 code.putln()

1531 self.generate_function_header(code,

1532 0,

1533 with_dispatch = entry.type.is_overridable,

1534 with_opt_args = entry.type.optional_arg_count,

1535 cname = entry.func_cname)

1536 if not self.return_type.is_void:

1537 code.put('return ')

1538 args = self.type.args

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

1540 if entry.type.is_overridable:

1541 arglist.append(Naming.skip_dispatch_cname)

1542 elif func_type.is_overridable:

1543 arglist.append('0')

1544 if entry.type.optional_arg_count:

1545 arglist.append(Naming.optional_args_cname)

1546 elif func_type.optional_arg_count:

1547 arglist.append('NULL')

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

1549 code.putln('}')

1550

1551

1552 class PyArgDeclNode(Node):

1553 # Argument which must be a Python object (used

1554 # for * and ** arguments).

1555 #

1556 # name string

1557 # entry Symtab.Entry

1558 child_attrs = []

1559

1560

1561 class DecoratorNode(Node):

1562 # A decorator

1563 #

1564 # decorator NameNode or CallNode

1565 child_attrs = ['decorator']

1566

1567

1568 class DefNode(FuncDefNode):

1569 # A Python function definition.

1570 #

1571 # name string the Python name of the function

1572 # decorators [DecoratorNode] list of decorators

1573 # args [CArgDeclNode] formal arguments

1574 # star_arg PyArgDeclNode or None * argument

1575 # starstar_arg PyArgDeclNode or None ** argument

1576 # doc EncodedString or None

1577 # body StatListNode

1578 #

1579 # The following subnode is constructed internally

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

1581 #

1582 # assmt AssignmentNode Function construction/assignment

1583

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

1585

1586 assmt = None

1587 num_kwonly_args = 0

1588 num_required_kw_args = 0

1589 reqd_kw_flags_cname = "0"

1590 is_wrapper = 0

1591 decorators = None

1592 entry = None

1593

1594

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

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

1597 k = rk = r = 0

1598 for arg in self.args:

1599 if arg.kw_only:

1600 k += 1

1601 if not arg.default:

1602 rk += 1

1603 if not arg.default:

1604 r += 1

1605 self.num_kwonly_args = k

1606 self.num_required_kw_args = rk

1607 self.num_required_args = r

1608

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

1610 if self.star_arg:

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

1612 if self.starstar_arg:

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

1614 if cfunc is None:

1615 cfunc_args = []

1616 for formal_arg in self.args:

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

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

1619 cname = None,

1620 type = py_object_type,

1621 pos = formal_arg.pos))

1622 cfunc_type = PyrexTypes.CFuncType(return_type = py_object_type,

1623 args = cfunc_args,

1624 has_varargs = False,

1625 exception_value = None,

1626 exception_check = False,

1627 nogil = False,

1628 with_gil = False,

1629 is_overridable = True)

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

1631 else:

1632 cfunc_type = cfunc.type

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

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

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

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

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

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

1639 formal_arg.type = type_arg.type

1640 formal_arg.name_declarator = name_declarator

1641 import ExprNodes

1642 if cfunc_type.exception_value is None:

1643 exception_value = None

1644 else:

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

1646 declarator = CFuncDeclaratorNode(self.pos,

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

1648 args = self.args,

1649 has_varargs = False,

1650 exception_check = cfunc_type.exception_check,

1651 exception_value = exception_value,

1652 with_gil = cfunc_type.with_gil,

1653 nogil = cfunc_type.nogil)

1654 return CFuncDefNode(self.pos,

1655 modifiers = [],

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

1657 declarator = declarator,

1658 body = self.body,

1659 doc = self.doc,

1660 overridable = cfunc_type.is_overridable,

1661 type = cfunc_type,

1662 with_gil = cfunc_type.with_gil,

1663 nogil = cfunc_type.nogil,

1664 visibility = 'private',

1665 api = False,

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

1667

1668 def analyse_declarations(self, env):

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

1670 for arg in self.args:

1671 if hasattr(arg, 'name'):

1672 type = arg.type

1673 name_declarator = None

1674 else:

1675 base_type = arg.base_type.analyse(env)

1676 name_declarator, type = \

1677 arg.declarator.analyse(base_type, env)

1678 arg.name = name_declarator.name

1679 if arg.name in directive_locals:

1680 type_node = directive_locals[arg.name]

1681 other_type = type_node.analyse_as_type(env)

1682 if other_type is None:

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

1684 elif (type is not PyrexTypes.py_object_type

1685 and not type.same_as(other_type)):

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

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

1688 else:

1689 type = other_type

1690 if name_declarator and name_declarator.cname:

1691 error(self.pos,

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

1693 arg.type = type.as_argument_type()

1694 arg.hdr_type = None

1695 arg.needs_conversion = 0

1696 arg.needs_type_test = 0

1697 arg.is_generic = 1

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

1699 error(self.pos,

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

1701 self.declare_pyfunction(env)

1702 self.analyse_signature(env)

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

1704

1705 def analyse_signature(self, env):

1706 any_type_tests_needed = 0

1707 if self.entry.is_special:

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

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

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

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

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

1713 self.entry.signature = TypeSlots.pyfunction_noargs

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

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

1716 self.entry.signature = TypeSlots.pyfunction_onearg

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

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

1719 self.entry.signature = TypeSlots.unaryfunc

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

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

1722 self.entry.signature = TypeSlots.ibinaryfunc

1723 sig = self.entry.signature

1724 nfixed = sig.num_fixed_args()

1725 for i in range(nfixed):

1726 if i < len(self.args):

1727 arg = self.args[i]

1728 arg.is_generic = 0

1729 if sig.is_self_arg(i):

1730 arg.is_self_arg = 1

1731 arg.hdr_type = arg.type = env.parent_type

1732 arg.needs_conversion = 0

1733 else:

1734 arg.hdr_type = sig.fixed_arg_type(i)

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

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

1737 arg.needs_type_test = 1

1738 any_type_tests_needed = 1

1739 else:

1740 arg.needs_conversion = 1

1741 if arg.needs_conversion:

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

1743 else:

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

1745 else:

1746 self.bad_signature()

1747 return

1748 if nfixed < len(self.args):

1749 if not sig.has_generic_args:

1750 self.bad_signature()

1751 for arg in self.args:

1752 if arg.is_generic and \

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

1754 arg.needs_type_test = 1

1755 any_type_tests_needed = 1

1756 if any_type_tests_needed:

1757 env.use_utility_code(arg_type_test_utility_code)

1758

1759 def bad_signature(self):

1760 sig = self.entry.signature

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

1762 if sig.has_generic_args:

1763 expected_str = expected_str + " or more"

1764 name = self.name

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

1766 desc = "Special method"

1767 else:

1768 desc = "Method"

1769 error(self.pos,

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

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

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

1773

1774 def signature_has_nongeneric_args(self):

1775 argcount = len(self.args)

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

1777 return 0

1778 return 1

1779

1780 def signature_has_generic_args(self):

1781 return self.entry.signature.has_generic_args

1782

1783 def declare_pyfunction(self, env):

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

1785 name = self.name

1786 entry = env.lookup_here(self.name)

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

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

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

1790 self.entry = entry

1791 prefix = env.scope_prefix

1792 entry.func_cname = \

1793 Naming.pyfunc_prefix + prefix + name

1794 entry.pymethdef_cname = \

1795 Naming.pymethdef_prefix + prefix + name

1796 if Options.docstrings:

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

1798 entry.doc_cname = \

1799 Naming.funcdoc_prefix + prefix + name

1800 else:

1801 entry.doc = None

1802

1803 def declare_arguments(self, env):

1804 for arg in self.args:

1805 if not arg.name:

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

1807 if arg.needs_conversion:

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

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

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

1811 if arg.type.is_pyobject:

1812 arg.entry.init = "0"

1813 arg.entry.init_to_none = 0

1814 else:

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

1816 arg.entry.used = 1

1817 arg.entry.is_self_arg = arg.is_self_arg

1818 if not arg.is_self_arg:

1819 arg.name_entry = env.get_string_const(

1820 arg.name, identifier = True)

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

1822 if arg.hdr_type:

1823 if arg.is_self_arg or \

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

1825 arg.entry.is_declared_generic = 1

1826 self.declare_python_arg(env, self.star_arg)

1827 self.declare_python_arg(env, self.starstar_arg)

1828

1829 def declare_python_arg(self, env, arg):

1830 if arg:

1831 entry = env.declare_var(arg.name,

1832 PyrexTypes.py_object_type, arg.pos)

1833 entry.used = 1

1834 entry.init = "0"

1835 entry.init_to_none = 0

1836 entry.xdecref_cleanup = 1

1837 arg.entry = entry

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

1839

1840 def analyse_expressions(self, env):

1841 self.local_scope.directives = env.directives

1842 self.analyse_default_values(env)

1843 if env.is_py_class_scope:

1844 self.synthesize_assignment_node(env)

1845

1846 def synthesize_assignment_node(self, env):

1847 import ExprNodes

1848 self.assmt = SingleAssignmentNode(self.pos,

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

1850 rhs = ExprNodes.UnboundMethodNode(self.pos,

1851 class_cname = env.class_obj_cname,

1852 function = ExprNodes.PyCFunctionNode(self.pos,

1853 pymethdef_cname = self.entry.pymethdef_cname)))

1854 self.assmt.analyse_declarations(env)

1855 self.assmt.analyse_expressions(env)

1856

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

1858 arg_code_list = []

1859 sig = self.entry.signature

1860 if sig.has_dummy_arg:

1861 arg_code_list.append(

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

1863 for arg in self.args:

1864 if not arg.is_generic:

1865 if arg.is_self_arg:

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

1867 else:

1868 arg_code_list.append(

1869 arg.hdr_type.declaration_code(arg.hdr_cname))

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

1871 arg_code_list.append("PyObject *unused")

1872 if sig.has_generic_args:

1873 arg_code_list.append(

1874 "PyObject *%s, PyObject *%s"

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

1876 arg_code = ", ".join(arg_code_list)

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

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

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

1880 if proto_only:

1881 return

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

1883 docstr = self.entry.doc

1884 if not isinstance(docstr, str):

1885 docstr = docstr.utf8encode()

1886 code.putln(

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

1888 self.entry.doc_cname,

1889 split_docstring(escape_byte_string(docstr))))

1890 if with_pymethdef:

1891 code.put(

1892 "static PyMethodDef %s = " %

1893 self.entry.pymethdef_cname)

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

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

1896

1897 def generate_argument_declarations(self, env, code):

1898 for arg in self.args:

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

1900 if arg.needs_conversion:

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

1902 else:

1903 code.put_var_declaration(arg.entry)

1904

1905 def generate_keyword_list(self, code):

1906 if self.signature_has_generic_args() and \

1907 self.signature_has_nongeneric_args():

1908 code.put(

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

1910 Naming.pykwdlist_cname)

1911 for arg in self.args:

1912 if arg.is_generic:

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

1914 code.putln("0};")

1915

1916 def generate_argument_parsing_code(self, env, code):

1917 # Generate PyArg_ParseTuple call for generic

1918 # arguments, if any.

1919 if self.entry.signature.has_dummy_arg:

1920 # get rid of unused argument warning

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

1922

1923 old_error_label = code.new_error_label()

1924 our_error_label = code.error_label

1925 end_label = code.new_label("argument_unpacking_done")

1926

1927 has_kwonly_args = self.num_kwonly_args > 0

1928 has_star_or_kw_args = self.star_arg is not None \

1929 or self.starstar_arg is not None or has_kwonly_args

1930

1931 for arg in self.args:

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

1933 arg.type.create_from_py_utility_code(env)

1934

1935 if not self.signature_has_generic_args():

1936 if has_star_or_kw_args:

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

1938 self.generate_argument_conversion_code(code)

1939

1940 elif not self.signature_has_nongeneric_args():

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

1942 self.generate_stararg_copy_code(code)

1943

1944 else:

1945 positional_args = []

1946 kw_only_args = []

1947 default_seen = 0

1948 for arg in self.args:

1949 arg_entry = arg.entry

1950 if arg.is_generic:

1951 if arg.default:

1952 default_seen = 1

1953 if not arg.is_self_arg:

1954 if arg.kw_only:

1955 kw_only_args.append(arg)

1956 else:

1957 positional_args.append(arg)

1958 elif arg.kw_only:

1959 kw_only_args.append(arg)

1960 default_seen = 1

1961 elif default_seen:

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

1963 elif not arg.is_self_arg:

1964 positional_args.append(arg)

1965

1966 self.generate_tuple_and_keyword_parsing_code(

1967 positional_args, kw_only_args, end_label, code)

1968

1969 code.error_label = old_error_label

1970 if code.label_used(our_error_label):

1971 if not code.label_used(end_label):

1972 code.put_goto(end_label)

1973 code.put_label(our_error_label)

1974 if has_star_or_kw_args:

1975 self.generate_arg_decref(self.star_arg, code)

1976 if self.starstar_arg:

1977 if self.starstar_arg.entry.xdecref_cleanup:

1978 code.put_var_xdecref(self.starstar_arg.entry)

1979 else:

1980 code.put_var_decref(self.starstar_arg.entry)

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

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

1983 if code.label_used(end_label):

1984 code.put_label(end_label)

1985

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

1987 if arg.type.is_pyobject:

1988 if arg.is_generic:

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

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

1991 else:

1992 func = arg.type.from_py_function

1993 if func:

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

1995 arg.entry.cname,

1996 func,

1997 item,

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

1999 else:

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

2001

2002 def generate_arg_xdecref(self, arg, code):

2003 if arg:

2004 code.put_var_xdecref(arg.entry)

2005

2006 def generate_arg_decref(self, arg, code):

2007 if arg:

2008 code.put_var_decref(arg.entry)

2009

2010 def generate_stararg_copy_code(self, code):

2011 if not self.star_arg:

2012 code.globalstate.use_utility_code(raise_argtuple_invalid_utility_code)

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

2014 Naming.args_cname)

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

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

2017 code.putln("}")

2018

2019 code.globalstate.use_utility_code(keyword_string_check_utility_code)

2020

2021 if self.starstar_arg:

2022 if self.star_arg:

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

2024 else:

2025 kwarg_check = "%s" % Naming.kwds_cname

2026 else:

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

2028 Naming.kwds_cname, Naming.kwds_cname)

2029 code.putln(

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

2031 kwarg_check, Naming.kwds_cname, self.name,

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

2033

2034 if self.starstar_arg:

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

2036 self.starstar_arg.entry.cname,

2037 Naming.kwds_cname,

2038 Naming.kwds_cname))

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

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

2041 self.starstar_arg.entry.xdecref_cleanup = 0

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

2043

2044

2045 if self.star_arg:

2046 code.put_incref(Naming.args_cname, py_object_type)

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

2048 self.star_arg.entry.cname,

2049 Naming.args_cname))

2050 self.star_arg.entry.xdecref_cleanup = 0

2051

2052 def generate_tuple_and_keyword_parsing_code(self, positional_args,

2053 kw_only_args, success_label, code):

2054 argtuple_error_label = code.new_label("argtuple_error")

2055

2056 min_positional_args = self.num_required_args - self.num_required_kw_args

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

2058 min_positional_args -= 1

2059 max_positional_args = len(positional_args)

2060 has_fixed_positional_count = not self.star_arg and \

2061 min_positional_args == max_positional_args

2062

2063 code.globalstate.use_utility_code(raise_double_keywords_utility_code)

2064 code.globalstate.use_utility_code(raise_argtuple_invalid_utility_code)

2065 if self.num_required_kw_args:

2066 code.globalstate.use_utility_code(raise_keyword_required_utility_code)

2067

2068 if self.starstar_arg or self.star_arg:

2069 self.generate_stararg_init_code(max_positional_args, code)

2070

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

2072 if self.num_required_kw_args:

2073 likely_hint = "likely"

2074 else:

2075 likely_hint = "unlikely"

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

2077 self.generate_keyword_unpacking_code(

2078 min_positional_args, max_positional_args,

2079 has_fixed_positional_count,

2080 positional_args, kw_only_args, argtuple_error_label, code)

2081

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

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

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

2085 # check the length here

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

2087 compare = '!='

2088 else:

2089 compare = '<'

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

2091 Naming.args_cname, compare, min_positional_args))

2092 code.put_goto(argtuple_error_label)

2093

2094 if self.num_required_kw_args:

2095 # pure error case: keywords required but not passed

2096 if max_positional_args > min_positional_args and not self.star_arg:

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

2098 Naming.args_cname, max_positional_args))

2099 code.put_goto(argtuple_error_label)

2100 code.putln('} else {')

2101 for i, arg in enumerate(kw_only_args):

2102 if not arg.default:

2103 # required keyword-only argument missing

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

2105 self.name.utf8encode(),

2106 arg.name_entry.pystring_cname))

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

2108 break

2109

2110 elif min_positional_args == max_positional_args:

2111 # parse the exact number of positional arguments from the

2112 # args tuple

2113 code.putln('} else {')

2114 for i, arg in enumerate(positional_args):

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

2116 self.generate_arg_assignment(arg, item, code)

2117 self.generate_arg_default_assignments(code)

2118

2119 else:

2120 # parse the positional arguments from the variable length

2121 # args tuple

2122 code.putln('} else {')

2123 self.generate_arg_default_assignments(code)

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

2125 if self.star_arg:

2126 code.putln('default:')

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

2128 for i, arg in reversed_args:

2129 if i >= min_positional_args-1:

2130 if min_positional_args > 1:

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

2132 else:

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

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

2135 self.generate_arg_assignment(arg, item, code)

2136 if min_positional_args == 0:

2137 code.put('case 0: ')

2138 code.putln('break;')

2139 if self.star_arg:

2140 if min_positional_args:

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

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

2143 code.put_goto(argtuple_error_label)

2144 else:

2145 code.put('default: ')

2146 code.put_goto(argtuple_error_label)

2147 code.putln('}')

2148

2149 code.putln('}')

2150

2151 if code.label_used(argtuple_error_label):

2152 code.put_goto(success_label)

2153 code.put_label(argtuple_error_label)

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

2155 self.name.utf8encode(), has_fixed_positional_count,

2156 min_positional_args, max_positional_args,

2157 Naming.args_cname))

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

2159

2160 def generate_arg_default_assignments(self, code):

2161 for arg in self.args:

2162 if arg.is_generic and arg.default:

2163 code.putln(

2164 "%s = %s;" % (

2165 arg.entry.cname,

2166 arg.default_result_code))

2167

2168 def generate_stararg_init_code(self, max_positional_args, code):

2169 if self.starstar_arg:

2170 self.starstar_arg.entry.xdecref_cleanup = 0

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

2172 self.starstar_arg.entry.cname,

2173 self.starstar_arg.entry.cname,

2174 self.error_value()))

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

2176 if self.star_arg:

2177 self.star_arg.entry.xdecref_cleanup = 0

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

2179 Naming.args_cname,

2180 max_positional_args))

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

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

2183 max_positional_args, Naming.args_cname))

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

2185 if self.starstar_arg:

2186 code.putln("")

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

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

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

2190 code.putln('}')

2191 else:

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

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

2194 code.putln('} else {')

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

2196 code.put_incref(Naming.empty_tuple, py_object_type)

2197 code.putln('}')

2198

2199 def generate_keyword_unpacking_code(self, min_positional_args, max_positional_args,

2200 has_fixed_positional_count, positional_args,

2201 kw_only_args, argtuple_error_label, code):

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

2203 max_args = len(all_args)

2204

2205 default_args = []

2206 for i, arg in enumerate(all_args):

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

2208 default_value = arg.default_result_code

2209 if arg.type is not PyrexTypes.py_object_type:

2210 default_value = "(PyObject*)"+default_value

2211 default_args.append((i, default_value))

2212

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

2214 Naming.kwds_cname)

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

2216 # default value, but C89 needs this

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

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

2219 for i, default_value in default_args:

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

2221

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

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

2224 if self.star_arg:

2225 code.putln('default:')

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

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

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

2229 i, Naming.args_cname, i))

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

2231 if not self.star_arg:

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

2233 code.put_goto(argtuple_error_label)

2234 code.putln('}')

2235

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

2237 # from the kw dict

2238 if self.num_required_args or max_positional_args > 0:

2239 last_required_arg = -1

2240 for i, arg in enumerate(all_args):

2241 if not arg.default:

2242 last_required_arg = i

2243 if last_required_arg < max_positional_args:

2244 last_required_arg = max_positional_args-1

2245 num_required_args = self.num_required_args

2246 if max_positional_args > 0:

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

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

2249 if max_positional_args > 0 and i <= max_positional_args:

2250 if self.star_arg and i == max_positional_args:

2251 code.putln('default:')

2252 else:

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

2254 if arg.default:

2255 if arg.kw_only:

2256 # handled separately below

2257 continue

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

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

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

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

2262 code.putln('}')

2263 else:

2264 num_required_args -= 1

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

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

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

2268 if i < min_positional_args:

2269 if i == 0:

2270 # special case: we know arg 0 is missing

2271 code.put('else ')

2272 code.put_goto(argtuple_error_label)

2273 else:

2274 # print the correct number of values (args or

2275 # kwargs) that were passed into positional

2276 # arguments up to this point

2277 code.putln('else {')

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

2279 self.name.utf8encode(), has_fixed_positional_count,

2280 min_positional_args, max_positional_args, i))

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

2282 code.putln('}')

2283 elif arg.kw_only:

2284 code.putln('else {')

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

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

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

2288 code.putln('}')

2289 if max_positional_args > 0:

2290 code.putln('}')

2291

2292 if kw_only_args and not self.starstar_arg:

2293 # unpack optional keyword-only arguments

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

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

2296 optional_args = []

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

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

2299 continue

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

2301 if optional_args:

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

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

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

2305 for i, arg in optional_args:

2306 code.putln(

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

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

2309 code.putln(

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

2311 code.putln('break;')

2312 code.putln('}')

2313

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

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

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

2317 #

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

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

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

2321 # common cases above.

2322 if max_positional_args == 0:

2323 pos_arg_count = "0"

2324 elif self.star_arg:

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

2326 Naming.args_cname, max_positional_args,

2327 Naming.args_cname, max_positional_args))

2328 pos_arg_count = "used_pos_args"

2329 else:

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

2331 code.globalstate.use_utility_code(parse_keywords_utility_code)

2332 code.put(

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

2334 Naming.kwds_cname,

2335 Naming.pykwdlist_cname,

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

2337 pos_arg_count,

2338 self.name.utf8encode()))

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

2340 code.putln('}')

2341

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

2343 for i, arg in enumerate(all_args):

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

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

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

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

2348 code.putln('} else {')

2349 code.putln(

2350 "%s = %s;" % (

2351 arg.entry.cname,

2352 arg.default_result_code))

2353 code.putln('}')

2354

2355 def generate_argument_conversion_code(self, code):

2356 # Generate code to convert arguments from

2357 # signature type to declared type, if needed.

2358 for arg in self.args:

2359 if arg.needs_conversion:

2360 self.generate_arg_conversion(arg, code)

2361

2362 def generate_arg_conversion(self, arg, code):

2363 # Generate conversion code for one argument.

2364 old_type = arg.hdr_type

2365 new_type = arg.type

2366 if old_type.is_pyobject:

2367 if arg.default:

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

2369 else:

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

2371 self.generate_arg_conversion_from_pyobject(arg, code)

2372 code.putln("}")

2373 elif new_type.is_pyobject:

2374 self.generate_arg_conversion_to_pyobject(arg, code)

2375 else:

2376 if new_type.assignable_from(old_type):

2377 code.putln(

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

2379 else:

2380 error(arg.pos,

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

2382 (old_type, new_type))

2383

2384 def generate_arg_conversion_from_pyobject(self, arg, code):

2385 new_type = arg.type

2386 func = new_type.from_py_function

2387 # copied from CoerceFromPyTypeNode

2388 if func:

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

2390 arg.entry.cname,

2391 func,

2392 arg.hdr_cname,

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

2394 else:

2395 error(arg.pos,

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

2397 % new_type)

2398

2399 def generate_arg_conversion_to_pyobject(self, arg, code):

2400 old_type = arg.hdr_type

2401 func = old_type.to_py_function

2402 if func:

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

2404 arg.entry.cname,

2405 func,

2406 arg.hdr_cname,

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

2408 code.put_var_gotref(arg.entry)

2409 else:

2410 error(arg.pos,

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

2412 % old_type)

2413

2414 def generate_argument_type_tests(self, code):

2415 # Generate type tests for args whose signature

2416 # type is PyObject * and whose declared type is

2417 # a subtype thereof.

2418 for arg in self.args:

2419 if arg.needs_type_test:

2420 self.generate_arg_type_test(arg, code)

2421

2422 def generate_arg_type_test(self, arg, code):

2423 # Generate type test for one argument.

2424 if arg.type.typeobj_is_available():

2425 typeptr_cname = arg.type.typeptr_cname

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

2427 code.putln(

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

2429 arg_code,

2430 typeptr_cname,

2431 not arg.not_none,

2432 arg.name,

2433 arg.type.is_builtin_type,

2434 code.error_goto(arg.pos)))

2435 else:

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

2437 "without type object name specification")

2438

2439 def error_value(self):

2440 return self.entry.signature.error_value

2441

2442 def caller_will_check_exceptions(self):

2443 return 1

2444

2445 class OverrideCheckNode(StatNode):

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

2447 # is overriden.

2448 #

2449 # py_func

2450 #

2451 # args

2452 # func_temp

2453 # body

2454

2455 child_attrs = ['body']

2456

2457 body = None

2458

2459 def analyse_expressions(self, env):

2460 self.args = env.arg_entries

2461 if self.py_func.is_module_scope:

2462 first_arg = 0

2463 else:

2464 first_arg = 1

2465 import ExprNodes

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

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

2468 call_node = ExprNodes.SimpleCallNode(self.pos,

2469 function=self.func_node,

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

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

2472 self.body.analyse_expressions(env)

2473

2474 def generate_execution_code(self, code):

2475 # Check to see if we are an extension type

2476 if self.py_func.is_module_scope:

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

2478 else:

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

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

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

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

2483 if self.py_func.is_module_scope:

2484 code.putln("else {")

2485 else:

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

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

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

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

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

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

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

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

2494 self.body.generate_execution_code(code)

2495 code.putln('}')

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

2497 code.putln("}")

2498

2499 class ClassDefNode(StatNode, BlockNode):

2500 pass

2501

2502 class PyClassDefNode(ClassDefNode):

2503 # A Python class definition.

2504 #

2505 # name EncodedString Name of the class

2506 # doc string or None

2507 # body StatNode Attribute definition code

2508 # entry Symtab.Entry

2509 # scope PyClassScope

2510 #

2511 # The following subnodes are constructed internally:

2512 #

2513 # dict DictNode Class dictionary

2514 # classobj ClassNode Class object

2515 # target NameNode Variable to assign class object to

2516

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

2518

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

2520 StatNode.__init__(self, pos)

2521 self.name = name

2522 self.doc = doc

2523 self.body = body

2524 import ExprNodes

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

2526 if self.doc and Options.docstrings:

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

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

2529 else:

2530 doc_node = None

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

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

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

2534

2535 def as_cclass(self):

2536 """

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

2538 """

2539 bases = self.classobj.bases.args

2540 if len(bases) == 0:

2541 base_class_name = None

2542 base_class_module = None

2543 elif len(bases) == 1:

2544 base = bases[0]

2545 path = []

2546 from ExprNodes import AttributeNode, NameNode

2547 while isinstance(base, AttributeNode):

2548 path.insert(0, base.attribute)

2549 base = base.obj

2550 if isinstance(base, NameNode):

2551 path.insert(0, base.name)

2552 base_class_name = path[-1]

2553 if len(path) > 1:

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

2555 else:

2556 base_class_module = None

2557 else:

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

2559 else:

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

2561 return None

2562

2563 return CClassDefNode(self.pos,

2564 visibility = 'private',

2565 module_name = None,

2566 class_name = self.name,

2567 base_class_module = base_class_module,

2568 base_class_name = base_class_name,

2569 body = self.body,

2570 in_pxd = False,

2571 doc = self.doc)

2572

2573 def create_scope(self, env):

2574 genv = env

2575 while env.is_py_class_scope or env.is_c_class_scope:

2576 env = env.outer_scope

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

2578 return cenv

2579

2580 def analyse_declarations(self, env):

2581 self.target.analyse_target_declaration(env)

2582 cenv = self.create_scope(env)

2583 cenv.directives = env.directives

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

2585 self.body.analyse_declarations(cenv)

2586

2587 def analyse_expressions(self, env):

2588 self.dict.analyse_expressions(env)

2589 self.classobj.analyse_expressions(env)

2590 genv = env.global_scope()

2591 cenv = self.scope

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

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

2594 self.body.analyse_expressions(cenv)

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

2596 self.dict.release_temp(env)

2597 #self.classobj.release_temp(env)

2598 #self.target.release_target_temp(env)

2599

2600 def generate_function_definitions(self, env, code):

2601 self.generate_py_string_decls(self.scope, code)

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

2603

2604 def generate_execution_code(self, code):

2605 self.dict.generate_evaluation_code(code)

2606 self.classobj.generate_evaluation_code(code)

2607 self.body.generate_execution_code(code)

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

2609 self.dict.generate_disposal_code(code)

2610 self.dict.free_temps(code)

2611

2612

2613 class CClassDefNode(ClassDefNode):

2614 # An extension type definition.

2615 #

2616 # visibility 'private' or 'public' or 'extern'

2617 # typedef_flag boolean

2618 # api boolean

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

2620 # class_name string Unqualified name of class

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

2622 # base_class_module string or None Module containing the base class

2623 # base_class_name string or None Name of the base class

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

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

2626 # in_pxd boolean Is in a .pxd file

2627 # doc string or None

2628 # body StatNode or None

2629 # entry Symtab.Entry

2630 # base_type PyExtensionType or None

2631 # buffer_defaults_node DictNode or None Declares defaults for a buffer

2632 # buffer_defaults_pos

2633

2634 child_attrs = ["body"]

2635 buffer_defaults_node = None

2636 buffer_defaults_pos = None

2637 typedef_flag = False

2638 api = False

2639 objstruct_name = None

2640 typeobj_name = None

2641

2642 def analyse_declarations(self, env):

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

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

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

2646

2647 import Buffer

2648 if self.buffer_defaults_node:

2649 buffer_defaults = Buffer.analyse_buffer_options(self.buffer_defaults_pos,

2650 env, [], self.buffer_defaults_node,

2651 need_complete=False)

2652 else:

2653 buffer_defaults = None

2654

2655 if env.in_cinclude and not self.objstruct_name:

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

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

2658 self.base_type = None

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

2660 # import the modules for extern classes.

2661 if self.module_name:

2662 self.module = None

2663 for module in env.cimported_modules:

2664 if module.name == self.module_name:

2665 self.module = module

2666 if self.module is None:

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

2668 self.module.has_extern_class = 1

2669 env.add_imported_module(self.module)

2670

2671 if self.base_class_name:

2672 if self.base_class_module:

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

2674 else:

2675 base_class_scope = env

2676 if self.base_class_name == 'object':

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

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

2679 self.base_class_name = None

2680 self.base_class_module = None

2681 base_class_scope = None

2682 if base_class_scope:

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

2684 if base_class_entry:

2685 if not base_class_entry.is_type:

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

2687 elif not base_class_entry.type.is_extension_type:

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

2689 elif not base_class_entry.type.is_complete():

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

2691 else:

2692 self.base_type = base_class_entry.type

2693 has_body = self.body is not None

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

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

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

2697 if not home_scope:

2698 return

2699 else:

2700 home_scope = env

2701

2702 if self.visibility == 'extern':

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

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

2705

2706 self.entry = home_scope.declare_c_class(

2707 name = self.class_name,

2708 pos = self.pos,

2709 defining = has_body and self.in_pxd,

2710 implementing = has_body and not self.in_pxd,

2711 module_name = self.module_name,

2712 base_type = self.base_type,

2713 objstruct_cname = self.objstruct_name,

2714 typeobj_cname = self.typeobj_name,

2715 visibility = self.visibility,

2716 typedef_flag = self.typedef_flag,

2717 api = self.api,

2718 buffer_defaults = buffer_defaults)

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

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

2721 scope = self.entry.type.scope

2722 if scope is not None:

2723 scope.directives = env.directives

2724

2725 if self.doc and Options.docstrings:

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

2727

2728 if has_body:

2729 self.body.analyse_declarations(scope)

2730 if self.in_pxd:

2731 scope.defined = 1

2732 else:

2733 scope.implemented = 1

2734 env.allocate_vtable_names(self.entry)

2735

2736 def analyse_expressions(self, env):

2737 if self.body:

2738 scope = self.entry.type.scope

2739 self.body.analyse_expressions(scope)

2740

2741 def generate_function_definitions(self, env, code):

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

2743 if self.body:

2744 self.body.generate_function_definitions(

2745 self.entry.type.scope, code)

2746

2747 def generate_execution_code(self, code):

2748 # This is needed to generate evaluation code for

2749 # default values of method arguments.

2750 if self.body:

2751 self.body.generate_execution_code(code)

2752

2753 def annotate(self, code):

2754 if self.body:

2755 self.body.annotate(code)

2756

2757

2758 class PropertyNode(StatNode):

2759 # Definition of a property in an extension type.

2760 #

2761 # name string

2762 # doc EncodedString or None Doc string

2763 # body StatListNode

2764

2765 child_attrs = ["body"]

2766

2767 def analyse_declarations(self, env):

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

2769 if entry:

2770 if self.doc and Options.docstrings:

2771 doc_entry = env.get_string_const(

2772 self.doc, identifier = False)

2773 entry.doc_cname = doc_entry.cname

2774 entry.scope.directives = env.directives

2775 self.body.analyse_declarations(entry.scope)

2776

2777 def analyse_expressions(self, env):

2778 self.body.analyse_expressions(env)

2779

2780 def generate_function_definitions(self, env, code):

2781 self.body.generate_function_definitions(env, code)

2782

2783 def generate_execution_code(self, code):

2784 pass

2785

2786 def annotate(self, code):

2787 self.body.annotate(code)

2788

2789

2790 class GlobalNode(StatNode):

2791 # Global variable declaration.

2792 #

2793 # names [string]

2794

2795 child_attrs = []

2796

2797 def analyse_declarations(self, env):

2798 for name in self.names:

2799 env.declare_global(name, self.pos)

2800

2801 def analyse_expressions(self, env):

2802 pass

2803

2804 def generate_execution_code(self, code):

2805 pass

2806

2807

2808 class ExprStatNode(StatNode):

2809 # Expression used as a statement.

2810 #

2811 # expr ExprNode

2812

2813 child_attrs = ["expr"]

2814

2815 def analyse_declarations(self, env):

2816 import ExprNodes

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

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

2819 if func == u'declare':

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

2821 if len(args):

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

2823 for var, type_node in kwds.key_value_pairs:

2824 type = type_node.analyse_as_type(env)

2825 if type is None:

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

2827 else:

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

2829 self.__class__ = PassStatNode

2830

2831 def analyse_expressions(self, env):

2832 self.expr.analyse_expressions(env)

2833 self.expr.release_temp(env)

2834

2835 def generate_execution_code(self, code):

2836 self.expr.generate_evaluation_code(code)

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

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

2839 self.expr.generate_disposal_code(code)

2840 self.expr.free_temps(code)

2841

2842 def annotate(self, code):

2843 self.expr.annotate(code)

2844

2845

2846 class AssignmentNode(StatNode):

2847 # Abstract base class for assignment nodes.

2848 #

2849 # The analyse_expressions and generate_execution_code

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

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

2852 # parallel assignment to be evaluated before assigning

2853 # to any of the left hand sides.

2854

2855 def analyse_expressions(self, env):

2856 self.analyse_types(env)

2857 self.allocate_rhs_temps(env)

2858 self.allocate_lhs_temps(env)

2859

2860 # def analyse_expressions(self, env):

2861 # self.analyse_expressions_1(env)

2862 # self.analyse_expressions_2(env)

2863

2864 def generate_execution_code(self, code):

2865 self.generate_rhs_evaluation_code(code)

2866 self.generate_assignment_code(code)

2867

2868

2869 class SingleAssignmentNode(AssignmentNode):

2870 # The simplest case:

2871 #

2872 # a = b

2873 #

2874 # lhs ExprNode Left hand side

2875 # rhs ExprNode Right hand side

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

2877

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

2879 first = False

2880 declaration_only = False

2881

2882 def analyse_declarations(self, env):

2883 import ExprNodes

2884

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

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

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

2888 if func_name:

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

2890

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

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

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

2894 return

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

2896 if type is None:

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

2898 return

2899 lhs = self.lhs

2900 if func_name == 'declare':

2901 if isinstance(lhs, ExprNodes.NameNode):

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

2903 elif isinstance(lhs, ExprNodes.TupleNode):

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

2905 else:

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

2907 return

2908 for var, pos in vars:

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

2910 if len(args) == 2:

2911 # we have a value

2912 self.rhs = args[1]

2913 else:

2914 self.declaration_only = True

2915 else:

2916 self.declaration_only = True

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

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

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

2920

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

2922 self.declaration_only = True

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

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

2925 return

2926 members = []

2927 for member, type_node in kwds.key_value_pairs:

2928 type = type_node.analyse_as_type(env)

2929 if type is None:

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

2931 else:

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

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

2934 return

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

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

2937 name = self.lhs.name

2938 scope = StructOrUnionScope(name)

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

2940 for member, type, pos in members:

2941 scope.declare_var(member, type, pos)

2942

2943 if self.declaration_only:

2944 return

2945 else:

2946 self.lhs.analyse_target_declaration(env)

2947

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

2949 self.rhs.analyse_types(env)

2950 self.lhs.analyse_target_types(env)

2951 self.lhs.gil_assignment_check(env)

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

2953 if use_temp:

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

2955

2956 def allocate_rhs_temps(self, env):

2957 self.rhs.allocate_temps(env)

2958

2959 def allocate_lhs_temps(self, env):

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

2961 #self.lhs.release_target_temp(env)

2962 #self.rhs.release_temp(env)

2963

2964 def generate_rhs_evaluation_code(self, code):

2965 self.rhs.generate_evaluation_code(code)

2966

2967 def generate_assignment_code(self, code):

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

2969

2970 def annotate(self, code):

2971 self.lhs.annotate(code)

2972 self.rhs.annotate(code)

2973

2974

2975 class CascadedAssignmentNode(AssignmentNode):

2976 # An assignment with multiple left hand sides:

2977 #

2978 # a = b = c

2979 #

2980 # lhs_list [ExprNode] Left hand sides

2981 # rhs ExprNode Right hand sides

2982 #

2983 # Used internally:

2984 #

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

2986

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

2988 coerced_rhs_list = None

2989

2990 def analyse_declarations(self, env):

2991 for lhs in self.lhs_list:

2992 lhs.analyse_target_declaration(env)

2993

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

2995 self.rhs.analyse_types(env)

2996 if use_temp:

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

2998 else:

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

3000 from ExprNodes import CloneNode

3001 self.coerced_rhs_list = []

3002 for lhs in self.lhs_list:

3003 lhs.analyse_target_types(env)

3004 lhs.gil_assignment_check(env)

3005 rhs = CloneNode(self.rhs)

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

3007 self.coerced_rhs_list.append(rhs)

3008

3009 def allocate_rhs_temps(self, env):

3010 self.rhs.allocate_temps(env)

3011

3012 def allocate_lhs_temps(self, env):

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

3014 rhs.allocate_temps(env)

3015 lhs.allocate_target_temps(env, rhs)

3016 #lhs.release_target_temp(env)

3017 #rhs.release_temp(env)

3018 self.rhs.release_temp(env)

3019

3020 def generate_rhs_evaluation_code(self, code):

3021 self.rhs.generate_evaluation_code(code)

3022

3023 def generate_assignment_code(self, code):

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

3025 lhs = self.lhs_list[i]

3026 rhs = self.coerced_rhs_list[i]

3027 rhs.generate_evaluation_code(code)

3028 lhs.generate_assignment_code(rhs, code)

3029 # Assignment has disposed of the cloned RHS

3030 self.rhs.generate_disposal_code(code)

3031 self.rhs.free_temps(code)

3032

3033 def annotate(self, code):

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

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

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

3037 self.rhs.annotate(code)

3038

3039

3040 class ParallelAssignmentNode(AssignmentNode):

3041 # A combined packing/unpacking assignment:

3042 #

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

3044 #

3045 # This has been rearranged by the parser into

3046 #

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

3048 #

3049 # but we must evaluate all the right hand sides

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

3051 #

3052 # stats [AssignmentNode] The constituent assignments

3053

3054 child_attrs = ["stats"]

3055

3056 def analyse_declarations(self, env):

3057 for stat in self.stats:

3058 stat.analyse_declarations(env)

3059

3060 def analyse_expressions(self, env):

3061 for stat in self.stats:

3062 stat.analyse_types(env, use_temp = 1)

3063 stat.allocate_rhs_temps(env)

3064 for stat in self.stats:

3065 stat.allocate_lhs_temps(env)

3066

3067 # def analyse_expressions(self, env):

3068 # for stat in self.stats:

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

3070 # for stat in self.stats:

3071 # stat.analyse_expressions_2(env)

3072

3073 def generate_execution_code(self, code):

3074 for stat in self.stats:

3075 stat.generate_rhs_evaluation_code(code)

3076 for stat in self.stats:

3077 stat.generate_assignment_code(code)

3078

3079 def annotate(self, code):

3080 for stat in self.stats:

3081 stat.annotate(code)

3082

3083

3084 class InPlaceAssignmentNode(AssignmentNode):

3085 # An in place arithmatic operand:

3086 #

3087 # a += b

3088 # a -= b

3089 # ...

3090 #

3091 # lhs ExprNode Left hand side

3092 # rhs ExprNode Right hand side

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

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

3095 #

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

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

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

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

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

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

3102

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

3104 dup = None

3105

3106 def analyse_declarations(self, env):

3107 self.lhs.analyse_target_declaration(env)

3108

3109 def analyse_types(self, env):

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

3111 self.rhs.analyse_types(env)

3112 self.lhs.analyse_target_types(env)

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

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

3115

3116 def allocate_rhs_temps(self, env):

3117 import ExprNodes

3118 if self.lhs.type.is_pyobject:

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

3120 elif self.rhs.type.is_pyobject:

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

3122 if self.lhs.type.is_pyobject:

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

3124 self.result_value.allocate_temps(env)

3125 # if use_temp:

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

3127 self.rhs.allocate_temps(env)

3128 self.dup.allocate_subexpr_temps(env)

3129 self.dup.allocate_temp(env)

3130

3131 def allocate_lhs_temps(self, env):

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

3133 # self.lhs.release_target_temp(env)

3134 self.dup.release_temp(env)

3135 if self.dup.is_temp:

3136 self.dup.release_subexpr_temps(env)

3137 # self.rhs.release_temp(env)

3138 if self.lhs.type.is_pyobject:

3139 self.result_value.release_temp(env)

3140

3141 def generate_execution_code(self, code):

3142 import ExprNodes

3143 self.rhs.generate_evaluation_code(code)

3144 self.dup.generate_subexpr_evaluation_code(code)

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

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

3147 if self.dup.is_temp:

3148 self.dup.allocate_temp_result(code)

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

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

3151 extra = ", Py_None"

3152 else:

3153 extra = ""

3154 if self.lhs.type.is_pyobject:

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

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

3157 self.dup.generate_result_code(code)

3158 code.putln(

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

3160 self.result_value.result(),

3161 self.py_operation_function(),

3162 self.dup.py_result(),

3163 self.rhs.py_result(),

3164 extra,

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

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

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

3168 self.rhs.generate_disposal_code(code)

3169 self.rhs.free_temps(code)

3170 self.dup.generate_disposal_code(code)

3171 self.dup.free_temps(code)

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

3173 else:

3174 c_op = self.operator

3175 if c_op == "//":

3176 c_op = "/"

3177 elif c_op == "**":

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

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

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

3181

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

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

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

3185 else:

3186 self.dup.generate_result_code(code)

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

3188 self.rhs.generate_disposal_code(code)

3189 self.rhs.free_temps(code)

3190 if self.dup.is_temp:

3191 self.dup.generate_subexpr_disposal_code(code)

3192 self.dup.free_subexpr_temps(code)

3193

3194 def create_dup_node(self, env):

3195 import ExprNodes

3196 self.dup = self.lhs

3197 self.dup.analyse_types(env)

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

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

3200 name = self.dup.name,

3201 is_temp = self.dup.is_temp,

3202 entry = self.dup.entry)

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

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

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

3206 attribute = self.dup.attribute,

3207 is_temp = self.dup.is_temp)

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

3209 if self.lhs.index:

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

3211 else:

3212 index = None

3213 if self.lhs.indices:

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

3215 else:

3216 indices = []

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

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

3219 index = index,

3220 indices = indices,

3221 is_temp = self.dup.is_temp)

3222 else:

3223 assert False

3224 self.lhs = target_lhs

3225 return self.dup

3226

3227 def py_operation_function(self):

3228 return self.py_functions[self.operator]

3229

3230 py_functions = {

3231 "|": "PyNumber_InPlaceOr",

3232 "^": "PyNumber_InPlaceXor",

3233 "&": "PyNumber_InPlaceAnd",

3234 "+": "PyNumber_InPlaceAdd",

3235 "-": "PyNumber_InPlaceSubtract",

3236 "*": "PyNumber_InPlaceMultiply",

3237 "/": "PyNumber_InPlaceDivide",

3238 "%": "PyNumber_InPlaceRemainder",

3239 "<<": "PyNumber_InPlaceLshift",

3240 ">>": "PyNumber_InPlaceRshift",

3241 "**": "PyNumber_InPlacePower",

3242 "//": "PyNumber_InPlaceFloorDivide",

3243 }

3244

3245 def annotate(self, code):

3246 self.lhs.annotate(code)

3247 self.rhs.annotate(code)

3248 self.dup.annotate(code)

3249

3250

3251 class PrintStatNode(StatNode):

3252 # print statement

3253 #

3254 # arg_tuple TupleNode

3255 # append_newline boolean

3256

3257 child_attrs = ["arg_tuple"]

3258

3259 def analyse_expressions(self, env):

3260 self.arg_tuple.analyse_expressions(env)

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

3262 self.arg_tuple.release_temp(env)

3263 env.use_utility_code(printing_utility_code)

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

3265 env.use_utility_code(printing_one_utility_code)

3266 self.gil_check(env)

3267

3268 gil_message = "Python print statement"

3269

3270 def generate_execution_code(self, code):

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

3272 arg = self.arg_tuple.args[0]

3273 arg.generate_evaluation_code(code)

3274

3275 code.putln(

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

3277 arg.py_result(),

3278 code.error_goto(self.pos)))

3279 arg.generate_disposal_code(code)

3280 arg.free_temps(code)

3281 else:

3282 self.arg_tuple.generate_evaluation_code(code)

3283 code.putln(

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

3285 self.arg_tuple.py_result(),

3286 self.append_newline,

3287 code.error_goto(self.pos)))

3288 self.arg_tuple.generate_disposal_code(code)

3289 self.arg_tuple.free_temps(code)

3290

3291 def annotate(self, code):

3292 self.arg_tuple.annotate(code)

3293

3294

3295 class ExecStatNode(StatNode):

3296 # exec statement

3297 #

3298 # args [ExprNode]

3299

3300 child_attrs = ["args"]

3301

3302 def analyse_expressions(self, env):

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

3304 arg.analyse_expressions(env)

3305 arg = arg.coerce_to_pyobject(env)

3306 arg.release_temp(env)

3307 self.args[i] = arg

3308 self.temp_result = env.allocate_temp_pyobject()

3309 env.release_temp(self.temp_result)

3310 env.use_utility_code(Builtin.pyexec_utility_code)

3311 self.gil_check(env)

3312

3313 gil_message = "Python exec statement"

3314

3315 def generate_execution_code(self, code):

3316 args = []

3317 for arg in self.args:

3318 arg.generate_evaluation_code(code)

3319 args.append( arg.py_result() )

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

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

3322 (self.temp_result,) + args))

3323 for arg in self.args:

3324 arg.generate_disposal_code(code)

3325 arg.free_temps(code)

3326 code.putln(

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

3328 code.put_gotref(self.temp_result)

3329 code.put_decref_clear(self.temp_result, py_object_type)

3330

3331 def annotate(self, code):

3332 for arg in self.args:

3333 arg.annotate(code)

3334

3335

3336 class DelStatNode(StatNode):

3337 # del statement

3338 #

3339 # args [ExprNode]

3340

3341 child_attrs = ["args"]

3342

3343 def analyse_declarations(self, env):

3344 for arg in self.args:

3345 arg.analyse_target_declaration(env)

3346

3347 def analyse_expressions(self, env):

3348 for arg in self.args:

3349 arg.analyse_target_expression(env, None)

3350 if arg.type.is_pyobject:

3351 self.gil_check(env)

3352 else:

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

3354 #arg.release_target_temp(env)

3355

3356 gil_message = "Deleting Python object"

3357

3358 def generate_execution_code(self, code):

3359 for arg in self.args:

3360 if arg.type.is_pyobject:

3361 arg.generate_deletion_code(code)

3362 # else error reported earlier

3363

3364 def annotate(self, code):

3365 for arg in self.args:

3366 arg.annotate(code)

3367

3368

3369 class PassStatNode(StatNode):

3370 # pass statement

3371

3372 child_attrs = []

3373

3374 def analyse_expressions(self, env):

3375 pass

3376

3377 def generate_execution_code(self, code):

3378 pass

3379

3380

3381 class BreakStatNode(StatNode):

3382

3383 child_attrs = []

3384

3385 def analyse_expressions(self, env):

3386 pass

3387

3388 def generate_execution_code(self, code):

3389 if not code.break_label:

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

3391 else:

3392 code.put_goto(code.break_label)

3393

3394

3395 class ContinueStatNode(StatNode):

3396

3397 child_attrs = []

3398

3399 def analyse_expressions(self, env):

3400 pass

3401

3402 def generate_execution_code(self, code):

3403 if code.funcstate.in_try_finally:

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

3405 elif not code.continue_label:

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

3407 else:

3408 code.put_goto(code.continue_label)

3409

3410

3411 class ReturnStatNode(StatNode):

3412 # return statement

3413 #

3414 # value ExprNode or None

3415 # return_type PyrexType

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

3417

3418 child_attrs = ["value"]

3419

3420 def analyse_expressions(self, env):

3421 return_type = env.return_type

3422 self.return_type = return_type

3423 self.temps_in_use = env.temps_in_use()

3424 if not return_type:

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

3426 return

3427 if self.value:

3428 self.value.analyse_types(env)

3429 if return_type.is_void or return_type.is_returncode:

3430 error(self.value.pos,

3431 "Return with value in void function")

3432 else:

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

3434 self.value.allocate_temps(env)

3435 self.value.release_temp(env)

3436 else:

3437 if (not return_type.is_void

3438 and not return_type.is_pyobject

3439 and not return_type.is_returncode):

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

3441 if return_type.is_pyobject:

3442 self.gil_check(env)

3443

3444 gil_message = "Returning Python object"

3445

3446 def generate_execution_code(self, code):

3447 code.mark_pos(self.pos)

3448 if not self.return_type:

3449 # error reported earlier

3450 return

3451 if self.return_type.is_pyobject:

3452 code.put_xdecref(Naming.retval_cname,

3453 self.return_type)

3454 if self.value:

3455 self.value.generate_evaluation_code(code)

3456 self.value.make_owned_reference(code)

3457 code.putln(

3458 "%s = %s;" % (

3459 Naming.retval_cname,

3460 self.value.result_as(self.return_type)))

3461 self.value.generate_post_assignment_code(code)

3462 self.value.free_temps(code)

3463 else:

3464 if self.return_type.is_pyobject:

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

3466 elif self.return_type.is_returncode:

3467 code.putln(

3468 "%s = %s;" % (

3469 Naming.retval_cname,

3470 self.return_type.default_value))

3471 # free temps the old way

3472 for entry in self.temps_in_use:

3473 code.put_var_decref_clear(entry)

3474 # free temps the new way

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

3476 code.put_decref_clear(cname, type)

3477 #code.putln(

3478 # "goto %s;" %

3479 # code.return_label)

3480 code.put_goto(code.return_label)

3481

3482 def annotate(self, code):

3483 if self.value:

3484 self.value.annotate(code)

3485

3486

3487 class RaiseStatNode(StatNode):

3488 # raise statement

3489 #

3490 # exc_type ExprNode or None

3491 # exc_value ExprNode or None

3492 # exc_tb ExprNode or None

3493

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

3495

3496 def analyse_expressions(self, env):

3497 if self.exc_type:

3498 self.exc_type.analyse_types(env)

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

3500 self.exc_type.allocate_temps(env)

3501 if self.exc_value:

3502 self.exc_value.analyse_types(env)

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

3504 self.exc_value.allocate_temps(env)

3505 if self.exc_tb:

3506 self.exc_tb.analyse_types(env)

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

3508 self.exc_tb.allocate_temps(env)

3509 if self.exc_type:

3510 self.exc_type.release_temp(env)

3511 if self.exc_value:

3512 self.exc_value.release_temp(env)

3513 if self.exc_tb:

3514 self.exc_tb.release_temp(env)

3515 env.use_utility_code(raise_utility_code)

3516 env.use_utility_code(restore_exception_utility_code)

3517 self.gil_check(env)

3518

3519 gil_message = "Raising exception"

3520

3521 def generate_execution_code(self, code):

3522 if self.exc_type:

3523 self.exc_type.generate_evaluation_code(code)

3524 type_code = self.exc_type.py_result()

3525 else:

3526 type_code = "0"

3527 if self.exc_value:

3528 self.exc_value.generate_evaluation_code(code)

3529 value_code = self.exc_value.py_result()

3530 else:

3531 value_code = "0"

3532 if self.exc_tb:

3533 self.exc_tb.generate_evaluation_code(code)

3534 tb_code = self.exc_tb.py_result()

3535 else:

3536 tb_code = "0"

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

3538 code.putln(

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

3540 type_code,

3541 value_code,

3542 tb_code))

3543 else:

3544 code.putln(

3545 "__Pyx_ReRaise();")

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

3547 if obj:

3548 obj.generate_disposal_code(code)

3549 obj.free_temps(code)

3550 code.putln(

3551 code.error_goto(self.pos))

3552

3553 def annotate(self, code):

3554 if self.exc_type:

3555 self.exc_type.annotate(code)

3556 if self.exc_value:

3557 self.exc_value.annotate(code)

3558 if self.exc_tb:

3559 self.exc_tb.annotate(code)

3560

3561

3562 class ReraiseStatNode(StatNode):

3563

3564 child_attrs = []

3565

3566 def analyse_expressions(self, env):

3567 self.gil_check(env)

3568 env.use_utility_code(raise_utility_code)

3569 env.use_utility_code(restore_exception_utility_code)

3570

3571 gil_message = "Raising exception"

3572

3573 def generate_execution_code(self, code):

3574 vars = code.funcstate.exc_vars

3575 if vars:

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

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

3578 else:

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

3580

3581

3582 class AssertStatNode(StatNode):

3583 # assert statement

3584 #

3585 # cond ExprNode

3586 # value ExprNode or None

3587

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

3589

3590 def analyse_expressions(self, env):

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

3592 if self.value:

3593 self.value.analyse_types(env)

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

3595 self.value.allocate_temps(env)

3596 self.cond.release_temp(env)

3597 if self.value:

3598 self.value.release_temp(env)

3599 self.gil_check(env)

3600 #env.recycle_pending_temps() # TEMPORARY

3601

3602 gil_message = "Raising exception"

3603

3604 def generate_execution_code(self, code):

3605 code.putln("#ifndef PYREX_WITHOUT_ASSERTIONS")

3606 self.cond.generate_evaluation_code(code)

3607 code.putln(

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

3609 self.cond.result())

3610 if self.value:

3611 self.value.generate_evaluation_code(code)

3612 code.putln(

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

3614 self.value.py_result())

3615 self.value.generate_disposal_code(code)

3616 self.value.free_temps(code)

3617 else:

3618 code.putln(

3619 "PyErr_SetNone(PyExc_AssertionError);")

3620 code.putln(

3621 code.error_goto(self.pos))

3622 code.putln(

3623 "}")

3624 self.cond.generate_disposal_code(code)

3625 self.cond.free_temps(code)

3626 code.putln("#endif")

3627

3628 def annotate(self, code):

3629 self.cond.annotate(code)

3630 if self.value:

3631 self.value.annotate(code)

3632

3633

3634 class IfStatNode(StatNode):

3635 # if statement

3636 #

3637 # if_clauses [IfClauseNode]

3638 # else_clause StatNode or None

3639

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

3641

3642 def analyse_control_flow(self, env):

3643 env.start_branching(self.pos)

3644 for if_clause in self.if_clauses:

3645 if_clause.analyse_control_flow(env)

3646 env.next_branch(if_clause.end_pos())

3647 if self.else_clause:

3648 self.else_clause.analyse_control_flow(env)

3649 env.finish_branching(self.end_pos())

3650

3651 def analyse_declarations(self, env):

3652 for if_clause in self.if_clauses:

3653 if_clause.analyse_declarations(env)

3654 if self.else_clause:

3655 self.else_clause.analyse_declarations(env)

3656

3657 def analyse_expressions(self, env):

3658 for if_clause in self.if_clauses:

3659 if_clause.analyse_expressions(env)

3660 if self.else_clause:

3661 self.else_clause.analyse_expressions(env)

3662

3663 def generate_execution_code(self, code):

3664 code.mark_pos(self.pos)

3665 end_label = code.new_label()

3666 for if_clause in self.if_clauses:

3667 if_clause.generate_execution_code(code, end_label)

3668 if self.else_clause:

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

3670 self.else_clause.generate_execution_code(code)

3671 code.putln("}")

3672 code.put_label(end_label)

3673

3674 def annotate(self, code):

3675 for if_clause in self.if_clauses:

3676 if_clause.annotate(code)

3677 if self.else_clause:

3678 self.else_clause.annotate(code)

3679

3680

3681 class IfClauseNode(Node):

3682 # if or elif clause in an if statement

3683 #

3684 # condition ExprNode

3685 # body StatNode

3686

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

3688

3689 def analyse_control_flow(self, env):

3690 self.body.analyse_control_flow(env)

3691

3692 def analyse_declarations(self, env):

3693 self.condition.analyse_declarations(env)

3694 self.body.analyse_declarations(env)

3695

3696 def analyse_expressions(self, env):

3697 self.condition = \

3698 self.condition.analyse_temp_boolean_expression(env)

3699 self.condition.release_temp(env)

3700 self.body.analyse_expressions(env)

3701

3702 def generate_execution_code(self, code, end_label):

3703 self.condition.generate_evaluation_code(code)

3704 code.putln(

3705 "if (%s) {" %

3706 self.condition.result())

3707 self.condition.generate_disposal_code(code)

3708 self.condition.free_temps(code)

3709 self.body.generate_execution_code(code)

3710 #code.putln(

3711 # "goto %s;" %

3712 # end_label)

3713 code.put_goto(end_label)

3714 code.putln("}")

3715

3716 def annotate(self, code):

3717 self.condition.annotate(code)

3718 self.body.annotate(code)

3719

3720

3721 class SwitchCaseNode(StatNode):

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

3723 #

3724 # conditions [ExprNode]

3725 # body StatNode

3726

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

3728

3729 def generate_execution_code(self, code):

3730 for cond in self.conditions:

3731 code.mark_pos(cond.pos)

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

3733 self.body.generate_execution_code(code)

3734 code.putln("break;")

3735

3736 def annotate(self, code):

3737 for cond in self.conditions:

3738 cond.annotate(code)

3739 self.body.annotate(code)

3740

3741 class SwitchStatNode(StatNode):

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

3743 #

3744 # test ExprNode

3745 # cases [SwitchCaseNode]

3746 # else_clause StatNode or None

3747

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

3749

3750 def generate_execution_code(self, code):

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

3752 for case in self.cases:

3753 case.generate_execution_code(code)

3754 if self.else_clause is not None:

3755 code.putln("default:")

3756 self.else_clause.generate_execution_code(code)

3757 code.putln("break;")

3758 code.putln("}")

3759

3760 def annotate(self, code):

3761 self.test.annotate(code)

3762 for case in self.cases:

3763 case.annotate(code)

3764 if self.else_clause is not None:

3765 self.else_clause.annotate(code)

3766

3767 class LoopNode(object):

3768

3769 def analyse_control_flow(self, env):

3770 env.start_branching(self.pos)

3771 self.body.analyse_control_flow(env)

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

3773 if self.else_clause:

3774 self.else_clause.analyse_control_flow(env)

3775 env.finish_branching(self.end_pos())

3776

3777

3778 class WhileStatNode(LoopNode, StatNode):

3779 # while statement

3780 #

3781 # condition ExprNode

3782 # body StatNode

3783 # else_clause StatNode

3784

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

3786

3787 def analyse_declarations(self, env):

3788 self.body.analyse_declarations(env)

3789 if self.else_clause:

3790 self.else_clause.analyse_declarations(env)

3791

3792 def analyse_expressions(self, env):

3793 self.condition = \

3794 self.condition.analyse_temp_boolean_expression(env)

3795 self.condition.release_temp(env)

3796 #env.recycle_pending_temps() # TEMPORARY

3797 self.body.analyse_expressions(env)

3798 if self.else_clause:

3799 self.else_clause.analyse_expressions(env)

3800

3801 def generate_execution_code(self, code):

3802 old_loop_labels = code.new_loop_labels()

3803 code.putln(

3804 "while (1) {")

3805 self.condition.generate_evaluation_code(code)

3806 self.condition.generate_disposal_code(code)

3807 code.putln(

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

3809 self.condition.result())

3810 self.condition.free_temps(code)

3811 self.body.generate_execution_code(code)

3812 code.put_label(code.continue_label)

3813 code.putln("}")

3814 break_label = code.break_label

3815 code.set_loop_labels(old_loop_labels)

3816 if self.else_clause:

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

3818 self.else_clause.generate_execution_code(code)

3819 code.putln("}")

3820 code.put_label(break_label)

3821

3822 def annotate(self, code):

3823 self.condition.annotate(code)

3824 self.body.annotate(code)

3825 if self.else_clause:

3826 self.else_clause.annotate(code)

3827

3828

3829 def ForStatNode(pos, **kw):

3830 if 'iterator' in kw:

3831 return ForInStatNode(pos, **kw)

3832 else:

3833 return ForFromStatNode(pos, **kw)

3834

3835 class ForInStatNode(LoopNode, StatNode):

3836 # for statement

3837 #

3838 # target ExprNode

3839 # iterator IteratorNode

3840 # body StatNode

3841 # else_clause StatNode

3842 # item NextNode used internally

3843

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

3845 item = None

3846

3847 def analyse_declarations(self, env):

3848 self.target.analyse_target_declaration(env)

3849 self.body.analyse_declarations(env)

3850 if self.else_clause:

3851 self.else_clause.analyse_declarations(env)

3852

3853 def analyse_expressions(self, env):

3854 import ExprNodes

3855 self.target.analyse_target_types(env)

3856 self.iterator.analyse_expressions(env)

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

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

3859 self.item.allocate_temps(env)

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

3861 #self.item.release_temp(env)

3862 #self.target.release_target_temp(env)

3863 self.body.analyse_expressions(env)

3864 if self.else_clause:

3865 self.else_clause.analyse_expressions(env)

3866 self.iterator.release_temp(env)

3867

3868 def generate_execution_code(self, code):

3869 old_loop_labels = code.new_loop_labels()

3870 self.iterator.allocate_counter_temp(code)

3871 self.iterator.generate_evaluation_code(code)

3872 code.putln(

3873 "for (;;) {")

3874 self.item.generate_evaluation_code(code)

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

3876 self.body.generate_execution_code(code)

3877 code.put_label(code.continue_label)

3878 code.putln(

3879 "}")

3880 break_label = code.break_label

3881 code.set_loop_labels(old_loop_labels)

3882 if self.else_clause:

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

3884 self.else_clause.generate_execution_code(code)

3885 code.putln("}")

3886 code.put_label(break_label)

3887 self.iterator.release_counter_temp(code)

3888 self.iterator.generate_disposal_code(code)

3889 self.iterator.free_temps(code)

3890

3891 def annotate(self, code):

3892 self.target.annotate(code)

3893 self.iterator.annotate(code)

3894 self.body.annotate(code)

3895 if self.else_clause:

3896 self.else_clause.annotate(code)

3897 self.item.annotate(code)

3898

3899

3900 class ForFromStatNode(LoopNode, StatNode):

3901 # for name from expr rel name rel expr

3902 #

3903 # target NameNode

3904 # bound1 ExprNode

3905 # relation1 string

3906 # relation2 string

3907 # bound2 ExprNode

3908 # step ExprNode or None

3909 # body StatNode

3910 # else_clause StatNode or None

3911 #

3912 # Used internally:

3913 #

3914 # from_range bool

3915 # is_py_target bool

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

3917 # py_loopvar_node PyTempNode or None

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

3919

3920 is_py_target = False

3921 loopvar_node = None

3922 py_loopvar_node = None

3923 from_range = False

3924

3925 def analyse_declarations(self, env):

3926 self.target.analyse_target_declaration(env)

3927 self.body.analyse_declarations(env)

3928 if self.else_clause:

3929 self.else_clause.analyse_declarations(env)

3930

3931 def analyse_expressions(self, env):

3932 import ExprNodes

3933 self.target.analyse_target_types(env)

3934 self.bound1.analyse_types(env)

3935 self.bound2.analyse_types(env)

3936 if self.step is not None:

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

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

3939 self.step.analyse_types(env)

3940

3941 target_type = self.target.type

3942 if self.target.type.is_numeric:

3943 loop_type = self.target.type

3944 else:

3945 loop_type = PyrexTypes.c_int_type

3946 if not self.bound1.type.is_pyobject:

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

3948 if not self.bound2.type.is_pyobject:

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

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

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

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

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

3954 if not self.bound2.is_literal:

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

3956 if self.step is not None:

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

3958 if not self.step.is_literal:

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

3960

3961 target_type = self.target.type

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

3963 error(self.target.pos,

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

3965 if target_type.is_numeric:

3966 self.is_py_target = False

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

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

3969 self.loopvar_node = self.target

3970 self.py_loopvar_node = None

3971 else:

3972 self.is_py_target = True