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 need_property = False

798 if (dest_scope.is_c_class_scope

799 and self.visibility == 'public'

800 and base_type.is_pyobject

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

802 # If the field is settable and extension type, then the CPython mechanism does

803 # not do enough type-checking for us.

804 need_property = True

805 elif (base_type.is_typedef and base_type.typedef_is_external

806 and (self.visibility in ('public', 'readonly'))):

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

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

809 # a property; made in AnalyseDeclarationsTransform).

810 need_property = True

811

812 if need_property:

813 visibility = 'private'

814 self.need_properties = []

815 else:

816 visibility = self.visibility

817

818 for declarator in self.declarators:

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

820 if not type.is_complete():

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

822 error(declarator.pos,

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

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

825 error(declarator.pos,

826 "Python object cannot be declared extern")

827 name = name_declarator.name

828 cname = name_declarator.cname

829 if name == '':

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

831 return

832 if type.is_cfunction:

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

834 cname = cname, visibility = self.visibility, in_pxd = self.in_pxd,

835 api = self.api)

836 if entry is not None:

837 entry.directive_locals = self.directive_locals

838 else:

839 if self.directive_locals:

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

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

842 error(self.pos,

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

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

845 cname = cname, visibility = visibility, is_cdef = 1)

846 if need_property:

847 self.need_properties.append(entry)

848 entry.needs_property = 1

849

850

851 class CStructOrUnionDefNode(StatNode):

852 # name string

853 # cname string or None

854 # kind "struct" or "union"

855 # typedef_flag boolean

856 # visibility "public" or "private"

857 # in_pxd boolean

858 # attributes [CVarDefNode] or None

859 # entry Entry

860 # packed boolean

861

862 child_attrs = ["attributes"]

863

864 def analyse_declarations(self, env):

865 scope = None

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

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

868 if self.attributes is not None:

869 scope = StructOrUnionScope(self.name)

870 self.entry = env.declare_struct_or_union(

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

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

873 if self.attributes is not None:

874 if self.in_pxd and not env.in_cinclude:

875 self.entry.defined_in_pxd = 1

876 for attr in self.attributes:

877 attr.analyse_declarations(env, scope)

878 if self.visibility != 'extern':

879 need_typedef_indirection = False

880 for attr in scope.var_entries:

881 type = attr.type

882 while type.is_array:

883 type = type.base_type

884 if type == self.entry.type:

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

886 if self.typedef_flag:

887 while type.is_ptr:

888 type = type.base_type

889 if type == self.entry.type:

890 need_typedef_indirection = True

891 if need_typedef_indirection:

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

893 struct_entry = self.entry

894 cname = env.new_const_cname()

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

896 struct_entry.type.typedef_flag = False

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

898

899 def analyse_expressions(self, env):

900 pass

901

902 def generate_execution_code(self, code):

903 pass

904

905

906 class CEnumDefNode(StatNode):

907 # name string or None

908 # cname string or None

909 # items [CEnumDefItemNode]

910 # typedef_flag boolean

911 # visibility "public" or "private"

912 # in_pxd boolean

913 # entry Entry

914

915 child_attrs = ["items"]

916

917 def analyse_declarations(self, env):

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

919 cname = self.cname, typedef_flag = self.typedef_flag,

920 visibility = self.visibility)

921 if self.items is not None:

922 if self.in_pxd and not env.in_cinclude:

923 self.entry.defined_in_pxd = 1

924 for item in self.items:

925 item.analyse_declarations(env, self.entry)

926

927 def analyse_expressions(self, env):

928 if self.visibility == 'public':

929 self.temp = env.allocate_temp_pyobject()

930 env.release_temp(self.temp)

931

932 def generate_execution_code(self, code):

933 if self.visibility == 'public':

934 for item in self.entry.enum_values:

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

936 self.temp,

937 item.cname,

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

939 code.put_gotref(self.temp)

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

941 Naming.module_cname,

942 item.name,

943 self.temp,

944 code.error_goto(item.pos)))

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

946

947

948 class CEnumDefItemNode(StatNode):

949 # name string

950 # cname string or None

951 # value ExprNode or None

952

953 child_attrs = ["value"]

954

955 def analyse_declarations(self, env, enum_entry):

956 if self.value:

957 self.value.analyse_const_expression(env)

958 if not self.value.type.is_int:

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

960 self.value.analyse_const_expression(env)

961 value = self.value.result()

962 else:

963 value = self.name

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

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

966 enum_entry.enum_values.append(entry)

967

968

969 class CTypeDefNode(StatNode):

970 # base_type CBaseTypeNode

971 # declarator CDeclaratorNode

972 # visibility "public" or "private"

973 # in_pxd boolean

974

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

976

977 def analyse_declarations(self, env):

978 base = self.base_type.analyse(env)

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

980 name = name_declarator.name

981 cname = name_declarator.cname

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

983 cname = cname, visibility = self.visibility)

984 if self.in_pxd and not env.in_cinclude:

985 entry.defined_in_pxd = 1

986

987 def analyse_expressions(self, env):

988 pass

989 def generate_execution_code(self, code):

990 pass

991

992

993 class FuncDefNode(StatNode, BlockNode):

994 # Base class for function definition nodes.

995 #

996 # return_type PyrexType

997 # #filename string C name of filename string const

998 # entry Symtab.Entry

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

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

1001

1002 py_func = None

1003 assmt = None

1004 needs_closure = False

1005

1006 def analyse_default_values(self, env):

1007 genv = env.global_scope()

1008 for arg in self.args:

1009 if arg.default:

1010 if arg.is_generic:

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

1012 arg.default.analyse_types(env)

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

1014 if arg.default.is_literal:

1015 arg.default_entry = arg.default

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

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

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

1019 else:

1020 arg.default.allocate_temps(genv)

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

1022 if arg.type.is_pyobject:

1023 arg.default_entry.init = 0

1024 arg.default_entry.used = 1

1025 arg.default_result_code = arg.default_entry.cname

1026 else:

1027 error(arg.pos,

1028 "This argument cannot have a default value")

1029 arg.default = None

1030

1031 def need_gil_acquisition(self, lenv):

1032 return 0

1033

1034 def create_local_scope(self, env):

1035 genv = env

1036 while env.is_py_class_scope or env.is_c_class_scope:

1037 env = env.outer_scope

1038 if self.needs_closure:

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

1040 else:

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

1042 lenv.return_type = self.return_type

1043 type = self.entry.type

1044 if type.is_cfunction:

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

1046 self.local_scope = lenv

1047 lenv.directives = env.directives

1048 return lenv

1049

1050 def generate_function_definitions(self, env, code):

1051 import Buffer

1052

1053 lenv = self.local_scope

1054

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

1056 self.entry.scope.is_c_class_scope)

1057

1058 # Generate C code for header and body of function

1059 code.enter_cfunc_scope()

1060 code.return_from_error_cleanup_label = code.new_label()

1061

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

1063 code.mark_pos(self.pos)

1064 self.generate_interned_num_decls(lenv, code)

1065 self.generate_interned_string_decls(lenv, code)

1066 self.generate_py_string_decls(lenv, code)

1067 self.generate_cached_builtins_decls(lenv, code)

1068 #code.putln("")

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

1070 self.generate_const_definitions(lenv, code)

1071 # ----- Function header

1072 code.putln("")

1073 if self.py_func:

1074 self.py_func.generate_function_header(code,

1075 with_pymethdef = env.is_py_class_scope,

1076 proto_only=True)

1077 self.generate_function_header(code,

1078 with_pymethdef = env.is_py_class_scope)

1079 # ----- Local variable declarations

1080 lenv.mangle_closure_cnames(Naming.cur_scope_cname)

1081 self.generate_argument_declarations(lenv, code)

1082 if self.needs_closure:

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

1084 code.put_var_declarations(lenv.var_entries)

1085 init = ""

1086 if not self.return_type.is_void:

1087 if self.return_type.is_pyobject:

1088 init = " = NULL"

1089 code.putln(

1090 "%s%s;" %

1091 (self.return_type.declaration_code(

1092 Naming.retval_cname),

1093 init))

1094 tempvardecl_code = code.insertion_point()

1095 self.generate_keyword_list(code)

1096 # ----- Extern library function declarations

1097 lenv.generate_library_function_declarations(code)

1098 # ----- GIL acquisition

1099 acquire_gil = self.need_gil_acquisition(lenv)

1100 if acquire_gil:

1101 env.use_utility_code(force_init_threads_utility_code)

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

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

1104 if not lenv.nogil:

1105 code.put_setup_refcount_context(self.entry.name)

1106 if is_getbuffer_slot:

1107 self.getbuffer_init(code)

1108 # ----- Fetch arguments

1109 self.generate_argument_parsing_code(env, code)

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

1111 # incref it to properly keep track of refcounts.

1112 for entry in lenv.arg_entries:

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

1114 code.put_var_incref(entry)

1115 # ----- Initialise local variables

1116 for entry in lenv.var_entries:

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

1118 code.put_init_var_to_py_none(entry)

1119 # ----- Initialise local buffer auxiliary variables

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

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

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

1123 # ----- Check and convert arguments

1124 self.generate_argument_type_tests(code)

1125 # ----- Acquire buffer arguments

1126 for entry in lenv.arg_entries:

1127 if entry.type.is_buffer:

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

1129 # ----- Function body

1130 self.body.generate_execution_code(code)

1131 # ----- Default return value

1132 code.putln("")

1133 if self.return_type.is_pyobject:

1134 #if self.return_type.is_extension_type:

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

1136 #else:

1137 lhs = Naming.retval_cname

1138 code.put_init_to_py_none(lhs, self.return_type)

1139 else:

1140 val = self.return_type.default_value

1141 if val:

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

1143 # ----- Error cleanup

1144 if code.error_label in code.labels_used:

1145 code.put_goto(code.return_label)

1146 code.put_label(code.error_label)

1147 # cleanup temps the old way

1148 code.put_var_xdecrefs(lenv.temp_entries)

1149 # cleanup temps the new way

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

1151 code.put_xdecref(cname, type)

1152

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

1154 # so need to save and restore error state

1155 buffers_present = len(lenv.buffer_entries) > 0

1156 if buffers_present:

1157 code.globalstate.use_utility_code(restore_exception_utility_code)

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

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

1160 for entry in lenv.buffer_entries:

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

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

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

1164

1165 err_val = self.error_value()

1166 exc_check = self.caller_will_check_exceptions()

1167 if err_val is not None or exc_check:

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

1169 else:

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

1171 % self.entry.qualified_name, 0)

1172 code.putln(

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

1174 self.entry.qualified_name)

1175 env.use_utility_code(unraisable_exception_utility_code)

1176 env.use_utility_code(restore_exception_utility_code)

1177 default_retval = self.return_type.default_value

1178 if err_val is None and default_retval:

1179 err_val = default_retval

1180 if err_val is not None:

1181 code.putln(

1182 "%s = %s;" % (

1183 Naming.retval_cname,

1184 err_val))

1185

1186 if is_getbuffer_slot:

1187 self.getbuffer_error_cleanup(code)

1188

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

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

1191 # whether this section is used.

1192 if buffers_present or is_getbuffer_slot:

1193 code.put_goto(code.return_from_error_cleanup_label)

1194

1195

1196 # ----- Non-error return cleanup

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

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

1199 # block).

1200 code.put_label(code.return_label)

1201 for entry in lenv.buffer_entries:

1202 if entry.used:

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

1204 if is_getbuffer_slot:

1205 self.getbuffer_normal_cleanup(code)

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

1207 code.put_label(code.return_from_error_cleanup_label)

1208 if not Options.init_local_none:

1209 for entry in lenv.var_entries:

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

1211 entry.xdecref_cleanup = 1

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

1213 # Decref any increfed args

1214 for entry in lenv.arg_entries:

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

1216 code.put_var_decref(entry)

1217

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

1219 # ----- Return

1220 # This code is duplicated in ModuleNode.generate_module_init_func

1221 if not lenv.nogil:

1222 default_retval = self.return_type.default_value

1223 err_val = self.error_value()

1224 if err_val is None and default_retval:

1225 err_val = default_retval

1226 if self.return_type.is_pyobject:

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

1228

1229 code.put_finish_refcount_context()

1230

1231 if acquire_gil:

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

1233

1234 if not self.return_type.is_void:

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

1236

1237 code.putln("}")

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

1239 tempvardecl_code.put_var_declarations(lenv.temp_entries)

1240 tempvardecl_code.put_temp_declarations(code.funcstate)

1241 # ----- Python version

1242 code.exit_cfunc_scope()

1243 if self.py_func:

1244 self.py_func.generate_function_definitions(env, code)

1245 self.generate_wrapper_functions(code)

1246

1247 def declare_argument(self, env, arg):

1248 if arg.type.is_void:

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

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

1251 error(arg.pos,

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

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

1254

1255 def generate_wrapper_functions(self, code):

1256 pass

1257

1258 def generate_execution_code(self, code):

1259 # Evaluate and store argument default values

1260 for arg in self.args:

1261 default = arg.default

1262 if default:

1263 if not default.is_literal:

1264 default.generate_evaluation_code(code)

1265 default.make_owned_reference(code)

1266 code.putln(

1267 "%s = %s;" % (

1268 arg.default_entry.cname,

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

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

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

1272 default.free_temps(code)

1273 code.put_var_giveref(arg.default_entry)

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

1275 if self.assmt:

1276 self.assmt.generate_execution_code(code)

1277

1278 #

1279 # Special code for the __getbuffer__ function

1280 #

1281 def getbuffer_init(self, code):

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

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

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

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

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

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

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

1289

1290 def getbuffer_error_cleanup(self, code):

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

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

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

1294 (info, info))

1295

1296 def getbuffer_normal_cleanup(self, code):

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

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

1299 code.put_gotref("Py_None")

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

1301 code.putln("}")

1302

1303 class CFuncDefNode(FuncDefNode):

1304 # C function definition.

1305 #

1306 # modifiers ['inline']

1307 # visibility 'private' or 'public' or 'extern'

1308 # base_type CBaseTypeNode

1309 # declarator CDeclaratorNode

1310 # body StatListNode

1311 # api boolean

1312 # decorators [DecoratorNode] list of decorators

1313 #

1314 # with_gil boolean Acquire GIL around body

1315 # type CFuncType

1316 # py_func wrapper for calling from Python

1317 # overridable whether or not this is a cpdef function

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

1319

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

1321

1322 inline_in_pxd = False

1323 decorators = None

1324 directive_locals = {}

1325

1326 def unqualified_name(self):

1327 return self.entry.name

1328

1329 def analyse_declarations(self, env):

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

1331 base_type = self.base_type.analyse(env)

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

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

1334 if not type.is_cfunction:

1335 error(self.pos,

1336 "Suite attached to non-function declaration")

1337 # Remember the actual type according to the function header

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

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

1340 # from the base type of an extension type.

1341 self.type = type

1342 type.is_overridable = self.overridable

1343 declarator = self.declarator

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

1345 declarator = declarator.base

1346 self.args = declarator.args

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

1348 formal_arg.type = type_arg.type

1349 formal_arg.name = type_arg.name

1350 formal_arg.cname = type_arg.cname

1351 name = name_declarator.name

1352 cname = name_declarator.cname

1353 self.entry = env.declare_cfunction(

1354 name, type, self.pos,

1355 cname = cname, visibility = self.visibility,

1356 defining = self.body is not None,

1357 api = self.api, modifiers = self.modifiers)

1358 self.entry.inline_func_in_pxd = self.inline_in_pxd

1359 self.return_type = type.return_type

1360

1361 if self.overridable and not env.is_module_scope:

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

1363 # An error will be produced in the cdef function

1364 self.overridable = False

1365

1366 if self.overridable:

1367 import ExprNodes

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

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

1370 name = self.entry.name,

1371 args = self.args,

1372 star_arg = None,

1373 starstar_arg = None,

1374 doc = self.doc,

1375 body = py_func_body,

1376 is_wrapper = 1)

1377 self.py_func.is_module_scope = env.is_module_scope

1378 self.py_func.analyse_declarations(env)

1379 self.entry.as_variable = self.py_func.entry

1380 # Reset scope entry the above cfunction

1381 env.entries[name] = self.entry

1382 self.py_func.interned_attr_cname = env.intern_identifier(

1383 self.py_func.entry.name)

1384 if not env.is_module_scope or Options.lookup_module_cpdef:

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

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

1387

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

1389 import ExprNodes

1390 args = self.type.args

1391 if omit_optional_args:

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

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

1394 if is_module_scope:

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

1396 else:

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

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

1399 skip_dispatch = not is_module_scope or Options.lookup_module_cpdef

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

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

1402

1403 def declare_arguments(self, env):

1404 for arg in self.type.args:

1405 if not arg.name:

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

1407 self.declare_argument(env, arg)

1408

1409 def need_gil_acquisition(self, lenv):

1410 type = self.type

1411 with_gil = self.type.with_gil

1412 if type.nogil and not with_gil:

1413 if type.return_type.is_pyobject:

1414 error(self.pos,

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

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

1417 if entry.type.is_pyobject:

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

1419 return with_gil

1420

1421 def analyse_expressions(self, env):

1422 self.local_scope.directives = env.directives

1423 self.analyse_default_values(env)

1424 if self.py_func is not None:

1425 self.py_func.analyse_expressions(env)

1426

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

1428 arg_decls = []

1429 type = self.type

1430 visibility = self.entry.visibility

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

1432 arg_decls.append(arg.declaration_code())

1433 if with_dispatch and self.overridable:

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

1435 if type.optional_arg_count and with_opt_args:

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

1437 if type.has_varargs:

1438 arg_decls.append("...")

1439 if not arg_decls:

1440 arg_decls = ["void"]

1441 if cname is None:

1442 cname = self.entry.func_cname

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

1444 if visibility == 'public':

1445 dll_linkage = "DL_EXPORT"

1446 else:

1447 dll_linkage = None

1448 header = self.return_type.declaration_code(entity,

1449 dll_linkage = dll_linkage)

1450 if visibility == 'extern':

1451 storage_class = "%s " % Naming.extern_c_macro

1452 elif visibility == 'public':

1453 storage_class = ""

1454 else:

1455 storage_class = "static "

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

1457 storage_class,

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

1459 header))

1460

1461 def generate_argument_declarations(self, env, code):

1462 for arg in self.args:

1463 if arg.default:

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

1465

1466 def generate_keyword_list(self, code):

1467 pass

1468

1469 def generate_argument_parsing_code(self, env, code):

1470 i = 0

1471 if self.type.optional_arg_count:

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

1473 for arg in self.args:

1474 if arg.default:

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

1476 # argument name mangling is in place

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

1478 declarator = arg.declarator

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

1480 declarator = declarator.base

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

1482 i += 1

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

1484 code.putln('}')

1485 code.putln('}')

1486

1487 def generate_argument_conversion_code(self, code):

1488 pass

1489

1490 def generate_argument_type_tests(self, code):

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

1492 # class is a supertype of the declared type.

1493 for arg in self.type.args:

1494 if arg.needs_type_test:

1495 self.generate_arg_type_test(arg, code)

1496

1497 def generate_arg_type_test(self, arg, code):

1498 # Generate type test for one argument.

1499 if arg.type.typeobj_is_available():

1500 typeptr_cname = arg.type.typeptr_cname

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

1502 code.putln(

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

1504 arg_code,

1505 typeptr_cname,

1506 not arg.not_none,

1507 arg.name,

1508 type.is_builtin_type,

1509 code.error_goto(arg.pos)))

1510 else:

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

1512 "without type object name specification")

1513

1514 def error_value(self):

1515 if self.return_type.is_pyobject:

1516 return "0"

1517 else:

1518 #return None

1519 return self.entry.type.exception_value

1520

1521 def caller_will_check_exceptions(self):

1522 return self.entry.type.exception_check

1523

1524 def generate_wrapper_functions(self, code):

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

1526 # wrappers to put in the slots here.

1527 k = 0

1528 entry = self.entry

1529 func_type = entry.type

1530 while entry.prev_entry is not None:

1531 k += 1

1532 entry = entry.prev_entry

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

1534 code.putln()

1535 self.generate_function_header(code,

1536 0,

1537 with_dispatch = entry.type.is_overridable,

1538 with_opt_args = entry.type.optional_arg_count,

1539 cname = entry.func_cname)

1540 if not self.return_type.is_void:

1541 code.put('return ')

1542 args = self.type.args

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

1544 if entry.type.is_overridable:

1545 arglist.append(Naming.skip_dispatch_cname)

1546 elif func_type.is_overridable:

1547 arglist.append('0')

1548 if entry.type.optional_arg_count:

1549 arglist.append(Naming.optional_args_cname)

1550 elif func_type.optional_arg_count:

1551 arglist.append('NULL')

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

1553 code.putln('}')

1554

1555

1556 class PyArgDeclNode(Node):

1557 # Argument which must be a Python object (used

1558 # for * and ** arguments).

1559 #

1560 # name string

1561 # entry Symtab.Entry

1562 child_attrs = []

1563

1564

1565 class DecoratorNode(Node):

1566 # A decorator

1567 #

1568 # decorator NameNode or CallNode

1569 child_attrs = ['decorator']

1570

1571

1572 class DefNode(FuncDefNode):

1573 # A Python function definition.

1574 #

1575 # name string the Python name of the function

1576 # decorators [DecoratorNode] list of decorators

1577 # args [CArgDeclNode] formal arguments

1578 # star_arg PyArgDeclNode or None * argument

1579 # starstar_arg PyArgDeclNode or None ** argument

1580 # doc EncodedString or None

1581 # body StatListNode

1582 #

1583 # The following subnode is constructed internally

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

1585 #

1586 # assmt AssignmentNode Function construction/assignment

1587

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

1589

1590 assmt = None

1591 num_kwonly_args = 0

1592 num_required_kw_args = 0

1593 reqd_kw_flags_cname = "0"

1594 is_wrapper = 0

1595 decorators = None

1596 entry = None

1597

1598

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

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

1601 k = rk = r = 0

1602 for arg in self.args:

1603 if arg.kw_only:

1604 k += 1

1605 if not arg.default:

1606 rk += 1

1607 if not arg.default:

1608 r += 1

1609 self.num_kwonly_args = k

1610 self.num_required_kw_args = rk

1611 self.num_required_args = r

1612

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

1614 if self.star_arg:

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

1616 if self.starstar_arg:

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

1618 if cfunc is None:

1619 cfunc_args = []

1620 for formal_arg in self.args:

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

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

1623 cname = None,

1624 type = py_object_type,

1625 pos = formal_arg.pos))

1626 cfunc_type = PyrexTypes.CFuncType(return_type = py_object_type,

1627 args = cfunc_args,

1628 has_varargs = False,

1629 exception_value = None,

1630 exception_check = False,

1631 nogil = False,

1632 with_gil = False,

1633 is_overridable = True)

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

1635 else:

1636 cfunc_type = cfunc.type

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

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

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

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

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

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

1643 formal_arg.type = type_arg.type

1644 formal_arg.name_declarator = name_declarator

1645 import ExprNodes

1646 if cfunc_type.exception_value is None:

1647 exception_value = None

1648 else:

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

1650 declarator = CFuncDeclaratorNode(self.pos,

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

1652 args = self.args,

1653 has_varargs = False,

1654 exception_check = cfunc_type.exception_check,

1655 exception_value = exception_value,

1656 with_gil = cfunc_type.with_gil,

1657 nogil = cfunc_type.nogil)

1658 return CFuncDefNode(self.pos,

1659 modifiers = [],

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

1661 declarator = declarator,

1662 body = self.body,

1663 doc = self.doc,

1664 overridable = cfunc_type.is_overridable,

1665 type = cfunc_type,

1666 with_gil = cfunc_type.with_gil,

1667 nogil = cfunc_type.nogil,

1668 visibility = 'private',

1669 api = False,

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

1671

1672 def analyse_declarations(self, env):

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

1674 for arg in self.args:

1675 if hasattr(arg, 'name'):

1676 type = arg.type

1677 name_declarator = None

1678 else:

1679 base_type = arg.base_type.analyse(env)

1680 name_declarator, type = \

1681 arg.declarator.analyse(base_type, env)

1682 arg.name = name_declarator.name

1683 if arg.name in directive_locals:

1684 type_node = directive_locals[arg.name]

1685 other_type = type_node.analyse_as_type(env)

1686 if other_type is None:

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

1688 elif (type is not PyrexTypes.py_object_type

1689 and not type.same_as(other_type)):

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

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

1692 else:

1693 type = other_type

1694 if name_declarator and name_declarator.cname:

1695 error(self.pos,

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

1697 arg.type = type.as_argument_type()

1698 arg.hdr_type = None

1699 arg.needs_conversion = 0

1700 arg.needs_type_test = 0

1701 arg.is_generic = 1

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

1703 error(self.pos,

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

1705 self.declare_pyfunction(env)

1706 self.analyse_signature(env)

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

1708

1709 def analyse_signature(self, env):

1710 any_type_tests_needed = 0

1711 if self.entry.is_special:

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

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

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

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

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

1717 self.entry.signature = TypeSlots.pyfunction_noargs

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

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

1720 self.entry.signature = TypeSlots.pyfunction_onearg

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

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

1723 self.entry.signature = TypeSlots.unaryfunc

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

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

1726 self.entry.signature = TypeSlots.ibinaryfunc

1727 sig = self.entry.signature

1728 nfixed = sig.num_fixed_args()

1729 for i in range(nfixed):

1730 if i < len(self.args):

1731 arg = self.args[i]

1732 arg.is_generic = 0

1733 if sig.is_self_arg(i):

1734 arg.is_self_arg = 1

1735 arg.hdr_type = arg.type = env.parent_type

1736 arg.needs_conversion = 0

1737 else:

1738 arg.hdr_type = sig.fixed_arg_type(i)

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

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

1741 arg.needs_type_test = 1

1742 any_type_tests_needed = 1

1743 else:

1744 arg.needs_conversion = 1

1745 if arg.needs_conversion:

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

1747 else:

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

1749 else:

1750 self.bad_signature()

1751 return

1752 if nfixed < len(self.args):

1753 if not sig.has_generic_args:

1754 self.bad_signature()

1755 for arg in self.args:

1756 if arg.is_generic and \

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

1758 arg.needs_type_test = 1

1759 any_type_tests_needed = 1

1760 if any_type_tests_needed:

1761 env.use_utility_code(arg_type_test_utility_code)

1762

1763 def bad_signature(self):

1764 sig = self.entry.signature

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

1766 if sig.has_generic_args:

1767 expected_str = expected_str + " or more"

1768 name = self.name

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

1770 desc = "Special method"

1771 else:

1772 desc = "Method"

1773 error(self.pos,

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

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

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

1777

1778 def signature_has_nongeneric_args(self):

1779 argcount = len(self.args)

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

1781 return 0

1782 return 1

1783

1784 def signature_has_generic_args(self):

1785 return self.entry.signature.has_generic_args

1786

1787 def declare_pyfunction(self, env):

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

1789 name = self.name

1790 entry = env.lookup_here(self.name)

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

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

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

1794 self.entry = entry

1795 prefix = env.scope_prefix

1796 entry.func_cname = \

1797 Naming.pyfunc_prefix + prefix + name

1798 entry.pymethdef_cname = \

1799 Naming.pymethdef_prefix + prefix + name

1800 if Options.docstrings:

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

1802 entry.doc_cname = \

1803 Naming.funcdoc_prefix + prefix + name

1804 else:

1805 entry.doc = None

1806

1807 def declare_arguments(self, env):

1808 for arg in self.args:

1809 if not arg.name:

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

1811 if arg.needs_conversion:

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

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

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

1815 if arg.type.is_pyobject:

1816 arg.entry.init = "0"

1817 arg.entry.init_to_none = 0

1818 else:

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

1820 arg.entry.used = 1

1821 arg.entry.is_self_arg = arg.is_self_arg

1822 if not arg.is_self_arg:

1823 arg.name_entry = env.get_string_const(

1824 arg.name, identifier = True)

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

1826 if arg.hdr_type:

1827 if arg.is_self_arg or \

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

1829 arg.entry.is_declared_generic = 1

1830 self.declare_python_arg(env, self.star_arg)

1831 self.declare_python_arg(env, self.starstar_arg)

1832

1833 def declare_python_arg(self, env, arg):

1834 if arg:

1835 entry = env.declare_var(arg.name,

1836 PyrexTypes.py_object_type, arg.pos)

1837 entry.used = 1

1838 entry.init = "0"

1839 entry.init_to_none = 0

1840 entry.xdecref_cleanup = 1

1841 arg.entry = entry

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

1843

1844 def analyse_expressions(self, env):

1845 self.local_scope.directives = env.directives

1846 self.analyse_default_values(env)

1847 if env.is_py_class_scope:

1848 self.synthesize_assignment_node(env)

1849

1850 def synthesize_assignment_node(self, env):

1851 import ExprNodes

1852 self.assmt = SingleAssignmentNode(self.pos,

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

1854 rhs = ExprNodes.UnboundMethodNode(self.pos,

1855 class_cname = env.class_obj_cname,

1856 function = ExprNodes.PyCFunctionNode(self.pos,

1857 pymethdef_cname = self.entry.pymethdef_cname)))

1858 self.assmt.analyse_declarations(env)

1859 self.assmt.analyse_expressions(env)

1860

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

1862 arg_code_list = []

1863 sig = self.entry.signature

1864 if sig.has_dummy_arg:

1865 arg_code_list.append(

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

1867 for arg in self.args:

1868 if not arg.is_generic:

1869 if arg.is_self_arg:

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

1871 else:

1872 arg_code_list.append(

1873 arg.hdr_type.declaration_code(arg.hdr_cname))

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

1875 arg_code_list.append("PyObject *unused")

1876 if sig.has_generic_args:

1877 arg_code_list.append(

1878 "PyObject *%s, PyObject *%s"

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

1880 arg_code = ", ".join(arg_code_list)

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

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

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

1884 if proto_only:

1885 return

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

1887 docstr = self.entry.doc

1888 if not isinstance(docstr, str):

1889 docstr = docstr.utf8encode()

1890 code.putln(

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

1892 self.entry.doc_cname,

1893 split_docstring(escape_byte_string(docstr))))

1894 if with_pymethdef:

1895 code.put(

1896 "static PyMethodDef %s = " %

1897 self.entry.pymethdef_cname)

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

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

1900

1901 def generate_argument_declarations(self, env, code):

1902 for arg in self.args:

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

1904 if arg.needs_conversion:

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

1906 else:

1907 code.put_var_declaration(arg.entry)

1908

1909 def generate_keyword_list(self, code):

1910 if self.signature_has_generic_args() and \

1911 self.signature_has_nongeneric_args():

1912 code.put(

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

1914 Naming.pykwdlist_cname)

1915 for arg in self.args:

1916 if arg.is_generic:

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

1918 code.putln("0};")

1919

1920 def generate_argument_parsing_code(self, env, code):

1921 # Generate PyArg_ParseTuple call for generic

1922 # arguments, if any.

1923 if self.entry.signature.has_dummy_arg:

1924 # get rid of unused argument warning

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

1926

1927 old_error_label = code.new_error_label()

1928 our_error_label = code.error_label

1929 end_label = code.new_label("argument_unpacking_done")

1930

1931 has_kwonly_args = self.num_kwonly_args > 0

1932 has_star_or_kw_args = self.star_arg is not None \

1933 or self.starstar_arg is not None or has_kwonly_args

1934

1935 for arg in self.args:

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

1937 arg.type.create_from_py_utility_code(env)

1938

1939 if not self.signature_has_generic_args():

1940 if has_star_or_kw_args:

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

1942 self.generate_argument_conversion_code(code)

1943

1944 elif not self.signature_has_nongeneric_args():

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

1946 self.generate_stararg_copy_code(code)

1947

1948 else:

1949 positional_args = []

1950 kw_only_args = []

1951 default_seen = 0

1952 for arg in self.args:

1953 arg_entry = arg.entry

1954 if arg.is_generic:

1955 if arg.default:

1956 default_seen = 1

1957 if not arg.is_self_arg:

1958 if arg.kw_only:

1959 kw_only_args.append(arg)

1960 else:

1961 positional_args.append(arg)

1962 elif arg.kw_only:

1963 kw_only_args.append(arg)

1964 default_seen = 1

1965 elif default_seen:

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

1967 elif not arg.is_self_arg:

1968 positional_args.append(arg)

1969

1970 self.generate_tuple_and_keyword_parsing_code(

1971 positional_args, kw_only_args, end_label, code)

1972

1973 code.error_label = old_error_label

1974 if code.label_used(our_error_label):

1975 if not code.label_used(end_label):

1976 code.put_goto(end_label)

1977 code.put_label(our_error_label)

1978 if has_star_or_kw_args:

1979 self.generate_arg_decref(self.star_arg, code)

1980 if self.starstar_arg:

1981 if self.starstar_arg.entry.xdecref_cleanup:

1982 code.put_var_xdecref(self.starstar_arg.entry)

1983 else:

1984 code.put_var_decref(self.starstar_arg.entry)

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

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

1987 if code.label_used(end_label):

1988 code.put_label(end_label)

1989

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

1991 if arg.type.is_pyobject:

1992 if arg.is_generic:

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

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

1995 else:

1996 func = arg.type.from_py_function

1997 if func:

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

1999 arg.entry.cname,

2000 func,

2001 item,

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

2003 else:

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

2005

2006 def generate_arg_xdecref(self, arg, code):

2007 if arg:

2008 code.put_var_xdecref(arg.entry)

2009

2010 def generate_arg_decref(self, arg, code):

2011 if arg:

2012 code.put_var_decref(arg.entry)

2013

2014 def generate_stararg_copy_code(self, code):

2015 if not self.star_arg:

2016 code.globalstate.use_utility_code(raise_argtuple_invalid_utility_code)

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

2018 Naming.args_cname)

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

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

2021 code.putln("}")

2022

2023 code.globalstate.use_utility_code(keyword_string_check_utility_code)

2024

2025 if self.starstar_arg:

2026 if self.star_arg:

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

2028 else:

2029 kwarg_check = "%s" % Naming.kwds_cname

2030 else:

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

2032 Naming.kwds_cname, Naming.kwds_cname)

2033 code.putln(

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

2035 kwarg_check, Naming.kwds_cname, self.name,

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

2037

2038 if self.starstar_arg:

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

2040 self.starstar_arg.entry.cname,

2041 Naming.kwds_cname,

2042 Naming.kwds_cname))

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

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

2045 self.starstar_arg.entry.xdecref_cleanup = 0

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

2047

2048

2049 if self.star_arg:

2050 code.put_incref(Naming.args_cname, py_object_type)

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

2052 self.star_arg.entry.cname,

2053 Naming.args_cname))

2054 self.star_arg.entry.xdecref_cleanup = 0

2055

2056 def generate_tuple_and_keyword_parsing_code(self, positional_args,

2057 kw_only_args, success_label, code):

2058 argtuple_error_label = code.new_label("argtuple_error")

2059

2060 min_positional_args = self.num_required_args - self.num_required_kw_args

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

2062 min_positional_args -= 1

2063 max_positional_args = len(positional_args)

2064 has_fixed_positional_count = not self.star_arg and \

2065 min_positional_args == max_positional_args

2066

2067 code.globalstate.use_utility_code(raise_double_keywords_utility_code)

2068 code.globalstate.use_utility_code(raise_argtuple_invalid_utility_code)

2069 if self.num_required_kw_args:

2070 code.globalstate.use_utility_code(raise_keyword_required_utility_code)

2071

2072 if self.starstar_arg or self.star_arg:

2073 self.generate_stararg_init_code(max_positional_args, code)

2074

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

2076 if self.num_required_kw_args:

2077 likely_hint = "likely"

2078 else:

2079 likely_hint = "unlikely"

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

2081 self.generate_keyword_unpacking_code(

2082 min_positional_args, max_positional_args,

2083 has_fixed_positional_count,

2084 positional_args, kw_only_args, argtuple_error_label, code)

2085

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

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

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

2089 # check the length here

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

2091 compare = '!='

2092 else:

2093 compare = '<'

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

2095 Naming.args_cname, compare, min_positional_args))

2096 code.put_goto(argtuple_error_label)

2097

2098 if self.num_required_kw_args:

2099 # pure error case: keywords required but not passed

2100 if max_positional_args > min_positional_args and not self.star_arg:

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

2102 Naming.args_cname, max_positional_args))

2103 code.put_goto(argtuple_error_label)

2104 code.putln('} else {')

2105 for i, arg in enumerate(kw_only_args):

2106 if not arg.default:

2107 # required keyword-only argument missing

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

2109 self.name.utf8encode(),

2110 arg.name_entry.pystring_cname))

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

2112 break

2113

2114 elif min_positional_args == max_positional_args:

2115 # parse the exact number of positional arguments from the

2116 # args tuple

2117 code.putln('} else {')

2118 for i, arg in enumerate(positional_args):

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

2120 self.generate_arg_assignment(arg, item, code)

2121 self.generate_arg_default_assignments(code)

2122

2123 else:

2124 # parse the positional arguments from the variable length

2125 # args tuple

2126 code.putln('} else {')

2127 self.generate_arg_default_assignments(code)

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

2129 if self.star_arg:

2130 code.putln('default:')

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

2132 for i, arg in reversed_args:

2133 if i >= min_positional_args-1:

2134 if min_positional_args > 1:

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

2136 else:

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

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

2139 self.generate_arg_assignment(arg, item, code)

2140 if min_positional_args == 0:

2141 code.put('case 0: ')

2142 code.putln('break;')

2143 if self.star_arg:

2144 if min_positional_args:

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

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

2147 code.put_goto(argtuple_error_label)

2148 else:

2149 code.put('default: ')

2150 code.put_goto(argtuple_error_label)

2151 code.putln('}')

2152

2153 code.putln('}')

2154

2155 if code.label_used(argtuple_error_label):

2156 code.put_goto(success_label)

2157 code.put_label(argtuple_error_label)

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

2159 self.name.utf8encode(), has_fixed_positional_count,

2160 min_positional_args, max_positional_args,

2161 Naming.args_cname))

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

2163

2164 def generate_arg_default_assignments(self, code):

2165 for arg in self.args:

2166 if arg.is_generic and arg.default:

2167 code.putln(

2168 "%s = %s;" % (

2169 arg.entry.cname,

2170 arg.default_result_code))

2171

2172 def generate_stararg_init_code(self, max_positional_args, code):

2173 if self.starstar_arg:

2174 self.starstar_arg.entry.xdecref_cleanup = 0

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

2176 self.starstar_arg.entry.cname,

2177 self.starstar_arg.entry.cname,

2178 self.error_value()))

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

2180 if self.star_arg:

2181 self.star_arg.entry.xdecref_cleanup = 0

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

2183 Naming.args_cname,

2184 max_positional_args))

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

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

2187 max_positional_args, Naming.args_cname))

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

2189 if self.starstar_arg:

2190 code.putln("")

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

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

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

2194 code.putln('}')

2195 else:

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

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

2198 code.putln('} else {')

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

2200 code.put_incref(Naming.empty_tuple, py_object_type)

2201 code.putln('}')

2202

2203 def generate_keyword_unpacking_code(self, min_positional_args, max_positional_args,

2204 has_fixed_positional_count, positional_args,

2205 kw_only_args, argtuple_error_label, code):

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

2207 max_args = len(all_args)

2208

2209 default_args = []

2210 for i, arg in enumerate(all_args):

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

2212 default_value = arg.default_result_code

2213 if arg.type is not PyrexTypes.py_object_type:

2214 default_value = "(PyObject*)"+default_value

2215 default_args.append((i, default_value))

2216

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

2218 Naming.kwds_cname)

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

2220 # default value, but C89 needs this

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

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

2223 for i, default_value in default_args:

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

2225

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

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

2228 if self.star_arg:

2229 code.putln('default:')

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

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

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

2233 i, Naming.args_cname, i))

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

2235 if not self.star_arg:

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

2237 code.put_goto(argtuple_error_label)

2238 code.putln('}')

2239

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

2241 # from the kw dict

2242 if self.num_required_args or max_positional_args > 0:

2243 last_required_arg = -1

2244 for i, arg in enumerate(all_args):

2245 if not arg.default:

2246 last_required_arg = i

2247 if last_required_arg < max_positional_args:

2248 last_required_arg = max_positional_args-1

2249 num_required_args = self.num_required_args

2250 if max_positional_args > 0:

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

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

2253 if max_positional_args > 0 and i <= max_positional_args:

2254 if self.star_arg and i == max_positional_args:

2255 code.putln('default:')

2256 else:

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

2258 if arg.default:

2259 if arg.kw_only:

2260 # handled separately below

2261 continue

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

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

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

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

2266 code.putln('}')

2267 else:

2268 num_required_args -= 1

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

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

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

2272 if i < min_positional_args:

2273 if i == 0:

2274 # special case: we know arg 0 is missing

2275 code.put('else ')

2276 code.put_goto(argtuple_error_label)

2277 else:

2278 # print the correct number of values (args or

2279 # kwargs) that were passed into positional

2280 # arguments up to this point

2281 code.putln('else {')

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

2283 self.name.utf8encode(), has_fixed_positional_count,

2284 min_positional_args, max_positional_args, i))

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

2286 code.putln('}')

2287 elif arg.kw_only:

2288 code.putln('else {')

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

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

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

2292 code.putln('}')

2293 if max_positional_args > 0:

2294 code.putln('}')

2295

2296 if kw_only_args and not self.starstar_arg:

2297 # unpack optional keyword-only arguments

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

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

2300 optional_args = []

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

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

2303 continue

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

2305 if optional_args:

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

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

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

2309 for i, arg in optional_args:

2310 code.putln(

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

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

2313 code.putln(

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

2315 code.putln('break;')

2316 code.putln('}')

2317

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

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

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

2321 #

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

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

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

2325 # common cases above.

2326 if max_positional_args == 0:

2327 pos_arg_count = "0"

2328 elif self.star_arg:

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

2330 Naming.args_cname, max_positional_args,

2331 Naming.args_cname, max_positional_args))

2332 pos_arg_count = "used_pos_args"

2333 else:

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

2335 code.globalstate.use_utility_code(parse_keywords_utility_code)

2336 code.put(

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

2338 Naming.kwds_cname,

2339 Naming.pykwdlist_cname,

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

2341 pos_arg_count,

2342 self.name.utf8encode()))

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

2344 code.putln('}')

2345

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

2347 for i, arg in enumerate(all_args):

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

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

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

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

2352 code.putln('} else {')

2353 code.putln(

2354 "%s = %s;" % (

2355 arg.entry.cname,

2356 arg.default_result_code))

2357 code.putln('}')

2358

2359 def generate_argument_conversion_code(self, code):

2360 # Generate code to convert arguments from

2361 # signature type to declared type, if needed.

2362 for arg in self.args:

2363 if arg.needs_conversion:

2364 self.generate_arg_conversion(arg, code)

2365

2366 def generate_arg_conversion(self, arg, code):

2367 # Generate conversion code for one argument.

2368 old_type = arg.hdr_type

2369 new_type = arg.type

2370 if old_type.is_pyobject:

2371 if arg.default:

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

2373 else:

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

2375 self.generate_arg_conversion_from_pyobject(arg, code)

2376 code.putln("}")

2377 elif new_type.is_pyobject:

2378 self.generate_arg_conversion_to_pyobject(arg, code)

2379 else:

2380 if new_type.assignable_from(old_type):

2381 code.putln(

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

2383 else:

2384 error(arg.pos,

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

2386 (old_type, new_type))

2387

2388 def generate_arg_conversion_from_pyobject(self, arg, code):

2389 new_type = arg.type

2390 func = new_type.from_py_function

2391 # copied from CoerceFromPyTypeNode

2392 if func:

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

2394 arg.entry.cname,

2395 func,

2396 arg.hdr_cname,

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

2398 else:

2399 error(arg.pos,

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

2401 % new_type)

2402

2403 def generate_arg_conversion_to_pyobject(self, arg, code):

2404 old_type = arg.hdr_type

2405 func = old_type.to_py_function

2406 if func:

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

2408 arg.entry.cname,

2409 func,

2410 arg.hdr_cname,

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

2412 code.put_var_gotref(arg.entry)

2413 else:

2414 error(arg.pos,

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

2416 % old_type)

2417

2418 def generate_argument_type_tests(self, code):

2419 # Generate type tests for args whose signature

2420 # type is PyObject * and whose declared type is

2421 # a subtype thereof.

2422 for arg in self.args:

2423 if arg.needs_type_test:

2424 self.generate_arg_type_test(arg, code)

2425

2426 def generate_arg_type_test(self, arg, code):

2427 # Generate type test for one argument.

2428 if arg.type.typeobj_is_available():

2429 typeptr_cname = arg.type.typeptr_cname

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

2431 code.putln(

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

2433 arg_code,

2434 typeptr_cname,

2435 not arg.not_none,

2436 arg.name,

2437 arg.type.is_builtin_type,

2438 code.error_goto(arg.pos)))

2439 else:

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

2441 "without type object name specification")

2442

2443 def error_value(self):

2444 return self.entry.signature.error_value

2445

2446 def caller_will_check_exceptions(self):

2447 return 1

2448

2449 class OverrideCheckNode(StatNode):

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

2451 # is overriden.

2452 #

2453 # py_func

2454 #

2455 # args

2456 # func_temp

2457 # body

2458

2459 child_attrs = ['body']

2460

2461 body = None

2462

2463 def analyse_expressions(self, env):

2464 self.args = env.arg_entries

2465 if self.py_func.is_module_scope:

2466 first_arg = 0

2467 else:

2468 first_arg = 1

2469 import ExprNodes

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

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

2472 call_node = ExprNodes.SimpleCallNode(self.pos,

2473 function=self.func_node,

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

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

2476 self.body.analyse_expressions(env)

2477

2478 def generate_execution_code(self, code):

2479 # Check to see if we are an extension type

2480 if self.py_func.is_module_scope:

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

2482 else:

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

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

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

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

2487 if self.py_func.is_module_scope:

2488 code.putln("else {")

2489 else:

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

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

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

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

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

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

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

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

2498 self.body.generate_execution_code(code)

2499 code.putln('}')

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

2501 code.putln("}")

2502

2503 class ClassDefNode(StatNode, BlockNode):

2504 pass

2505

2506 class PyClassDefNode(ClassDefNode):

2507 # A Python class definition.

2508 #

2509 # name EncodedString Name of the class

2510 # doc string or None

2511 # body StatNode Attribute definition code

2512 # entry Symtab.Entry

2513 # scope PyClassScope

2514 #

2515 # The following subnodes are constructed internally:

2516 #

2517 # dict DictNode Class dictionary

2518 # classobj ClassNode Class object

2519 # target NameNode Variable to assign class object to

2520

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

2522

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

2524 StatNode.__init__(self, pos)

2525 self.name = name

2526 self.doc = doc

2527 self.body = body

2528 import ExprNodes

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

2530 if self.doc and Options.docstrings:

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

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

2533 else:

2534 doc_node = None

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

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

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

2538

2539 def as_cclass(self):

2540 """

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

2542 """

2543 bases = self.classobj.bases.args

2544 if len(bases) == 0:

2545 base_class_name = None

2546 base_class_module = None

2547 elif len(bases) == 1:

2548 base = bases[0]

2549 path = []

2550 from ExprNodes import AttributeNode, NameNode

2551 while isinstance(base, AttributeNode):

2552 path.insert(0, base.attribute)

2553 base = base.obj

2554 if isinstance(base, NameNode):

2555 path.insert(0, base.name)

2556 base_class_name = path[-1]

2557 if len(path) > 1:

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

2559 else:

2560 base_class_module = None

2561 else:

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

2563 else:

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

2565 return None

2566

2567 return CClassDefNode(self.pos,

2568 visibility = 'private',

2569 module_name = None,

2570 class_name = self.name,

2571 base_class_module = base_class_module,

2572 base_class_name = base_class_name,

2573 body = self.body,

2574 in_pxd = False,

2575 doc = self.doc)

2576

2577 def create_scope(self, env):

2578 genv = env

2579 while env.is_py_class_scope or env.is_c_class_scope:

2580 env = env.outer_scope

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

2582 return cenv

2583

2584 def analyse_declarations(self, env):

2585 self.target.analyse_target_declaration(env)

2586 cenv = self.create_scope(env)

2587 cenv.directives = env.directives

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

2589 self.body.analyse_declarations(cenv)

2590

2591 def analyse_expressions(self, env):

2592 self.dict.analyse_expressions(env)

2593 self.classobj.analyse_expressions(env)

2594 genv = env.global_scope()

2595 cenv = self.scope

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

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

2598 self.body.analyse_expressions(cenv)

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

2600 self.dict.release_temp(env)

2601 #self.classobj.release_temp(env)

2602 #self.target.release_target_temp(env)

2603

2604 def generate_function_definitions(self, env, code):

2605 self.generate_py_string_decls(self.scope, code)

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

2607

2608 def generate_execution_code(self, code):

2609 self.dict.generate_evaluation_code(code)

2610 self.classobj.generate_evaluation_code(code)

2611 self.body.generate_execution_code(code)

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

2613 self.dict.generate_disposal_code(code)

2614 self.dict.free_temps(code)

2615

2616

2617 class CClassDefNode(ClassDefNode):

2618 # An extension type definition.

2619 #

2620 # visibility 'private' or 'public' or 'extern'

2621 # typedef_flag boolean

2622 # api boolean

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

2624 # class_name string Unqualified name of class

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

2626 # base_class_module string or None Module containing the base class

2627 # base_class_name string or None Name of the base class

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

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

2630 # in_pxd boolean Is in a .pxd file

2631 # doc string or None

2632 # body StatNode or None

2633 # entry Symtab.Entry

2634 # base_type PyExtensionType or None

2635 # buffer_defaults_node DictNode or None Declares defaults for a buffer

2636 # buffer_defaults_pos

2637

2638 child_attrs = ["body"]

2639 buffer_defaults_node = None

2640 buffer_defaults_pos = None

2641 typedef_flag = False

2642 api = False

2643 objstruct_name = None

2644 typeobj_name = None

2645

2646 def analyse_declarations(self, env):

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

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

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

2650

2651 import Buffer

2652 if self.buffer_defaults_node:

2653 buffer_defaults = Buffer.analyse_buffer_options(self.buffer_defaults_pos,

2654 env, [], self.buffer_defaults_node,

2655 need_complete=False)

2656 else:

2657 buffer_defaults = None

2658

2659 if env.in_cinclude and not self.objstruct_name:

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

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

2662 self.base_type = None

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

2664 # import the modules for extern classes.

2665 if self.module_name:

2666 self.module = None

2667 for module in env.cimported_modules:

2668 if module.name == self.module_name:

2669 self.module = module

2670 if self.module is None:

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

2672 self.module.has_extern_class = 1

2673 env.add_imported_module(self.module)

2674

2675 if self.base_class_name:

2676 if self.base_class_module:

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

2678 else:

2679 base_class_scope = env

2680 if self.base_class_name == 'object':

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

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

2683 self.base_class_name = None

2684 self.base_class_module = None

2685 base_class_scope = None

2686 if base_class_scope:

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

2688 if base_class_entry:

2689 if not base_class_entry.is_type:

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

2691 elif not base_class_entry.type.is_extension_type:

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

2693 elif not base_class_entry.type.is_complete():

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

2695 else:

2696 self.base_type = base_class_entry.type

2697 has_body = self.body is not None

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

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

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

2701 if not home_scope:

2702 return

2703 else:

2704 home_scope = env

2705

2706 if self.visibility == 'extern':

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

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

2709

2710 self.entry = home_scope.declare_c_class(

2711 name = self.class_name,

2712 pos = self.pos,

2713 defining = has_body and self.in_pxd,

2714 implementing = has_body and not self.in_pxd,

2715 module_name = self.module_name,

2716 base_type = self.base_type,

2717 objstruct_cname = self.objstruct_name,

2718 typeobj_cname = self.typeobj_name,

2719 visibility = self.visibility,

2720 typedef_flag = self.typedef_flag,

2721 api = self.api,

2722 buffer_defaults = buffer_defaults)

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

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

2725 scope = self.entry.type.scope

2726 if scope is not None:

2727 scope.directives = env.directives

2728

2729 if self.doc and Options.docstrings:

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

2731

2732 if has_body:

2733 self.body.analyse_declarations(scope)

2734 if self.in_pxd:

2735 scope.defined = 1

2736 else:

2737 scope.implemented = 1

2738 env.allocate_vtable_names(self.entry)

2739

2740 def analyse_expressions(self, env):

2741 if self.body:

2742 scope = self.entry.type.scope

2743 self.body.analyse_expressions(scope)

2744

2745 def generate_function_definitions(self, env, code):

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

2747 if self.body:

2748 self.body.generate_function_definitions(

2749 self.entry.type.scope, code)

2750

2751 def generate_execution_code(self, code):

2752 # This is needed to generate evaluation code for

2753 # default values of method arguments.

2754 if self.body:

2755 self.body.generate_execution_code(code)

2756

2757 def annotate(self, code):

2758 if self.body:

2759 self.body.annotate(code)

2760

2761

2762 class PropertyNode(StatNode):

2763 # Definition of a property in an extension type.

2764 #

2765 # name string

2766 # doc EncodedString or None Doc string

2767 # body StatListNode

2768

2769 child_attrs = ["body"]

2770

2771 def analyse_declarations(self, env):

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

2773 if entry:

2774 if self.doc and Options.docstrings:

2775 doc_entry = env.get_string_const(

2776 self.doc, identifier = False)

2777 entry.doc_cname = doc_entry.cname

2778 entry.scope.directives = env.directives

2779 self.body.analyse_declarations(entry.scope)

2780

2781 def analyse_expressions(self, env):

2782 self.body.analyse_expressions(env)

2783

2784 def generate_function_definitions(self, env, code):

2785 self.body.generate_function_definitions(env, code)

2786

2787 def generate_execution_code(self, code):

2788 pass

2789

2790 def annotate(self, code):

2791 self.body.annotate(code)

2792

2793

2794 class GlobalNode(StatNode):

2795 # Global variable declaration.

2796 #

2797 # names [string]

2798

2799 child_attrs = []

2800

2801 def analyse_declarations(self, env):

2802 for name in self.names:

2803 env.declare_global(name, self.pos)

2804

2805 def analyse_expressions(self, env):

2806 pass

2807

2808 def generate_execution_code(self, code):

2809 pass

2810

2811

2812 class ExprStatNode(StatNode):

2813 # Expression used as a statement.

2814 #

2815 # expr ExprNode

2816

2817 child_attrs = ["expr"]

2818

2819 def analyse_declarations(self, env):

2820 import ExprNodes

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

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

2823 if func == u'declare':

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

2825 if len(args):

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

2827 for var, type_node in kwds.key_value_pairs:

2828 type = type_node.analyse_as_type(env)

2829 if type is None:

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

2831 else:

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

2833 self.__class__ = PassStatNode

2834

2835 def analyse_expressions(self, env):

2836 self.expr.analyse_expressions(env)

2837 self.expr.release_temp(env)

2838

2839 def generate_execution_code(self, code):

2840 self.expr.generate_evaluation_code(code)

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

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

2843 self.expr.generate_disposal_code(code)

2844 self.expr.free_temps(code)

2845

2846 def annotate(self, code):

2847 self.expr.annotate(code)

2848

2849

2850 class AssignmentNode(StatNode):

2851 # Abstract base class for assignment nodes.

2852 #

2853 # The analyse_expressions and generate_execution_code

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

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

2856 # parallel assignment to be evaluated before assigning

2857 # to any of the left hand sides.

2858

2859 def analyse_expressions(self, env):

2860 self.analyse_types(env)

2861 self.allocate_rhs_temps(env)

2862 self.allocate_lhs_temps(env)

2863

2864 # def analyse_expressions(self, env):

2865 # self.analyse_expressions_1(env)

2866 # self.analyse_expressions_2(env)

2867

2868 def generate_execution_code(self, code):

2869 self.generate_rhs_evaluation_code(code)

2870 self.generate_assignment_code(code)

2871

2872

2873 class SingleAssignmentNode(AssignmentNode):

2874 # The simplest case:

2875 #

2876 # a = b

2877 #

2878 # lhs ExprNode Left hand side

2879 # rhs ExprNode Right hand side

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

2881

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

2883 first = False

2884 declaration_only = False

2885

2886 def analyse_declarations(self, env):

2887 import ExprNodes

2888

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

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

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

2892 if func_name:

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

2894

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

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

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

2898 return

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

2900 if type is None:

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

2902 return

2903 lhs = self.lhs

2904 if func_name == 'declare':

2905 if isinstance(lhs, ExprNodes.NameNode):

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

2907 elif isinstance(lhs, ExprNodes.TupleNode):

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

2909 else:

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

2911 return

2912 for var, pos in vars:

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

2914 if len(args) == 2:

2915 # we have a value

2916 self.rhs = args[1]

2917 else:

2918 self.declaration_only = True

2919 else:

2920 self.declaration_only = True

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

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

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

2924

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

2926 self.declaration_only = True

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

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

2929 return

2930 members = []

2931 for member, type_node in kwds.key_value_pairs:

2932 type = type_node.analyse_as_type(env)

2933 if type is None:

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

2935 else:

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

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

2938 return

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

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

2941 name = self.lhs.name

2942 scope = StructOrUnionScope(name)

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

2944 for member, type, pos in members:

2945 scope.declare_var(member, type, pos)

2946

2947 if self.declaration_only:

2948 return

2949 else:

2950 self.lhs.analyse_target_declaration(env)

2951

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

2953 self.rhs.analyse_types(env)

2954 self.lhs.analyse_target_types(env)

2955 self.lhs.gil_assignment_check(env)

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

2957 if use_temp:

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

2959

2960 def allocate_rhs_temps(self, env):

2961 self.rhs.allocate_temps(env)

2962

2963 def allocate_lhs_temps(self, env):

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

2965 #self.lhs.release_target_temp(env)

2966 #self.rhs.release_temp(env)

2967

2968 def generate_rhs_evaluation_code(self, code):

2969 self.rhs.generate_evaluation_code(code)

2970

2971 def generate_assignment_code(self, code):

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

2973

2974 def annotate(self, code):

2975 self.lhs.annotate(code)

2976 self.rhs.annotate(code)

2977

2978

2979 class CascadedAssignmentNode(AssignmentNode):

2980 # An assignment with multiple left hand sides:

2981 #

2982 # a = b = c

2983 #

2984 # lhs_list [ExprNode] Left hand sides

2985 # rhs ExprNode Right hand sides

2986 #

2987 # Used internally:

2988 #

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

2990

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

2992 coerced_rhs_list = None

2993

2994 def analyse_declarations(self, env):

2995 for lhs in self.lhs_list:

2996 lhs.analyse_target_declaration(env)

2997

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

2999 self.rhs.analyse_types(env)

3000 if use_temp:

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

3002 else:

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

3004 from ExprNodes import CloneNode

3005 self.coerced_rhs_list = []

3006 for lhs in self.lhs_list:

3007 lhs.analyse_target_types(env)

3008 lhs.gil_assignment_check(env)

3009 rhs = CloneNode(self.rhs)

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

3011 self.coerced_rhs_list.append(rhs)

3012

3013 def allocate_rhs_temps(self, env):

3014 self.rhs.allocate_temps(env)

3015

3016 def allocate_lhs_temps(self, env):

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

3018 rhs.allocate_temps(env)

3019 lhs.allocate_target_temps(env, rhs)

3020 #lhs.release_target_temp(env)

3021 #rhs.release_temp(env)

3022 self.rhs.release_temp(env)

3023

3024 def generate_rhs_evaluation_code(self, code):

3025 self.rhs.generate_evaluation_code(code)

3026

3027 def generate_assignment_code(self, code):

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

3029 lhs = self.lhs_list[i]

3030 rhs = self.coerced_rhs_list[i]

3031 rhs.generate_evaluation_code(code)

3032 lhs.generate_assignment_code(rhs, code)

3033 # Assignment has disposed of the cloned RHS

3034 self.rhs.generate_disposal_code(code)

3035 self.rhs.free_temps(code)

3036

3037 def annotate(self, code):

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

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

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

3041 self.rhs.annotate(code)

3042

3043

3044 class ParallelAssignmentNode(AssignmentNode):

3045 # A combined packing/unpacking assignment:

3046 #

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

3048 #

3049 # This has been rearranged by the parser into

3050 #

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

3052 #

3053 # but we must evaluate all the right hand sides

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

3055 #

3056 # stats [AssignmentNode] The constituent assignments

3057

3058 child_attrs = ["stats"]

3059

3060 def analyse_declarations(self, env):

3061 for stat in self.stats:

3062 stat.analyse_declarations(env)

3063

3064 def analyse_expressions(self, env):

3065 for stat in self.stats:

3066 stat.analyse_types(env, use_temp = 1)

3067 stat.allocate_rhs_temps(env)

3068 for stat in self.stats:

3069 stat.allocate_lhs_temps(env)

3070

3071 # def analyse_expressions(self, env):

3072 # for stat in self.stats:

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

3074 # for stat in self.stats:

3075 # stat.analyse_expressions_2(env)

3076

3077 def generate_execution_code(self, code):

3078 for stat in self.stats:

3079 stat.generate_rhs_evaluation_code(code)

3080 for stat in self.stats:

3081 stat.generate_assignment_code(code)

3082

3083 def annotate(self, code):

3084 for stat in self.stats:

3085 stat.annotate(code)

3086

3087

3088 class InPlaceAssignmentNode(AssignmentNode):

3089 # An in place arithmatic operand:

3090 #

3091 # a += b

3092 # a -= b

3093 # ...

3094 #

3095 # lhs ExprNode Left hand side

3096 # rhs ExprNode Right hand side

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

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

3099 #

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

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

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

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

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

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

3106

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

3108 dup = None

3109

3110 def analyse_declarations(self, env):

3111 self.lhs.analyse_target_declaration(env)

3112

3113 def analyse_types(self, env):

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

3115 self.rhs.analyse_types(env)

3116 self.lhs.analyse_target_types(env)

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

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

3119

3120 def allocate_rhs_temps(self, env):

3121 import ExprNodes

3122 if self.lhs.type.is_pyobject:

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

3124 elif self.rhs.type.is_pyobject:

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

3126 if self.lhs.type.is_pyobject:

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

3128 self.result_value.allocate_temps(env)

3129 # if use_temp:

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

3131 self.rhs.allocate_temps(env)

3132 self.dup.allocate_subexpr_temps(env)

3133 self.dup.allocate_temp(env)

3134

3135 def allocate_lhs_temps(self, env):

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

3137 # self.lhs.release_target_temp(env)

3138 self.dup.release_temp(env)

3139 if self.dup.is_temp:

3140 self.dup.release_subexpr_temps(env)

3141 # self.rhs.release_temp(env)

3142 if self.lhs.type.is_pyobject:

3143 self.result_value.release_temp(env)

3144

3145 def generate_execution_code(self, code):

3146 import ExprNodes

3147 self.rhs.generate_evaluation_code(code)

3148 self.dup.generate_subexpr_evaluation_code(code)

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

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

3151 if self.dup.is_temp:

3152 self.dup.allocate_temp_result(code)

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

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

3155 extra = ", Py_None"

3156 else:

3157 extra = ""

3158 if self.lhs.type.is_pyobject:

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

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

3161 self.dup.generate_result_code(code)

3162 code.putln(

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

3164 self.result_value.result(),

3165 self.py_operation_function(),

3166 self.dup.py_result(),

3167 self.rhs.py_result(),

3168 extra,

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

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

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

3172 self.rhs.generate_disposal_code(code)

3173 self.rhs.free_temps(code)

3174 self.dup.generate_disposal_code(code)

3175 self.dup.free_temps(code)

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

3177 else:

3178 c_op = self.operator

3179 if c_op == "//":

3180 c_op = "/"

3181 elif c_op == "**":

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

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

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

3185

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

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

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

3189 else:

3190 self.dup.generate_result_code(code)

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

3192 self.rhs.generate_disposal_code(code)

3193 self.rhs.free_temps(code)

3194 if self.dup.is_temp:

3195 self.dup.generate_subexpr_disposal_code(code)

3196 self.dup.free_subexpr_temps(code)

3197

3198 def create_dup_node(self, env):

3199 import ExprNodes

3200 self.dup = self.lhs

3201 self.dup.analyse_types(env)

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

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

3204 name = self.dup.name,

3205 is_temp = self.dup.is_temp,

3206 entry = self.dup.entry)

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

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

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

3210 attribute = self.dup.attribute,

3211 is_temp = self.dup.is_temp)

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

3213 if self.lhs.index:

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

3215 else:

3216 index = None

3217 if self.lhs.indices:

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

3219 else:

3220 indices = []

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

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

3223 index = index,

3224 indices = indices,

3225 is_temp = self.dup.is_temp)

3226 else:

3227 assert False

3228 self.lhs = target_lhs

3229 return self.dup

3230

3231 def py_operation_function(self):

3232 return self.py_functions[self.operator]

3233

3234 py_functions = {

3235 "|": "PyNumber_InPlaceOr",

3236 "^": "PyNumber_InPlaceXor",

3237 "&": "PyNumber_InPlaceAnd",

3238 "+": "PyNumber_InPlaceAdd",

3239 "-": "PyNumber_InPlaceSubtract",

3240 "*": "PyNumber_InPlaceMultiply",

3241 "/": "PyNumber_InPlaceDivide",

3242 "%": "PyNumber_InPlaceRemainder",

3243 "<<": "PyNumber_InPlaceLshift",

3244 ">>": "PyNumber_InPlaceRshift",

3245 "**": "PyNumber_InPlacePower",

3246 "//": "PyNumber_InPlaceFloorDivide",

3247 }

3248

3249 def annotate(self, code):

3250 self.lhs.annotate(code)

3251 self.rhs.annotate(code)

3252 self.dup.annotate(code)

3253

3254

3255 class PrintStatNode(StatNode):

3256 # print statement

3257 #

3258 # arg_tuple TupleNode

3259 # append_newline boolean

3260

3261 child_attrs = ["arg_tuple"]

3262

3263 def analyse_expressions(self, env):

3264 self.arg_tuple.analyse_expressions(env)

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

3266 self.arg_tuple.release_temp(env)

3267 env.use_utility_code(printing_utility_code)

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

3269 env.use_utility_code(printing_one_utility_code)

3270 self.gil_check(env)

3271

3272 gil_message = "Python print statement"

3273

3274 def generate_execution_code(self, code):

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

3276 arg = self.arg_tuple.args[0]

3277 arg.generate_evaluation_code(code)

3278

3279 code.putln(

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

3281 arg.py_result(),

3282 code.error_goto(self.pos)))

3283 arg.generate_disposal_code(code)

3284 arg.free_temps(code)

3285 else:

3286 self.arg_tuple.generate_evaluation_code(code)

3287 code.putln(

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

3289 self.arg_tuple.py_result(),

3290 self.append_newline,

3291 code.error_goto(self.pos)))

3292 self.arg_tuple.generate_disposal_code(code)

3293 self.arg_tuple.free_temps(code)

3294

3295 def annotate(self, code):

3296 self.arg_tuple.annotate(code)

3297

3298

3299 class ExecStatNode(StatNode):

3300 # exec statement

3301 #

3302 # args [ExprNode]

3303

3304 child_attrs = ["args"]

3305

3306 def analyse_expressions(self, env):

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

3308 arg.analyse_expressions(env)

3309 arg = arg.coerce_to_pyobject(env)

3310 arg.release_temp(env)

3311 self.args[i] = arg

3312 self.temp_result = env.allocate_temp_pyobject()

3313 env.release_temp(self.temp_result)

3314 env.use_utility_code(Builtin.pyexec_utility_code)

3315 self.gil_check(env)

3316

3317 gil_message = "Python exec statement"

3318

3319 def generate_execution_code(self, code):

3320 args = []

3321 for arg in self.args:

3322 arg.generate_evaluation_code(code)

3323 args.append( arg.py_result() )

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

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

3326 (self.temp_result,) + args))

3327 for arg in self.args:

3328 arg.generate_disposal_code(code)

3329 arg.free_temps(code)

3330 code.putln(

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

3332 code.put_gotref(self.temp_result)

3333 code.put_decref_clear(self.temp_result, py_object_type)

3334

3335 def annotate(self, code):

3336 for arg in self.args:

3337 arg.annotate(code)

3338

3339

3340 class DelStatNode(StatNode):

3341 # del statement

3342 #

3343 # args [ExprNode]

3344

3345 child_attrs = ["args"]

3346

3347 def analyse_declarations(self, env):

3348 for arg in self.args:

3349 arg.analyse_target_declaration(env)

3350

3351 def analyse_expressions(self, env):

3352 for arg in self.args:

3353 arg.analyse_target_expression(env, None)

3354 if arg.type.is_pyobject:

3355 self.gil_check(env)

3356 else:

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

3358 #arg.release_target_temp(env)

3359

3360 gil_message = "Deleting Python object"

3361

3362 def generate_execution_code(self, code):

3363 for arg in self.args:

3364 if arg.type.is_pyobject:

3365 arg.generate_deletion_code(code)

3366 # else error reported earlier

3367

3368 def annotate(self, code):

3369 for arg in self.args:

3370 arg.annotate(code)

3371

3372

3373 class PassStatNode(StatNode):

3374 # pass statement

3375

3376 child_attrs = []

3377

3378 def analyse_expressions(self, env):

3379 pass

3380

3381 def generate_execution_code(self, code):

3382 pass

3383

3384

3385 class BreakStatNode(StatNode):

3386

3387 child_attrs = []

3388

3389 def analyse_expressions(self, env):

3390 pass

3391

3392 def generate_execution_code(self, code):

3393 if not code.break_label:

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

3395 else:

3396 code.put_goto(code.break_label)

3397

3398

3399 class ContinueStatNode(StatNode):

3400

3401 child_attrs = []

3402

3403 def analyse_expressions(self, env):

3404 pass

3405

3406 def generate_execution_code(self, code):

3407 if code.funcstate.in_try_finally:

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

3409 elif not code.continue_label:

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

3411 else:

3412 code.put_goto(code.continue_label)

3413

3414

3415 class ReturnStatNode(StatNode):

3416 # return statement

3417 #

3418 # value ExprNode or None

3419 # return_type PyrexType

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

3421

3422 child_attrs = ["value"]

3423

3424 def analyse_expressions(self, env):

3425 return_type = env.return_type

3426 self.return_type = return_type

3427 self.temps_in_use = env.temps_in_use()

3428 if not return_type:

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

3430 return

3431 if self.value:

3432 self.value.analyse_types(env)

3433 if return_type.is_void or return_type.is_returncode:

3434 error(self.value.pos,

3435 "Return with value in void function")

3436 else:

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

3438 self.value.allocate_temps(env)

3439 self.value.release_temp(env)

3440 else:

3441 if (not return_type.is_void

3442 and not return_type.is_pyobject

3443 and not return_type.is_returncode):

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

3445 if return_type.is_pyobject:

3446 self.gil_check(env)

3447

3448 gil_message = "Returning Python object"

3449

3450 def generate_execution_code(self, code):

3451 code.mark_pos(self.pos)

3452 if not self.return_type:

3453 # error reported earlier

3454 return

3455 if self.return_type.is_pyobject:

3456 code.put_xdecref(Naming.retval_cname,

3457 self.return_type)

3458 if self.value:

3459 self.value.generate_evaluation_code(code)

3460 self.value.make_owned_reference(code)

3461 code.putln(

3462 "%s = %s;" % (

3463 Naming.retval_cname,

3464 self.value.result_as(self.return_type)))

3465 self.value.generate_post_assignment_code(code)

3466 self.value.free_temps(code)

3467 else:

3468 if self.return_type.is_pyobject:

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

3470 elif self.return_type.is_returncode:

3471 code.putln(

3472 "%s = %s;" % (

3473 Naming.retval_cname,

3474 self.return_type.default_value))

3475 # free temps the old way

3476 for entry in self.temps_in_use:

3477 code.put_var_decref_clear(entry)

3478 # free temps the new way

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

3480 code.put_decref_clear(cname, type)

3481 #code.putln(

3482 # "goto %s;" %

3483 # code.return_label)

3484 code.put_goto(code.return_label)

3485

3486 def annotate(self, code):

3487 if self.value:

3488 self.value.annotate(code)

3489

3490

3491 class RaiseStatNode(StatNode):

3492 # raise statement

3493 #

3494 # exc_type ExprNode or None

3495 # exc_value ExprNode or None

3496 # exc_tb ExprNode or None

3497

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

3499

3500 def analyse_expressions(self, env):

3501 if self.exc_type:

3502 self.exc_type.analyse_types(env)

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

3504 self.exc_type.allocate_temps(env)

3505 if self.exc_value:

3506 self.exc_value.analyse_types(env)

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

3508 self.exc_value.allocate_temps(env)

3509 if self.exc_tb:

3510 self.exc_tb.analyse_types(env)

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

3512 self.exc_tb.allocate_temps(env)

3513 if self.exc_type:

3514 self.exc_type.release_temp(env)

3515 if self.exc_value:

3516 self.exc_value.release_temp(env)

3517 if self.exc_tb:

3518 self.exc_tb.release_temp(env)

3519 env.use_utility_code(raise_utility_code)

3520 env.use_utility_code(restore_exception_utility_code)

3521 self.gil_check(env)

3522

3523 gil_message = "Raising exception"

3524

3525 def generate_execution_code(self, code):

3526 if self.exc_type:

3527 self.exc_type.generate_evaluation_code(code)

3528 type_code = self.exc_type.py_result()

3529 else:

3530 type_code = "0"

3531 if self.exc_value:

3532 self.exc_value.generate_evaluation_code(code)

3533 value_code = self.exc_value.py_result()

3534 else:

3535 value_code = "0"

3536 if self.exc_tb:

3537 self.exc_tb.generate_evaluation_code(code)

3538 tb_code = self.exc_tb.py_result()

3539 else:

3540 tb_code = "0"

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

3542 code.putln(

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

3544 type_code,

3545 value_code,

3546 tb_code))

3547 else:

3548 code.putln(

3549 "__Pyx_ReRaise();")

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

3551 if obj:

3552 obj.generate_disposal_code(code)

3553 obj.free_temps(code)

3554 code.putln(

3555 code.error_goto(self.pos))

3556

3557 def annotate(self, code):

3558 if self.exc_type:

3559 self.exc_type.annotate(code)

3560 if self.exc_value:

3561 self.exc_value.annotate(code)

3562 if self.exc_tb:

3563 self.exc_tb.annotate(code)

3564

3565

3566 class ReraiseStatNode(StatNode):

3567

3568 child_attrs = []

3569

3570 def analyse_expressions(self, env):

3571 self.gil_check(env)

3572 env.use_utility_code(raise_utility_code)

3573 env.use_utility_code(restore_exception_utility_code)

3574

3575 gil_message = "Raising exception"

3576

3577 def generate_execution_code(self, code):

3578 vars = code.funcstate.exc_vars

3579 if vars:

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

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

3582 else:

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

3584

3585

3586 class AssertStatNode(StatNode):

3587 # assert statement

3588 #

3589 # cond ExprNode

3590 # value ExprNode or None

3591

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

3593

3594 def analyse_expressions(self, env):

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

3596 if self.value:

3597 self.value.analyse_types(env)

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

3599 self.value.allocate_temps(env)

3600 self.cond.release_temp(env)

3601 if self.value:

3602 self.value.release_temp(env)

3603 self.gil_check(env)

3604 #env.recycle_pending_temps() # TEMPORARY

3605

3606 gil_message = "Raising exception"

3607

3608 def generate_execution_code(self, code):

3609 code.putln("#ifndef PYREX_WITHOUT_ASSERTIONS")

3610 self.cond.generate_evaluation_code(code)

3611 code.putln(

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

3613 self.cond.result())

3614 if self.value:

3615 self.value.generate_evaluation_code(code)

3616 code.putln(

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

3618 self.value.py_result())

3619 self.value.generate_disposal_code(code)

3620 self.value.free_temps(code)

3621 else:

3622 code.putln(

3623 "PyErr_SetNone(PyExc_AssertionError);")

3624 code.putln(

3625 code.error_goto(self.pos))

3626 code.putln(

3627 "}")

3628 self.cond.generate_disposal_code(code)

3629 self.cond.free_temps(code)

3630 code.putln("#endif")

3631

3632 def annotate(self, code):

3633 self.cond.annotate(code)

3634 if self.value:

3635 self.value.annotate(code)

3636

3637

3638 class IfStatNode(StatNode):

3639 # if statement

3640 #

3641 # if_clauses [IfClauseNode]

3642 # else_clause StatNode or None

3643

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

3645

3646 def analyse_control_flow(self, env):

3647 env.start_branching(self.pos)

3648 for if_clause in self.if_clauses:

3649 if_clause.analyse_control_flow(env)

3650 env.next_branch(if_clause.end_pos())

3651 if self.else_clause:

3652 self.else_clause.analyse_control_flow(env)

3653 env.finish_branching(self.end_pos())

3654

3655 def analyse_declarations(self, env):

3656 for if_clause in self.if_clauses:

3657 if_clause.analyse_declarations(env)

3658 if self.else_clause:

3659 self.else_clause.analyse_declarations(env)

3660

3661 def analyse_expressions(self, env):

3662 for if_clause in self.if_clauses:

3663 if_clause.analyse_expressions(env)

3664 if self.else_clause:

3665 self.else_clause.analyse_expressions(env)

3666

3667 def generate_execution_code(self, code):

3668 code.mark_pos(self.pos)

3669 end_label = code.new_label()

3670 for if_clause in self.if_clauses:

3671 if_clause.generate_execution_code(code, end_label)

3672 if self.else_clause:

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

3674 self.else_clause.generate_execution_code(code)

3675 code.putln("}")

3676 code.put_label(end_label)

3677

3678 def annotate(self, code):

3679 for if_clause in self.if_clauses:

3680 if_clause.annotate(code)

3681 if self.else_clause:

3682 self.else_clause.annotate(code)

3683

3684

3685 class IfClauseNode(Node):

3686 # if or elif clause in an if statement

3687 #

3688 # condition ExprNode

3689 # body StatNode

3690

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

3692

3693 def analyse_control_flow(self, env):

3694 self.body.analyse_control_flow(env)

3695

3696 def analyse_declarations(self, env):

3697 self.condition.analyse_declarations(env)

3698 self.body.analyse_declarations(env)

3699

3700 def analyse_expressions(self, env):

3701 self.condition = \

3702 self.condition.analyse_temp_boolean_expression(env)

3703 self.condition.release_temp(env)

3704 self.body.analyse_expressions(env)

3705

3706 def generate_execution_code(self, code, end_label):

3707 self.condition.generate_evaluation_code(code)

3708 code.putln(

3709 "if (%s) {" %

3710 self.condition.result())

3711 self.condition.generate_disposal_code(code)

3712 self.condition.free_temps(code)

3713 self.body.generate_execution_code(code)

3714 #code.putln(

3715 # "goto %s;" %

3716 # end_label)

3717 code.put_goto(end_label)

3718 code.putln("}")

3719

3720 def annotate(self, code):

3721 self.condition.annotate(code)

3722 self.body.annotate(code)

3723

3724

3725 class SwitchCaseNode(StatNode):

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

3727 #

3728 # conditions [ExprNode]

3729 # body StatNode

3730

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

3732

3733 def generate_execution_code(self, code):

3734 for cond in self.conditions:

3735 code.mark_pos(cond.pos)

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

3737 self.body.generate_execution_code(code)

3738 code.putln("break;")

3739

3740 def annotate(self, code):

3741 for cond in self.conditions:

3742 cond.annotate(code)

3743 self.body.annotate(code)

3744

3745 class SwitchStatNode(StatNode):

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

3747 #

3748 # test ExprNode

3749 # cases [SwitchCaseNode]

3750 # else_clause StatNode or None

3751

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

3753

3754 def generate_execution_code(self, code):

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

3756 for case in self.cases:

3757 case.generate_execution_code(code)

3758 if self.else_clause is not None:

3759 code.putln("default:")

3760 self.else_clause.generate_execution_code(code)

3761 code.putln("break;")

3762 code.putln("}")

3763

3764 def annotate(self, code):

3765 self.test.annotate(code)

3766 for case in self.cases:

3767 case.annotate(code)

3768 if self.else_clause is not None:

3769 self.else_clause.annotate(code)

3770

3771 class LoopNode(object):

3772

3773 def analyse_control_flow(self, env):

3774 env.start_branching(self.pos)

3775 self.body.analyse_control_flow(env)

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

3777 if self.else_clause:

3778 self.else_clause.analyse_control_flow(env)

3779 env.finish_branching(self.end_pos())

3780

3781

3782 class WhileStatNode(LoopNode, StatNode):

3783 # while statement

3784 #

3785 # condition ExprNode

3786 # body StatNode

3787 # else_clause StatNode

3788

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

3790

3791 def analyse_declarations(self, env):

3792 self.body.analyse_declarations(env)

3793 if self.else_clause:

3794 self.else_clause.analyse_declarations(env)

3795

3796 def analyse_expressions(self, env):

3797 self.condition = \

3798 self.condition.analyse_temp_boolean_expression(env)

3799 self.condition.release_temp(env)

3800 #env.recycle_pending_temps() # TEMPORARY

3801 self.body.analyse_expressions(env)

3802 if self.else_clause:

3803 self.else_clause.analyse_expressions(env)

3804

3805 def generate_execution_code(self, code):

3806 old_loop_labels = code.new_loop_labels()

3807 code.putln(

3808 "while (1) {")

3809 self.condition.generate_evaluation_code(code)

3810 self.condition.generate_disposal_code(code)

3811 code.putln(

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

3813 self.condition.result())

3814 self.condition.free_temps(code)

3815 self.body.generate_execution_code(code)

3816 code.put_label(code.continue_label)

3817 code.putln("}")

3818 break_label = code.break_label

3819 code.set_loop_labels(old_loop_labels)

3820 if self.else_clause:

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

3822 self.else_clause.generate_execution_code(code)

3823 code.putln("}")

3824 code.put_label(break_label)

3825

3826 def annotate(self, code):

3827 self.condition.annotate(code)

3828 self.body.annotate(code)

3829 if self.else_clause:

3830 self.else_clause.annotate(code)

3831

3832

3833 def ForStatNode(pos, **kw):

3834 if 'iterator' in kw:

3835 return ForInStatNode(pos, **kw)

3836 else:

3837 return ForFromStatNode(pos, **kw)

3838

3839 class ForInStatNode(LoopNode, StatNode):

3840 # for statement

3841 #

3842 # target ExprNode

3843 # iterator IteratorNode

3844 # body StatNode

3845 # else_clause StatNode

3846 # item NextNode used internally

3847

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

3849 item = None

3850

3851 def analyse_declarations(self, env):

3852 self.target.analyse_target_declaration(env)

3853 self.body.analyse_declarations(env)

3854 if self.else_clause:

3855 self.else_clause.analyse_declarations(env)

3856

3857 def analyse_expressions(self, env):

3858 import ExprNodes

3859 self.target.analyse_target_types(env)

3860 self.iterator.analyse_expressions(env)

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

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

3863 self.item.allocate_temps(env)

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

3865 #self.item.release_temp(env)

3866 #self.target.release_target_temp(env)

3867 self.body.analyse_expressions(env)

3868 if self.else_clause:

3869 self.else_clause.analyse_expressions(env)

3870 self.iterator.release_temp(env)

3871

3872 def generate_execution_code(self, code):

3873 old_loop_labels = code.new_loop_labels()

3874 self.iterator.allocate_counter_temp(code)

3875 self.iterator.generate_evaluation_code(code)

3876 code.putln(

3877 "for (;;) {")

3878 self.item.generate_evaluation_code(code)

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

3880 self.body.generate_execution_code(code)

3881 code.put_label(code.continue_label)

3882 code.putln(

3883 "}")

3884 break_label = code.break_label

3885 code.set_loop_labels(old_loop_labels)

3886 if self.else_clause:

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

3888 self.else_clause.generate_execution_code(code)

3889 code.putln("}")

3890 code.put_label(break_label)

3891 self.iterator.release_counter_temp(code)

3892 self.iterator.generate_disposal_code(code)

3893 self.iterator.free_temps(code)

3894

3895 def annotate(self, code):

3896 self.target.annotate(code)

3897 self.iterator.annotate(code)

3898 self.body.annotate(code)

3899 if self.else_clause:

3900 self.else_clause.annotate(code)

3901 self.item.annotate(code)

3902

3903

3904 class ForFromStatNode(LoopNode, StatNode):

3905 # for name from expr rel name rel expr

3906 #

3907 # target NameNode

3908 # bound1 ExprNode

3909 # relation1 string

3910 # relation2 string

3911 # bound2 ExprNode

3912 # step ExprNode or None

3913 # body StatNode

3914 # else_clause StatNode or None

3915 #

3916 # Used internally:

3917 #

3918 # from_range bool

3919 # is_py_target bool

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

3921 # py_loopvar_node PyTempNode or None

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

3923

3924 is_py_target = False

3925 loopvar_node = None

3926 py_loopvar_node = None

3927 from_range = False

3928

3929 def analyse_declarations(self, env):

3930 self.target.analyse_target_declaration(env)

3931 self.body.analyse_declarations(env)

3932 if self.else_clause:

3933 self.else_clause.analyse_declarations(env)

3934

3935 def analyse_expressions(self, env):

3936 import ExprNodes

3937 self.target.analyse_target_types(env)

3938 self.bound1.analyse_types(env)

3939 self.bound2.analyse_types(env)

3940 if self.step is not None:

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

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

3943 self.step.analyse_types(env)

3944

3945 target_type = self.target.type

3946 if self.target.type.is_numeric:

3947 loop_type = self.target.type

3948 else:

3949 loop_type = PyrexTypes.c_int_type

3950 if not self.bound1.type.is_pyobject:

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

3952 if not self.bound2.type.is_pyobject:

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

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

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

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

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

3958 if not self.bound2.is_literal:

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

3960 if self.step is not None:

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

3962 if not self.step.is_literal:

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

3964

3965 target_type = self.target.type

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

3967 error(self.target.pos,

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

3969 if target_type.is_numeric:

3970 self.is_py_target = False

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

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