1 #

2 # Pyrex - Parse tree nodes

3 #

4

5 import sys, os, time, copy

6

7 try:

8 set

9 except NameError:

10 # Python 2.3

11 from sets import Set as set

12

13 import Code

14 import Builtin

15 from Errors import error, warning, InternalError

16 import Naming

17 import PyrexTypes

18 import TypeSlots

19 from PyrexTypes import py_object_type, error_type, CTypedefType, CFuncType

20 from Symtab import ModuleScope, LocalScope, GeneratorLocalScope, \

21 StructOrUnionScope, PyClassScope, CClassScope

22 from Cython.Utils import open_new_file, replace_suffix

23 from Code import UtilityCode

24 from StringEncoding import EncodedString, escape_byte_string, split_docstring

25 import Options

26 import ControlFlow

27 import DebugFlags

28

29 absolute_path_length = 0

30

31 def relative_position(pos):

32 """

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

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

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

36 e.g,. when distributing binaries.)

37

38 INPUT:

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

40

41 OUTPUT:

42 relative filename

43 line number

44

45 AUTHOR: William Stein

46 """

47 global absolute_path_length

48 if absolute_path_length==0:

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

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

51

52 def embed_position(pos, docstring):

53 if not Options.embed_pos_in_docstring:

54 return docstring

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

56 if docstring is None:

57 # unicode string

58 return EncodedString(pos_line)

59

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

61 # otherwise make the docstring a unicode string

62 encoding = docstring.encoding

63 if encoding is not None:

64 try:

65 encoded_bytes = pos_line.encode(encoding)

66 except UnicodeEncodeError:

67 encoding = None

68

69 if not docstring:

70 # reuse the string encoding of the original docstring

71 doc = EncodedString(pos_line)

72 else:

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

74 doc.encoding = encoding

75 return doc

76

77

78 from Code import CCodeWriter

79 from types import FunctionType

80

81 def write_func_call(func):

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

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

84 # here we annotate the code with this function call

85 # but only if new code is generated

86 node, code = args[:2]

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

88 ' ' * code.call_level,

89 node.__class__.__name__,

90 func.__name__,

91 node.pos[1:])

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

93 code.putln(marker)

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

95 code.call_level += 4

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

97 code.call_level -= 4

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

99 code.buffer.stream.seek(pristine)

100 else:

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

102 code.putln(marker)

103 return res

104 else:

105 return func(*args, **kwds)

106 return f

107

108 class VerboseCodeWriter(type):

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

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

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

112 attrs = dict(attrs)

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

114 if isinstance(m, FunctionType):

115 attrs[mname] = write_func_call(m)

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

117

118

119 class Node(object):

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

121 # is_name boolean Is a NameNode

122 # is_literal boolean Is a ConstNode

123

124 if DebugFlags.debug_trace_code_generation:

125 __metaclass__ = VerboseCodeWriter

126

127 is_name = 0

128 is_literal = 0

129 temps = None

130

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

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

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

134 child_attrs = None

135

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

137 self.pos = pos

138 self.__dict__.update(kw)

139

140 gil_message = "Operation"

141

142 nogil_check = None

143

144 def gil_error(self, env=None):

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

146

147 def clone_node(self):

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

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

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

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

152 level in the tree."""

153 result = copy.copy(self)

154 for attrname in result.child_attrs:

155 value = getattr(result, attrname)

156 if isinstance(value, list):

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

158 return result

159

160

161 #

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

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

164 #

165 # (0) analyse_control_flow

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

167 # queried.

168 #

169 # (1) analyse_declarations

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

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

172 # to an otherwise undeclared name).

173 #

174 # (2) analyse_expressions

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

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

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

178 # Allocate temporary locals for intermediate results. Fill

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

180 # fragment.

181 #

182 # (3) generate_code

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

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

185 # functions.

186 #

187

188 def analyse_control_flow(self, env):

189 pass

190

191 def analyse_declarations(self, env):

192 pass

193

194 def analyse_expressions(self, env):

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

196 self.__class__.__name__)

197

198 def generate_code(self, code):

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

200 self.__class__.__name__)

201

202 def annotate(self, code):

203 # mro does the wrong thing

204 if isinstance(self, BlockNode):

205 self.body.annotate(code)

206

207 def end_pos(self):

208 try:

209 return self._end_pos

210 except AttributeError:

211 pos = self.pos

212 if not self.child_attrs:

213 self._end_pos = pos

214 return pos

215 for attr in self.child_attrs:

216 child = getattr(self, attr)

217 # Sometimes lists, sometimes nodes

218 if child is None:

219 pass

220 elif isinstance(child, list):

221 for c in child:

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

223 else:

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

225 self._end_pos = pos

226 return pos

227

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

229 if cutoff == 0:

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

231 if encountered is None:

232 encountered = set()

233 if id(self) in encountered:

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

235 encountered.add(id(self))

236

237 def dump_child(x, level):

238 if isinstance(x, Node):

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

240 elif isinstance(x, list):

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

242 else:

243 return repr(x)

244

245

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

247 if len(attrs) == 0:

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

249 else:

250 indent = " " * level

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

252 for key, value in attrs:

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

254 res += "%s>" % indent

255 return res

256

257 class CompilerDirectivesNode(Node):

258 """

259 Sets compiler directives for the children nodes

260 """

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

262 # *all* possible directives.

263 # body Node

264 child_attrs = ["body"]

265

266 def analyse_control_flow(self, env):

267 old = env.directives

268 env.directives = self.directives

269 self.body.analyse_control_flow(env)

270 env.directives = old

271

272 def analyse_declarations(self, env):

273 old = env.directives

274 env.directives = self.directives

275 self.body.analyse_declarations(env)

276 env.directives = old

277

278 def analyse_expressions(self, env):

279 old = env.directives

280 env.directives = self.directives

281 self.body.analyse_expressions(env)

282 env.directives = old

283

284 def generate_function_definitions(self, env, code):

285 env_old = env.directives

286 code_old = code.globalstate.directives

287 code.globalstate.directives = self.directives

288 self.body.generate_function_definitions(env, code)

289 env.directives = env_old

290 code.globalstate.directives = code_old

291

292 def generate_execution_code(self, code):

293 old = code.globalstate.directives

294 code.globalstate.directives = self.directives

295 self.body.generate_execution_code(code)

296 code.globalstate.directives = old

297

298 def annotate(self, code):

299 old = code.globalstate.directives

300 code.globalstate.directives = self.directives

301 self.body.annotate(code)

302 code.globalstate.directives = old

303

304 class BlockNode(object):

305 # Mixin class for nodes representing a declaration block.

306

307 def generate_cached_builtins_decls(self, env, code):

308 entries = env.global_scope().undeclared_cached_builtins

309 for entry in entries:

310 code.globalstate.add_cached_builtin_decl(entry)

311 del entries[:]

312

313

314 class StatListNode(Node):

315 # stats a list of StatNode

316

317 child_attrs = ["stats"]

318

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

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

321 return node # No node-specific analysis necesarry

322 create_analysed = staticmethod(create_analysed)

323

324 def analyse_control_flow(self, env):

325 for stat in self.stats:

326 stat.analyse_control_flow(env)

327

328 def analyse_declarations(self, env):

329 #print "StatListNode.analyse_declarations" ###

330 for stat in self.stats:

331 stat.analyse_declarations(env)

332

333 def analyse_expressions(self, env):

334 #print "StatListNode.analyse_expressions" ###

335 for stat in self.stats:

336 stat.analyse_expressions(env)

337

338 def generate_function_definitions(self, env, code):

339 #print "StatListNode.generate_function_definitions" ###

340 for stat in self.stats:

341 stat.generate_function_definitions(env, code)

342

343 def generate_execution_code(self, code):

344 #print "StatListNode.generate_execution_code" ###

345 for stat in self.stats:

346 code.mark_pos(stat.pos)

347 stat.generate_execution_code(code)

348

349 def annotate(self, code):

350 for stat in self.stats:

351 stat.annotate(code)

352

353

354 class StatNode(Node):

355 #

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

357 #

358 # (1) generate_function_definitions

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

360 # unions, enums and functions defined in the current

361 # scope-block.

362 #

363 # (2) generate_execution_code

364 # Emit C code for executable statements.

365 #

366

367 def generate_function_definitions(self, env, code):

368 pass

369

370 def generate_execution_code(self, code):

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

372 self.__class__.__name__)

373

374

375 class CDefExternNode(StatNode):

376 # include_file string or None

377 # body StatNode

378

379 child_attrs = ["body"]

380

381 def analyse_declarations(self, env):

382 if self.include_file:

383 env.add_include_file(self.include_file)

384 old_cinclude_flag = env.in_cinclude

385 env.in_cinclude = 1

386 self.body.analyse_declarations(env)

387 env.in_cinclude = old_cinclude_flag

388

389 def analyse_expressions(self, env):

390 pass

391

392 def generate_execution_code(self, code):

393 pass

394

395 def annotate(self, code):

396 self.body.annotate(code)

397

398

399 class CDeclaratorNode(Node):

400 # Part of a C declaration.

401 #

402 # Processing during analyse_declarations phase:

403 #

404 # analyse

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

406 # CNameDeclaratorNode of the name being declared

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

408 #

409 # calling_convention string Calling convention of CFuncDeclaratorNode

410 # for which this is a base

411

412 child_attrs = []

413

414 calling_convention = ""

415

416

417 class CNameDeclaratorNode(CDeclaratorNode):

418 # name string The Pyrex name being declared

419 # cname string or None C name, if specified

420 # default ExprNode or None the value assigned on declaration

421

422 child_attrs = ['default']

423

424 default = None

425

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

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

428 # May have mistaken the name for the type.

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

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

431 elif base_type.is_void:

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

433 else:

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

435 base_type = py_object_type

436 self.type = base_type

437 return self, base_type

438

439 class CPtrDeclaratorNode(CDeclaratorNode):

440 # base CDeclaratorNode

441

442 child_attrs = ["base"]

443

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

445 if base_type.is_pyobject:

446 error(self.pos,

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

448 ptr_type = PyrexTypes.c_ptr_type(base_type)

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

450

451 class CArrayDeclaratorNode(CDeclaratorNode):

452 # base CDeclaratorNode

453 # dimension ExprNode

454

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

456

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

458 if self.dimension:

459 self.dimension.analyse_const_expression(env)

460 if not self.dimension.type.is_int:

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

462 size = self.dimension.get_constant_c_result_code()

463 if size is not None:

464 try:

465 size = int(size)

466 except ValueError:

467 # runtime constant?

468 pass

469 else:

470 size = None

471 if not base_type.is_complete():

472 error(self.pos,

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

474 if base_type.is_pyobject:

475 error(self.pos,

476 "Array element cannot be a Python object")

477 if base_type.is_cfunction:

478 error(self.pos,

479 "Array element cannot be a function")

480 array_type = PyrexTypes.c_array_type(base_type, size)

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

482

483

484 class CFuncDeclaratorNode(CDeclaratorNode):

485 # base CDeclaratorNode

486 # args [CArgDeclNode]

487 # has_varargs boolean

488 # exception_value ConstNode

489 # exception_check boolean True if PyErr_Occurred check needed

490 # nogil boolean Can be called without gil

491 # with_gil boolean Acquire gil around function body

492

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

494

495 overridable = 0

496 optional_arg_count = 0

497

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

499 if nonempty:

500 nonempty -= 1

501 func_type_args = []

502 for arg_node in self.args:

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

504 name = name_declarator.name

505 if name_declarator.cname:

506 error(self.pos,

507 "Function argument cannot have C name specification")

508 # Turn *[] argument into **

509 if type.is_array:

510 type = PyrexTypes.c_ptr_type(type.base_type)

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

512 if type.is_void:

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

514 func_type_args.append(

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

516 if arg_node.default:

517 self.optional_arg_count += 1

518 elif self.optional_arg_count:

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

520

521 if self.optional_arg_count:

522 scope = StructOrUnionScope()

523 arg_count_member = '%sn' % Naming.pyrex_prefix

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

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

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

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

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

529 kind = 'struct',

530 scope = scope,

531 typedef_flag = 0,

532 pos = self.pos,

533 cname = struct_cname)

534 self.op_args_struct.defined_in_pxd = 1

535 self.op_args_struct.used = 1

536

537 exc_val = None

538 exc_check = 0

539 if self.exception_check == '+':

540 env.add_include_file('stdexcept')

541 if return_type.is_pyobject \

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

543 and self.exception_check != '+':

544 error(self.pos,

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

546 else:

547 if self.exception_value:

548 self.exception_value.analyse_const_expression(env)

549 exc_val = self.exception_value.get_constant_c_result_code()

550 if self.exception_check == '+':

551 exc_val_type = self.exception_value.type

552 if not exc_val_type.is_error and \

553 not exc_val_type.is_pyobject and \

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

555 error(self.exception_value.pos,

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

557 else:

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

559 error(self.exception_value.pos,

560 "Exception value incompatible with function return type")

561 exc_check = self.exception_check

562 if return_type.is_array:

563 error(self.pos,

564 "Function cannot return an array")

565 if return_type.is_cfunction:

566 error(self.pos,

567 "Function cannot return a function")

568 func_type = PyrexTypes.CFuncType(

569 return_type, func_type_args, self.has_varargs,

570 optional_arg_count = self.optional_arg_count,

571 exception_value = exc_val, exception_check = exc_check,

572 calling_convention = self.base.calling_convention,

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

574 if self.optional_arg_count:

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

576 callspec = env.directives['callspec']

577 if callspec:

578 current = func_type.calling_convention

579 if current and current != callspec:

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

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

582 func_type.calling_convention = callspec

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

584

585

586 class CArgDeclNode(Node):

587 # Item in a function declaration argument list.

588 #

589 # base_type CBaseTypeNode

590 # declarator CDeclaratorNode

591 # not_none boolean Tagged with 'not None'

592 # default ExprNode or None

593 # default_value PyObjectConst constant for default value

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

595 # is_kw_only boolean Is a keyword-only argument

596

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

598

599 is_self_arg = 0

600 is_generic = 1

601 type = None

602 name_declarator = None

603 default_value = None

604

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

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

607 if self.type is None:

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

609 # We fix that here.

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

611 if nonempty:

612 self.declarator.name = self.base_type.name

613 self.base_type.name = None

614 self.base_type.is_basic_c_type = False

615 could_be_name = True

616 else:

617 could_be_name = False

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

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

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

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

622 else:

623 return self.name_declarator, self.type

624

625 def calculate_default_value_code(self, code):

626 if self.default_value is None:

627 if self.default:

628 if self.default.is_literal:

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

630 self.default.generate_evaluation_code(code)

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

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

633 return self.default_value

634

635 def annotate(self, code):

636 if self.default:

637 self.default.annotate(code)

638

639

640 class CBaseTypeNode(Node):

641 # Abstract base class for C base type nodes.

642 #

643 # Processing during analyse_declarations phase:

644 #

645 # analyse

646 # Returns the type.

647

648 pass

649

650 class CAnalysedBaseTypeNode(Node):

651 # type type

652

653 child_attrs = []

654

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

656 return self.type

657

658 class CSimpleBaseTypeNode(CBaseTypeNode):

659 # name string

660 # module_path [string] Qualifying name components

661 # is_basic_c_type boolean

662 # signed boolean

663 # longness integer

664 # complex boolean

665 # is_self_arg boolean Is self argument of C method

666

667 child_attrs = []

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

669

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

671 # Return type descriptor.

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

673 type = None

674 if self.is_basic_c_type:

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

676 if not type:

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

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

679 type = py_object_type

680 elif self.name is None:

681 if self.is_self_arg and env.is_c_class_scope:

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

683 type = env.parent_type

684 else:

685 type = py_object_type

686 else:

687 if self.module_path:

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

689 else:

690 scope = env

691 if scope:

692 if scope.is_c_class_scope:

693 scope = scope.global_scope()

694 entry = scope.lookup(self.name)

695 if entry and entry.is_type:

696 type = entry.type

697 elif could_be_name:

698 if self.is_self_arg and env.is_c_class_scope:

699 type = env.parent_type

700 else:

701 type = py_object_type

702 self.arg_name = self.name

703 else:

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

705 if self.complex:

706 if not type.is_numeric or type.is_complex:

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

708 type = PyrexTypes.CComplexType(type)

709 type.create_declaration_utility_code(env)

710 if type:

711 return type

712 else:

713 return PyrexTypes.error_type

714

715 class CBufferAccessTypeNode(CBaseTypeNode):

716 # After parsing:

717 # positional_args [ExprNode] List of positional arguments

718 # keyword_args DictNode Keyword arguments

719 # base_type_node CBaseTypeNode

720

721 # After analysis:

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

723

724

725 child_attrs = ["base_type_node", "positional_args",

726 "keyword_args", "dtype_node"]

727

728 dtype_node = None

729

730 name = None

731

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

733 base_type = self.base_type_node.analyse(env)

734 if base_type.is_error: return base_type

735 import Buffer

736

737 options = Buffer.analyse_buffer_options(

738 self.pos,

739 env,

740 self.positional_args,

741 self.keyword_args,

742 base_type.buffer_defaults)

743

744 if sys.version_info[0] < 3:

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

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

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

748

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

750 return self.type

751

752 class CComplexBaseTypeNode(CBaseTypeNode):

753 # base_type CBaseTypeNode

754 # declarator CDeclaratorNode

755

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

757

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

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

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

761 return type

762

763

764 class CVarDefNode(StatNode):

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

766 #

767 # visibility 'private' or 'public' or 'extern'

768 # base_type CBaseTypeNode

769 # declarators [CDeclaratorNode]

770 # in_pxd boolean

771 # api boolean

772 # need_properties [entry]

773

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

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

776

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

778 need_properties = ()

779

780 decorators = None

781 directive_locals = {}

782

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

784 if not dest_scope:

785 dest_scope = env

786 self.dest_scope = dest_scope

787 base_type = self.base_type.analyse(env)

788

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

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

791 # a property; made in AnalyseDeclarationsTransform).

792 if (dest_scope.is_c_class_scope

793 and self.visibility == 'public'

794 and base_type.is_pyobject

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

796 self.need_properties = []

797 need_property = True

798 visibility = 'private'

799 else:

800 need_property = False

801 visibility = self.visibility

802

803 for declarator in self.declarators:

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

805 if not type.is_complete():

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

807 error(declarator.pos,

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

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

810 error(declarator.pos,

811 "Python object cannot be declared extern")

812 name = name_declarator.name

813 cname = name_declarator.cname

814 if name == '':

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

816 return

817 if type.is_cfunction:

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

819 cname = cname, visibility = self.visibility, in_pxd = self.in_pxd,

820 api = self.api)

821 if entry is not None:

822 entry.directive_locals = self.directive_locals

823 else:

824 if self.directive_locals:

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

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

827 error(self.pos,

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

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

830 cname = cname, visibility = visibility, is_cdef = 1)

831 if need_property:

832 self.need_properties.append(entry)

833 entry.needs_property = 1

834

835

836 class CStructOrUnionDefNode(StatNode):

837 # name string

838 # cname string or None

839 # kind "struct" or "union"

840 # typedef_flag boolean

841 # visibility "public" or "private"

842 # in_pxd boolean

843 # attributes [CVarDefNode] or None

844 # entry Entry

845 # packed boolean

846

847 child_attrs = ["attributes"]

848

849 def analyse_declarations(self, env):

850 scope = None

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

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

853 if self.attributes is not None:

854 scope = StructOrUnionScope(self.name)

855 self.entry = env.declare_struct_or_union(

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

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

858 if self.attributes is not None:

859 if self.in_pxd and not env.in_cinclude:

860 self.entry.defined_in_pxd = 1

861 for attr in self.attributes:

862 attr.analyse_declarations(env, scope)

863 if self.visibility != 'extern':

864 need_typedef_indirection = False

865 for attr in scope.var_entries:

866 type = attr.type

867 while type.is_array:

868 type = type.base_type

869 if type == self.entry.type:

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

871 if self.typedef_flag:

872 while type.is_ptr:

873 type = type.base_type

874 if type == self.entry.type:

875 need_typedef_indirection = True

876 if need_typedef_indirection:

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

878 struct_entry = self.entry

879 self.entry = env.declare_typedef(

880 self.name, struct_entry.type, self.pos,

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

882 struct_entry.type.typedef_flag = False

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

884 struct_entry.cname = struct_entry.type.cname = \

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

886

887 def analyse_expressions(self, env):

888 pass

889

890 def generate_execution_code(self, code):

891 pass

892

893

894 class CEnumDefNode(StatNode):

895 # name string or None

896 # cname string or None

897 # items [CEnumDefItemNode]

898 # typedef_flag boolean

899 # visibility "public" or "private"

900 # in_pxd boolean

901 # entry Entry

902

903 child_attrs = ["items"]

904

905 def analyse_declarations(self, env):

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

907 cname = self.cname, typedef_flag = self.typedef_flag,

908 visibility = self.visibility)

909 if self.items is not None:

910 if self.in_pxd and not env.in_cinclude:

911 self.entry.defined_in_pxd = 1

912 for item in self.items:

913 item.analyse_declarations(env, self.entry)

914

915 def analyse_expressions(self, env):

916 pass

917

918 def generate_execution_code(self, code):

919 if self.visibility == 'public':

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

921 for item in self.entry.enum_values:

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

923 temp,

924 item.cname,

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

926 code.put_gotref(temp)

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

928 Naming.module_cname,

929 item.name,

930 temp,

931 code.error_goto(item.pos)))

932 code.put_decref_clear(temp, PyrexTypes.py_object_type)

933 code.funcstate.release_temp(temp)

934

935

936 class CEnumDefItemNode(StatNode):

937 # name string

938 # cname string or None

939 # value ExprNode or None

940

941 child_attrs = ["value"]

942

943 def analyse_declarations(self, env, enum_entry):

944 if self.value:

945 self.value.analyse_const_expression(env)

946 if not self.value.type.is_int:

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

948 self.value.analyse_const_expression(env)

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

950 self.value, self.pos, cname = self.cname,

951 visibility = enum_entry.visibility)

952 enum_entry.enum_values.append(entry)

953

954

955 class CTypeDefNode(StatNode):

956 # base_type CBaseTypeNode

957 # declarator CDeclaratorNode

958 # visibility "public" or "private"

959 # in_pxd boolean

960

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

962

963 def analyse_declarations(self, env):

964 base = self.base_type.analyse(env)

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

966 name = name_declarator.name

967 cname = name_declarator.cname

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

969 cname = cname, visibility = self.visibility)

970 if self.in_pxd and not env.in_cinclude:

971 entry.defined_in_pxd = 1

972

973 def analyse_expressions(self, env):

974 pass

975 def generate_execution_code(self, code):

976 pass

977

978

979 class FuncDefNode(StatNode, BlockNode):

980 # Base class for function definition nodes.

981 #

982 # return_type PyrexType

983 # #filename string C name of filename string const

984 # entry Symtab.Entry

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

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

987

988 py_func = None

989 assmt = None

990 needs_closure = False

991 modifiers = []

992

993 def analyse_default_values(self, env):

994 genv = env.global_scope()

995 default_seen = 0

996 for arg in self.args:

997 if arg.default:

998 default_seen = 1

999 if arg.is_generic:

1000 arg.default.analyse_types(env)

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

1002 else:

1003 error(arg.pos,

1004 "This argument cannot have a default value")

1005 arg.default = None

1006 elif arg.kw_only:

1007 default_seen = 1

1008 elif default_seen:

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

1010

1011 def need_gil_acquisition(self, lenv):

1012 return 0

1013

1014 def create_local_scope(self, env):

1015 genv = env

1016 while env.is_py_class_scope or env.is_c_class_scope:

1017 env = env.outer_scope

1018 if self.needs_closure:

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

1020 else:

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

1022 lenv.return_type = self.return_type

1023 type = self.entry.type

1024 if type.is_cfunction:

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

1026 self.local_scope = lenv

1027 lenv.directives = env.directives

1028 return lenv

1029

1030 def generate_function_definitions(self, env, code):

1031 import Buffer

1032

1033 lenv = self.local_scope

1034

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

1036 self.entry.scope.is_c_class_scope)

1037

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

1039 if profile:

1040 if lenv.nogil:

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

1042 code.globalstate.use_utility_code(profile_utility_code)

1043

1044 # Generate C code for header and body of function

1045 code.enter_cfunc_scope()

1046 code.return_from_error_cleanup_label = code.new_label()

1047

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

1049 code.mark_pos(self.pos)

1050 self.generate_cached_builtins_decls(lenv, code)

1051 # ----- Function header

1052 code.putln("")

1053 if self.py_func:

1054 self.py_func.generate_function_header(code,

1055 with_pymethdef = env.is_py_class_scope,

1056 proto_only=True)

1057 self.generate_function_header(code,

1058 with_pymethdef = env.is_py_class_scope)

1059 # ----- Local variable declarations

1060 lenv.mangle_closure_cnames(Naming.cur_scope_cname)

1061 self.generate_argument_declarations(lenv, code)

1062 if self.needs_closure:

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

1064 code.put_var_declarations(lenv.var_entries)

1065 init = ""

1066 if not self.return_type.is_void:

1067 if self.return_type.is_pyobject:

1068 init = " = NULL"

1069 code.putln(

1070 "%s%s;" %

1071 (self.return_type.declaration_code(

1072 Naming.retval_cname),

1073 init))

1074 tempvardecl_code = code.insertion_point()

1075 self.generate_keyword_list(code)

1076 # ----- Extern library function declarations

1077 lenv.generate_library_function_declarations(code)

1078 # ----- GIL acquisition

1079 acquire_gil = self.acquire_gil

1080 if acquire_gil:

1081 env.use_utility_code(force_init_threads_utility_code)

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

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

1084 if profile:

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

1086 if not lenv.nogil:

1087 code.put_setup_refcount_context(self.entry.name)

1088 if is_getbuffer_slot:

1089 self.getbuffer_init(code)

1090 # ----- Fetch arguments

1091 self.generate_argument_parsing_code(env, code)

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

1093 # incref it to properly keep track of refcounts.

1094 for entry in lenv.arg_entries:

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

1096 code.put_var_incref(entry)

1097 # ----- Initialise local variables

1098 for entry in lenv.var_entries:

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

1100 code.put_init_var_to_py_none(entry)

1101 # ----- Initialise local buffer auxiliary variables

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

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

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

1105 # ----- Check and convert arguments

1106 self.generate_argument_type_tests(code)

1107 # ----- Acquire buffer arguments

1108 for entry in lenv.arg_entries:

1109 if entry.type.is_buffer:

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

1111 # ----- Function body

1112 self.body.generate_execution_code(code)

1113 # ----- Default return value

1114 code.putln("")

1115 if self.return_type.is_pyobject:

1116 #if self.return_type.is_extension_type:

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

1118 #else:

1119 lhs = Naming.retval_cname

1120 code.put_init_to_py_none(lhs, self.return_type)

1121 else:

1122 val = self.return_type.default_value

1123 if val:

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

1125 # ----- Error cleanup

1126 if code.error_label in code.labels_used:

1127 code.put_goto(code.return_label)

1128 code.put_label(code.error_label)

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

1130 code.put_xdecref(cname, type)

1131

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

1133 # so need to save and restore error state

1134 buffers_present = len(lenv.buffer_entries) > 0

1135 if buffers_present:

1136 code.globalstate.use_utility_code(restore_exception_utility_code)

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

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

1139 for entry in lenv.buffer_entries:

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

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

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

1143

1144 err_val = self.error_value()

1145 exc_check = self.caller_will_check_exceptions()

1146 if err_val is not None or exc_check:

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

1148 # code.globalstate.use_utility_code(get_exception_tuple_utility_code)

1149 # code.put_trace_exception()

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

1151 else:

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

1153 % self.entry.qualified_name, 0)

1154 code.putln(

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

1156 self.entry.qualified_name)

1157 env.use_utility_code(unraisable_exception_utility_code)

1158 env.use_utility_code(restore_exception_utility_code)

1159 default_retval = self.return_type.default_value

1160 if err_val is None and default_retval:

1161 err_val = default_retval

1162 if err_val is not None:

1163 code.putln(

1164 "%s = %s;" % (

1165 Naming.retval_cname,

1166 err_val))

1167

1168 if is_getbuffer_slot:

1169 self.getbuffer_error_cleanup(code)

1170

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

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

1173 # whether this section is used.

1174 if buffers_present or is_getbuffer_slot:

1175 code.put_goto(code.return_from_error_cleanup_label)

1176

1177

1178 # ----- Non-error return cleanup

1179 code.put_label(code.return_label)

1180 for entry in lenv.buffer_entries:

1181 if entry.used:

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

1183 if is_getbuffer_slot:

1184 self.getbuffer_normal_cleanup(code)

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

1186 code.put_label(code.return_from_error_cleanup_label)

1187 if not Options.init_local_none:

1188 for entry in lenv.var_entries:

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

1190 entry.xdecref_cleanup = 1

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

1192 # Decref any increfed args

1193 for entry in lenv.arg_entries:

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

1195 code.put_var_decref(entry)

1196

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

1198 # ----- Return

1199 # This code is duplicated in ModuleNode.generate_module_init_func

1200 if not lenv.nogil:

1201 default_retval = self.return_type.default_value

1202 err_val = self.error_value()

1203 if err_val is None and default_retval:

1204 err_val = default_retval

1205 if self.return_type.is_pyobject:

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

1207

1208 code.put_finish_refcount_context()

1209

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

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

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

1213 code.putln("if (unlikely(%s == -1) && !PyErr_Occurred()) %s = -2;" % (Naming.retval_cname, Naming.retval_cname))

1214

1215 if profile:

1216 if self.return_type.is_pyobject:

1217 code.put_trace_return(Naming.retval_cname)

1218 else:

1219 code.put_trace_return("Py_None")

1220

1221 if acquire_gil:

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

1223

1224 if not self.return_type.is_void:

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

1226

1227 code.putln("}")

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

1229 tempvardecl_code.put_temp_declarations(code.funcstate)

1230 # ----- Python version

1231 code.exit_cfunc_scope()

1232 if self.py_func:

1233 self.py_func.generate_function_definitions(env, code)

1234 self.generate_wrapper_functions(code)

1235

1236 def declare_argument(self, env, arg):

1237 if arg.type.is_void:

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

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

1240 error(arg.pos,

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

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

1243

1244 def generate_wrapper_functions(self, code):

1245 pass

1246

1247 def generate_execution_code(self, code):

1248 # Evaluate and store argument default values

1249 for arg in self.args:

1250 default = arg.default

1251 if default:

1252 if not default.is_literal:

1253 default.generate_evaluation_code(code)

1254 default.make_owned_reference(code)

1255 result = default.result_as(arg.type)

1256 code.putln(

1257 "%s = %s;" % (

1258 arg.calculate_default_value_code(code),

1259 result))

1260 if arg.type.is_pyobject:

1261 code.put_giveref(default.result())

1262 default.generate_post_assignment_code(code)

1263 default.free_temps(code)

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

1265 if self.assmt:

1266 self.assmt.generate_execution_code(code)

1267

1268 #

1269 # Special code for the __getbuffer__ function

1270 #

1271 def getbuffer_init(self, code):

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

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

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

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

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

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

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

1279

1280 def getbuffer_error_cleanup(self, code):

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

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

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

1284 (info, info))

1285

1286 def getbuffer_normal_cleanup(self, code):

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

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

1289 code.put_gotref("Py_None")

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

1291 code.putln("}")

1292

1293 class CFuncDefNode(FuncDefNode):

1294 # C function definition.

1295 #

1296 # modifiers ['inline']

1297 # visibility 'private' or 'public' or 'extern'

1298 # base_type CBaseTypeNode

1299 # declarator CDeclaratorNode

1300 # body StatListNode

1301 # api boolean

1302 # decorators [DecoratorNode] list of decorators

1303 #

1304 # with_gil boolean Acquire GIL around body

1305 # type CFuncType

1306 # py_func wrapper for calling from Python

1307 # overridable whether or not this is a cpdef function

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

1309

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

1311

1312 inline_in_pxd = False

1313 decorators = None

1314 directive_locals = {}

1315

1316 def unqualified_name(self):

1317 return self.entry.name

1318

1319 def analyse_declarations(self, env):

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

1321 base_type = self.base_type.analyse(env)

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

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

1324 if not type.is_cfunction:

1325 error(self.pos,

1326 "Suite attached to non-function declaration")

1327 # Remember the actual type according to the function header

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

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

1330 # from the base type of an extension type.

1331 self.type = type

1332 type.is_overridable = self.overridable

1333 declarator = self.declarator

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

1335 declarator = declarator.base

1336 self.args = declarator.args

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

1338 formal_arg.type = type_arg.type

1339 formal_arg.name = type_arg.name

1340 formal_arg.cname = type_arg.cname

1341 name = name_declarator.name

1342 cname = name_declarator.cname

1343 self.entry = env.declare_cfunction(

1344 name, type, self.pos,

1345 cname = cname, visibility = self.visibility,

1346 defining = self.body is not None,

1347 api = self.api, modifiers = self.modifiers)

1348 self.entry.inline_func_in_pxd = self.inline_in_pxd

1349 self.return_type = type.return_type

1350

1351 if self.overridable and not env.is_module_scope:

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

1353 # An error will be produced in the cdef function

1354 self.overridable = False

1355

1356 if self.overridable:

1357 import ExprNodes

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

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

1360 name = self.entry.name,

1361 args = self.args,

1362 star_arg = None,

1363 starstar_arg = None,

1364 doc = self.doc,

1365 body = py_func_body,

1366 is_wrapper = 1)

1367 self.py_func.is_module_scope = env.is_module_scope

1368 self.py_func.analyse_declarations(env)

1369 self.entry.as_variable = self.py_func.entry

1370 # Reset scope entry the above cfunction

1371 env.entries[name] = self.entry

1372 if not env.is_module_scope or Options.lookup_module_cpdef:

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

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

1375

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

1377 import ExprNodes

1378 args = self.type.args

1379 if omit_optional_args:

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

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

1382 if is_module_scope:

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

1384 else:

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

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

1387 skip_dispatch = not is_module_scope or Options.lookup_module_cpdef

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

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

1390

1391 def declare_arguments(self, env):

1392 for arg in self.type.args:

1393 if not arg.name:

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

1395 self.declare_argument(env, arg)

1396

1397 def need_gil_acquisition(self, lenv):

1398 return self.type.with_gil

1399

1400 def nogil_check(self, env):

1401 type = self.type

1402 with_gil = type.with_gil

1403 if type.nogil and not with_gil:

1404 if type.return_type.is_pyobject:

1405 error(self.pos,

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

1407 for entry in self.local_scope.var_entries:

1408 if entry.type.is_pyobject:

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

1410

1411 def analyse_expressions(self, env):

1412 self.local_scope.directives = env.directives

1413 if self.py_func is not None:

1414 # this will also analyse the default values

1415 self.py_func.analyse_expressions(env)

1416 else:

1417 self.analyse_default_values(env)

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

1419

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

1421 arg_decls = []

1422 type = self.type

1423 visibility = self.entry.visibility

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

1425 arg_decls.append(arg.declaration_code())

1426 if with_dispatch and self.overridable:

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

1428 if type.optional_arg_count and with_opt_args:

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

1430 if type.has_varargs:

1431 arg_decls.append("...")

1432 if not arg_decls:

1433 arg_decls = ["void"]

1434 if cname is None:

1435 cname = self.entry.func_cname

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

1437 if visibility == 'public':

1438 dll_linkage = "DL_EXPORT"

1439 else:

1440 dll_linkage = None

1441 header = self.return_type.declaration_code(entity,

1442 dll_linkage = dll_linkage)

1443 if visibility == 'extern':

1444 storage_class = "%s " % Naming.extern_c_macro

1445 elif visibility == 'public':

1446 storage_class = ""

1447 else:

1448 storage_class = "static "

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

1450 storage_class,

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

1452 header))

1453

1454 def generate_argument_declarations(self, env, code):

1455 for arg in self.args:

1456 if arg.default:

1457 result = arg.calculate_default_value_code(code)

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

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

1460

1461 def generate_keyword_list(self, code):

1462 pass

1463

1464 def generate_argument_parsing_code(self, env, code):

1465 i = 0

1466 if self.type.optional_arg_count:

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

1468 for arg in self.args:

1469 if arg.default:

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

1471 # argument name mangling is in place

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

1473 declarator = arg.declarator

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

1475 declarator = declarator.base

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

1477 i += 1

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

1479 code.putln('}')

1480 code.putln('}')

1481

1482 def generate_argument_conversion_code(self, code):

1483 pass

1484

1485 def generate_argument_type_tests(self, code):

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

1487 # class is a supertype of the declared type.

1488 for arg in self.type.args:

1489 if arg.needs_type_test:

1490 self.generate_arg_type_test(arg, code)

1491

1492 def generate_arg_type_test(self, arg, code):

1493 # Generate type test for one argument.

1494 if arg.type.typeobj_is_available():

1495 typeptr_cname = arg.type.typeptr_cname

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

1497 code.putln(

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

1499 arg_code,

1500 typeptr_cname,

1501 not arg.not_none,

1502 arg.name,

1503 type.is_builtin_type,

1504 code.error_goto(arg.pos)))

1505 else:

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

1507 "without type object name specification")

1508

1509 def error_value(self):

1510 if self.return_type.is_pyobject:

1511 return "0"

1512 else:

1513 #return None

1514 return self.entry.type.exception_value

1515

1516 def caller_will_check_exceptions(self):

1517 return self.entry.type.exception_check

1518

1519 def generate_wrapper_functions(self, code):

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

1521 # wrappers to put in the slots here.

1522 k = 0

1523 entry = self.entry

1524 func_type = entry.type

1525 while entry.prev_entry is not None:

1526 k += 1

1527 entry = entry.prev_entry

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

1529 code.putln()

1530 self.generate_function_header(code,

1531 0,

1532 with_dispatch = entry.type.is_overridable,

1533 with_opt_args = entry.type.optional_arg_count,

1534 cname = entry.func_cname)

1535 if not self.return_type.is_void:

1536 code.put('return ')

1537 args = self.type.args

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

1539 if entry.type.is_overridable:

1540 arglist.append(Naming.skip_dispatch_cname)

1541 elif func_type.is_overridable:

1542 arglist.append('0')

1543 if entry.type.optional_arg_count:

1544 arglist.append(Naming.optional_args_cname)

1545 elif func_type.optional_arg_count:

1546 arglist.append('NULL')

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

1548 code.putln('}')

1549

1550

1551 class PyArgDeclNode(Node):

1552 # Argument which must be a Python object (used

1553 # for * and ** arguments).

1554 #

1555 # name string

1556 # entry Symtab.Entry

1557 child_attrs = []

1558

1559

1560 class DecoratorNode(Node):

1561 # A decorator

1562 #

1563 # decorator NameNode or CallNode

1564 child_attrs = ['decorator']

1565

1566

1567 class DefNode(FuncDefNode):

1568 # A Python function definition.

1569 #

1570 # name string the Python name of the function

1571 # decorators [DecoratorNode] list of decorators

1572 # args [CArgDeclNode] formal arguments

1573 # star_arg PyArgDeclNode or None * argument

1574 # starstar_arg PyArgDeclNode or None ** argument

1575 # doc EncodedString or None

1576 # body StatListNode

1577 #

1578 # The following subnode is constructed internally

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

1580 #

1581 # assmt AssignmentNode Function construction/assignment

1582

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

1584

1585 assmt = None

1586 num_kwonly_args = 0

1587 num_required_kw_args = 0

1588 reqd_kw_flags_cname = "0"

1589 is_wrapper = 0

1590 decorators = None

1591 entry = None

1592 acquire_gil = 0

1593

1594

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

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

1597 k = rk = r = 0

1598 for arg in self.args:

1599 if arg.kw_only:

1600 k += 1

1601 if not arg.default:

1602 rk += 1

1603 if not arg.default:

1604 r += 1

1605 self.num_kwonly_args = k

1606 self.num_required_kw_args = rk

1607 self.num_required_args = r

1608

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

1610 if self.star_arg:

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

1612 if self.starstar_arg:

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

1614 if cfunc is None:

1615 cfunc_args = []

1616 for formal_arg in self.args:

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

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

1619 cname = None,

1620 type = py_object_type,

1621 pos = formal_arg.pos))

1622 cfunc_type = PyrexTypes.CFuncType(return_type = py_object_type,

1623 args = cfunc_args,

1624 has_varargs = False,

1625 exception_value = None,

1626 exception_check = False,

1627 nogil = False,

1628 with_gil = False,

1629 is_overridable = True)

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

1631 else:

1632 cfunc_type = cfunc.type

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

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

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

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

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

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

1639 formal_arg.type = type_arg.type

1640 formal_arg.name_declarator = name_declarator

1641 import ExprNodes

1642 if cfunc_type.exception_value is None:

1643 exception_value = None

1644 else:

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

1646 declarator = CFuncDeclaratorNode(self.pos,

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

1648 args = self.args,

1649 has_varargs = False,

1650 exception_check = cfunc_type.exception_check,

1651 exception_value = exception_value,

1652 with_gil = cfunc_type.with_gil,

1653 nogil = cfunc_type.nogil)

1654 return CFuncDefNode(self.pos,

1655 modifiers = [],

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

1657 declarator = declarator,

1658 body = self.body,

1659 doc = self.doc,

1660 overridable = cfunc_type.is_overridable,

1661 type = cfunc_type,

1662 with_gil = cfunc_type.with_gil,

1663 nogil = cfunc_type.nogil,

1664 visibility = 'private',

1665 api = False,

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

1667

1668 def analyse_declarations(self, env):

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

1670 for arg in self.args:

1671 if hasattr(arg, 'name'):

1672 type = arg.type

1673 name_declarator = None

1674 else:

1675 base_type = arg.base_type.analyse(env)

1676 name_declarator, type = \

1677 arg.declarator.analyse(base_type, env)

1678 arg.name = name_declarator.name

1679 if arg.name in directive_locals:

1680 type_node = directive_locals[arg.name]

1681 other_type = type_node.analyse_as_type(env)

1682 if other_type is None:

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

1684 elif (type is not PyrexTypes.py_object_type

1685 and not type.same_as(other_type)):

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

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

1688 else:

1689 type = other_type

1690 if name_declarator and name_declarator.cname:

1691 error(self.pos,

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

1693 arg.type = type.as_argument_type()

1694 arg.hdr_type = None

1695 arg.needs_conversion = 0

1696 arg.needs_type_test = 0

1697 arg.is_generic = 1

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

1699 error(self.pos,

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

1701 self.declare_pyfunction(env)

1702 self.analyse_signature(env)

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

1704

1705 def analyse_signature(self, env):

1706 any_type_tests_needed = 0

1707 if self.entry.is_special:

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

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

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

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

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

1713 self.entry.signature = TypeSlots.pyfunction_noargs

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

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

1716 self.entry.signature = TypeSlots.pyfunction_onearg

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

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

1719 self.entry.signature = TypeSlots.unaryfunc

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

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

1722 self.entry.signature = TypeSlots.ibinaryfunc

1723 sig = self.entry.signature

1724 nfixed = sig.num_fixed_args()

1725 for i in range(nfixed):

1726 if i < len(self.args):

1727 arg = self.args[i]

1728 arg.is_generic = 0

1729 if sig.is_self_arg(i):

1730 arg.is_self_arg = 1

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

1732 arg.needs_conversion = 0

1733 else:

1734 arg.hdr_type = sig.fixed_arg_type(i)

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

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

1737 arg.needs_type_test = 1

1738 any_type_tests_needed = 1

1739 else:

1740 arg.needs_conversion = 1

1741 if arg.needs_conversion:

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

1743 else:

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

1745 else:

1746 self.bad_signature()

1747 return

1748 if nfixed < len(self.args):

1749 if not sig.has_generic_args:

1750 self.bad_signature()

1751 for arg in self.args:

1752 if arg.is_generic and \

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

1754 arg.needs_type_test = 1

1755 any_type_tests_needed = 1

1756 if any_type_tests_needed:

1757 env.use_utility_code(arg_type_test_utility_code)

1758

1759 def bad_signature(self):

1760 sig = self.entry.signature

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

1762 if sig.has_generic_args:

1763 expected_str = expected_str + " or more"

1764 name = self.name

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

1766 desc = "Special method"

1767 else:

1768 desc = "Method"

1769 error(self.pos,

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

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

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

1773

1774 def signature_has_nongeneric_args(self):

1775 argcount = len(self.args)

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

1777 return 0

1778 return 1

1779

1780 def signature_has_generic_args(self):

1781 return self.entry.signature.has_generic_args

1782

1783 def declare_pyfunction(self, env):

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

1785 name = self.name

1786 entry = env.lookup_here(self.name)

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

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

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

1790 self.entry = entry

1791 prefix = env.scope_prefix

1792 entry.func_cname = \

1793 Naming.pyfunc_prefix + prefix + name

1794 entry.pymethdef_cname = \

1795 Naming.pymethdef_prefix + prefix + name

1796 if Options.docstrings:

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

1798 entry.doc_cname = \

1799 Naming.funcdoc_prefix + prefix + name

1800 else:

1801 entry.doc = None

1802

1803 def declare_arguments(self, env):

1804 for arg in self.args:

1805 if not arg.name:

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

1807 if arg.needs_conversion:

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

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

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

1811 if arg.type.is_pyobject:

1812 arg.entry.init = "0"

1813 arg.entry.init_to_none = 0

1814 else:

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

1816 arg.entry.used = 1

1817 arg.entry.is_self_arg = arg.is_self_arg

1818 if arg.hdr_type:

1819 if arg.is_self_arg or \

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

1821 arg.entry.is_declared_generic = 1

1822 self.declare_python_arg(env, self.star_arg)

1823 self.declare_python_arg(env, self.starstar_arg)

1824

1825 def declare_python_arg(self, env, arg):

1826 if arg:

1827 entry = env.declare_var(arg.name,

1828 PyrexTypes.py_object_type, arg.pos)

1829 entry.used = 1

1830 entry.init = "0"

1831 entry.init_to_none = 0

1832 entry.xdecref_cleanup = 1

1833 arg.entry = entry

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

1835

1836 def analyse_expressions(self, env):

1837 self.local_scope.directives = env.directives

1838 self.analyse_default_values(env)

1839 if env.is_py_class_scope:

1840 self.synthesize_assignment_node(env)

1841

1842 def synthesize_assignment_node(self, env):

1843 import ExprNodes

1844 self.assmt = SingleAssignmentNode(self.pos,

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

1846 rhs = ExprNodes.UnboundMethodNode(self.pos,

1847 function = ExprNodes.PyCFunctionNode(self.pos,

1848 pymethdef_cname = self.entry.pymethdef_cname)))

1849 self.assmt.analyse_declarations(env)

1850 self.assmt.analyse_expressions(env)

1851

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

1853 arg_code_list = []

1854 sig = self.entry.signature

1855 if sig.has_dummy_arg:

1856 arg_code_list.append(

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

1858 for arg in self.args:

1859 if not arg.is_generic:

1860 if arg.is_self_arg:

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

1862 else:

1863 arg_code_list.append(

1864 arg.hdr_type.declaration_code(arg.hdr_cname))

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

1866 arg_code_list.append("PyObject *unused")

1867 if sig.has_generic_args:

1868 arg_code_list.append(

1869 "PyObject *%s, PyObject *%s"

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

1871 arg_code = ", ".join(arg_code_list)

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

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

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

1875 if proto_only:

1876 return

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

1878 docstr = self.entry.doc

1879 if docstr.is_unicode:

1880 docstr = docstr.utf8encode()

1881 code.putln(

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

1883 self.entry.doc_cname,

1884 split_docstring(escape_byte_string(docstr))))

1885 if with_pymethdef:

1886 code.put(

1887 "static PyMethodDef %s = " %

1888 self.entry.pymethdef_cname)

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

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

1891

1892 def generate_argument_declarations(self, env, code):

1893 for arg in self.args:

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

1895 if arg.needs_conversion:

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

1897 else:

1898 code.put_var_declaration(arg.entry)

1899

1900 def generate_keyword_list(self, code):

1901 if self.signature_has_generic_args() and \

1902 self.signature_has_nongeneric_args():

1903 code.put(

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

1905 Naming.pykwdlist_cname)

1906 for arg in self.args:

1907 if arg.is_generic:

1908 pystring_cname = code.intern_identifier(arg.name)

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

1910 code.putln("0};")

1911

1912 def generate_argument_parsing_code(self, env, code):

1913 # Generate PyArg_ParseTuple call for generic

1914 # arguments, if any.

1915 if self.entry.signature.has_dummy_arg:

1916 # get rid of unused argument warning

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

1918

1919 old_error_label = code.new_error_label()

1920 our_error_label = code.error_label

1921 end_label = code.new_label("argument_unpacking_done")

1922

1923 has_kwonly_args = self.num_kwonly_args > 0

1924 has_star_or_kw_args = self.star_arg is not None \

1925 or self.starstar_arg is not None or has_kwonly_args

1926

1927 for arg in self.args:

1928 if not arg.type.is_pyobject:

1929 done = arg.type.create_from_py_utility_code(env)

1930 if not done: pass # will fail later

1931

1932 if not self.signature_has_generic_args():

1933 if has_star_or_kw_args:

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

1935 self.generate_argument_conversion_code(code)

1936

1937 elif not self.signature_has_nongeneric_args():

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

1939 self.generate_stararg_copy_code(code)

1940

1941 else:

1942 positional_args = []

1943 kw_only_args = []

1944 for arg in self.args:

1945 arg_entry = arg.entry

1946 if arg.is_generic:

1947 if arg.default:

1948 if not arg.is_self_arg:

1949 if arg.kw_only:

1950 kw_only_args.append(arg)

1951 else:

1952 positional_args.append(arg)

1953 elif arg.kw_only:

1954 kw_only_args.append(arg)

1955 elif not arg.is_self_arg:

1956 positional_args.append(arg)

1957

1958 self.generate_tuple_and_keyword_parsing_code(

1959 positional_args, kw_only_args, end_label, code)

1960

1961 code.error_label = old_error_label

1962 if code.label_used(our_error_label):

1963 if not code.label_used(end_label):

1964 code.put_goto(end_label)

1965 code.put_label(our_error_label)

1966 if has_star_or_kw_args:

1967 self.generate_arg_decref(self.star_arg, code)

1968 if self.starstar_arg:

1969 if self.starstar_arg.entry.xdecref_cleanup:

1970 code.put_var_xdecref(self.starstar_arg.entry)

1971 else:

1972 code.put_var_decref(self.starstar_arg.entry)

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

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

1975 if code.label_used(end_label):

1976 code.put_label(end_label)

1977

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

1979 if arg.type.is_pyobject:

1980 if arg.is_generic:

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

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

1983 else:

1984 func = arg.type.from_py_function

1985 if func:

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

1987 arg.entry.cname,

1988 func,

1989 item,

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

1991 else:

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

1993

1994 def generate_arg_xdecref(self, arg, code):

1995 if arg:

1996 code.put_var_xdecref(arg.entry)

1997

1998 def generate_arg_decref(self, arg, code):

1999 if arg:

2000 code.put_var_decref(arg.entry)

2001

2002 def generate_stararg_copy_code(self, code):

2003 if not self.star_arg:

2004 code.globalstate.use_utility_code(raise_argtuple_invalid_utility_code)

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

2006 Naming.args_cname)

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

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

2009 code.putln("}")

2010

2011 code.globalstate.use_utility_code(keyword_string_check_utility_code)

2012

2013 if self.starstar_arg:

2014 if self.star_arg:

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

2016 else:

2017 kwarg_check = "%s" % Naming.kwds_cname

2018 else:

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

2020 Naming.kwds_cname, Naming.kwds_cname)

2021 code.putln(

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

2023 kwarg_check, Naming.kwds_cname, self.name,

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

2025

2026 if self.starstar_arg:

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

2028 self.starstar_arg.entry.cname,

2029 Naming.kwds_cname,

2030 Naming.kwds_cname))

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

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

2033 self.starstar_arg.entry.xdecref_cleanup = 0

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

2035

2036

2037 if self.star_arg:

2038 code.put_incref(Naming.args_cname, py_object_type)

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

2040 self.star_arg.entry.cname,

2041 Naming.args_cname))

2042 self.star_arg.entry.xdecref_cleanup = 0

2043

2044 def generate_tuple_and_keyword_parsing_code(self, positional_args,

2045 kw_only_args, success_label, code):

2046 argtuple_error_label = code.new_label("argtuple_error")

2047

2048 min_positional_args = self.num_required_args - self.num_required_kw_args

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

2050 min_positional_args -= 1

2051 max_positional_args = len(positional_args)

2052 has_fixed_positional_count = not self.star_arg and \

2053 min_positional_args == max_positional_args

2054

2055 code.globalstate.use_utility_code(raise_double_keywords_utility_code)

2056 code.globalstate.use_utility_code(raise_argtuple_invalid_utility_code)

2057 if self.num_required_kw_args:

2058 code.globalstate.use_utility_code(raise_keyword_required_utility_code)

2059

2060 if self.starstar_arg or self.star_arg:

2061 self.generate_stararg_init_code(max_positional_args, code)

2062

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

2064 if self.num_required_kw_args:

2065 likely_hint = "likely"

2066 else:

2067 likely_hint = "unlikely"

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

2069 self.generate_keyword_unpacking_code(

2070 min_positional_args, max_positional_args,

2071 has_fixed_positional_count,

2072 positional_args, kw_only_args, argtuple_error_label, code)

2073

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

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

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

2077 # check the length here

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

2079 compare = '!='

2080 else:

2081 compare = '<'

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

2083 Naming.args_cname, compare, min_positional_args))

2084 code.put_goto(argtuple_error_label)

2085

2086 if self.num_required_kw_args:

2087 # pure error case: keywords required but not passed

2088 if max_positional_args > min_positional_args and not self.star_arg:

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

2090 Naming.args_cname, max_positional_args))

2091 code.put_goto(argtuple_error_label)

2092 code.putln('} else {')

2093 for i, arg in enumerate(kw_only_args):

2094 if not arg.default:

2095 pystring_cname = code.intern_identifier(arg.name)

2096 # required keyword-only argument missing

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

2098 self.name,

2099 pystring_cname))

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

2101 break

2102

2103 elif min_positional_args == max_positional_args:

2104 # parse the exact number of positional arguments from the

2105 # args tuple

2106 code.putln('} else {')

2107 for i, arg in enumerate(positional_args):

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

2109 self.generate_arg_assignment(arg, item, code)

2110 self.generate_arg_default_assignments(code)

2111

2112 else:

2113 # parse the positional arguments from the variable length

2114 # args tuple

2115 code.putln('} else {')

2116 self.generate_arg_default_assignments(code)

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

2118 if self.star_arg:

2119 code.putln('default:')

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

2121 for i, arg in reversed_args:

2122 if i >= min_positional_args-1:

2123 if min_positional_args > 1:

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

2125 else:

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

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

2128 self.generate_arg_assignment(arg, item, code)

2129 if min_positional_args == 0:

2130 code.put('case 0: ')

2131 code.putln('break;')

2132 if self.star_arg:

2133 if min_positional_args:

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

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

2136 code.put_goto(argtuple_error_label)

2137 else:

2138 code.put('default: ')

2139 code.put_goto(argtuple_error_label)

2140 code.putln('}')

2141

2142 code.putln('}')

2143

2144 if code.label_used(argtuple_error_label):

2145 code.put_goto(success_label)

2146 code.put_label(argtuple_error_label)

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

2148 self.name, has_fixed_positional_count,

2149 min_positional_args, max_positional_args,

2150 Naming.args_cname))

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

2152

2153 def generate_arg_default_assignments(self, code):

2154 for arg in self.args:

2155 if arg.is_generic and arg.default:

2156 code.putln(

2157 "%s = %s;" % (

2158 arg.entry.cname,

2159 arg.calculate_default_value_code(code)))

2160

2161 def generate_stararg_init_code(self, max_positional_args, code):

2162 if self.starstar_arg:

2163 self.starstar_arg.entry.xdecref_cleanup = 0

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

2165 self.starstar_arg.entry.cname,

2166 self.starstar_arg.entry.cname,

2167 self.error_value()))

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

2169 if self.star_arg:

2170 self.star_arg.entry.xdecref_cleanup = 0

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

2172 Naming.args_cname,

2173 max_positional_args))

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

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

2176 max_positional_args, Naming.args_cname))

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

2178 if self.starstar_arg:

2179 code.putln("")

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

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

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

2183 code.putln('}')

2184 else:

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

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

2187 code.putln('} else {')

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

2189 code.put_incref(Naming.empty_tuple, py_object_type)

2190 code.putln('}')

2191

2192 def generate_keyword_unpacking_code(self, min_positional_args, max_positional_args,

2193 has_fixed_positional_count, positional_args,

2194 kw_only_args, argtuple_error_label, code):

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

2196 max_args = len(all_args)

2197

2198 default_args = []

2199 for i, arg in enumerate(all_args):

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

2201 default_value = arg.calculate_default_value_code(code)

2202 if arg.type is not PyrexTypes.py_object_type:

2203 default_value = "(PyObject*)"+default_value

2204 default_args.append((i, default_value))

2205

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

2207 Naming.kwds_cname)

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

2209 # default value, but C89 needs this

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

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

2212 for i, default_value in default_args:

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

2214

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

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

2217 if self.star_arg:

2218 code.putln('default:')

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

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

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

2222 i, Naming.args_cname, i))

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

2224 if not self.star_arg:

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

2226 code.put_goto(argtuple_error_label)

2227 code.putln('}')

2228

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

2230 # from the kw dict

2231 if self.num_required_args or max_positional_args > 0:

2232 last_required_arg = -1

2233 for i, arg in enumerate(all_args):

2234 if not arg.default:

2235 last_required_arg = i

2236 if last_required_arg < max_positional_args:

2237 last_required_arg = max_positional_args-1

2238 num_required_args = self.num_required_args

2239 if max_positional_args > 0:

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

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

2242 if max_positional_args > 0 and i <= max_positional_args:

2243 if self.star_arg and i == max_positional_args:

2244 code.putln('default:')

2245 else:

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

2247 pystring_cname = code.intern_identifier(arg.name)

2248 if arg.default:

2249 if arg.kw_only:

2250 # handled separately below

2251 continue

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

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

2254 Naming.kwds_cname, pystring_cname))

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

2256 code.putln('}')

2257 else:

2258 num_required_args -= 1

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

2260 i, Naming.kwds_cname, pystring_cname))

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

2262 if i < min_positional_args:

2263 if i == 0:

2264 # special case: we know arg 0 is missing

2265 code.put('else ')

2266 code.put_goto(argtuple_error_label)

2267 else:

2268 # print the correct number of values (args or

2269 # kwargs) that were passed into positional

2270 # arguments up to this point

2271 code.putln('else {')

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

2273 self.name, has_fixed_positional_count,

2274 min_positional_args, max_positional_args, i))

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

2276 code.putln('}')

2277 elif arg.kw_only:

2278 code.putln('else {')

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

2280 self.name, pystring_cname))

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

2282 code.putln('}')

2283 if max_positional_args > 0:

2284 code.putln('}')

2285

2286 if kw_only_args and not self.starstar_arg:

2287 # unpack optional keyword-only arguments

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

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

2290 optional_args = []

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

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

2293 continue

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

2295 if optional_args:

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

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

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

2299 for i, arg in optional_args:

2300 pystring_cname = code.intern_identifier(arg.name)

2301 code.putln(

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

2303 Naming.kwds_cname, pystring_cname))

2304 code.putln(

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

2306 code.putln('break;')

2307 code.putln('}')

2308

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

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

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

2312 #

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

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

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

2316 # common cases above.

2317 if max_positional_args == 0:

2318 pos_arg_count = "0"

2319 elif self.star_arg:

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

2321 Naming.args_cname, max_positional_args,

2322 Naming.args_cname, max_positional_args))

2323 pos_arg_count = "used_pos_args"

2324 else:

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

2326 code.globalstate.use_utility_code(parse_keywords_utility_code)

2327 code.put(

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

2329 Naming.kwds_cname,

2330 Naming.pykwdlist_cname,

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

2332 pos_arg_count,

2333 self.name))

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

2335 code.putln('}')

2336

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

2338 for i, arg in enumerate(all_args):

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

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

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

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

2343 code.putln('} else {')

2344 code.putln(

2345 "%s = %s;" % (

2346 arg.entry.cname,

2347 arg.calculate_default_value_code(code)))

2348 code.putln('}')

2349

2350 def generate_argument_conversion_code(self, code):

2351 # Generate code to convert arguments from

2352 # signature type to declared type, if needed.

2353 for arg in self.args:

2354 if arg.needs_conversion:

2355 self.generate_arg_conversion(arg, code)

2356

2357 def generate_arg_conversion(self, arg, code):

2358 # Generate conversion code for one argument.

2359 old_type = arg.hdr_type

2360 new_type = arg.type

2361 if old_type.is_pyobject:

2362 if arg.default:

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

2364 else:

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

2366 self.generate_arg_conversion_from_pyobject(arg, code)

2367 code.putln("}")

2368 elif new_type.is_pyobject:

2369 self.generate_arg_conversion_to_pyobject(arg, code)

2370 else:

2371 if new_type.assignable_from(old_type):

2372 code.putln(

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

2374 else:

2375 error(arg.pos,

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

2377 (old_type, new_type))

2378

2379 def generate_arg_conversion_from_pyobject(self, arg, code):

2380 new_type = arg.type

2381 func = new_type.from_py_function

2382 # copied from CoerceFromPyTypeNode

2383 if func:

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

2385 arg.entry.cname,

2386 func,

2387 arg.hdr_cname,

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

2389 else:

2390 error(arg.pos,

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

2392 % new_type)

2393

2394 def generate_arg_conversion_to_pyobject(self, arg, code):

2395 old_type = arg.hdr_type

2396 func = old_type.to_py_function

2397 if func:

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

2399 arg.entry.cname,

2400 func,

2401 arg.hdr_cname,

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

2403 code.put_var_gotref(arg.entry)

2404 else:

2405 error(arg.pos,

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

2407 % old_type)

2408

2409 def generate_argument_type_tests(self, code):

2410 # Generate type tests for args whose signature

2411 # type is PyObject * and whose declared type is

2412 # a subtype thereof.

2413 for arg in self.args:

2414 if arg.needs_type_test:

2415 self.generate_arg_type_test(arg, code)

2416

2417 def generate_arg_type_test(self, arg, code):

2418 # Generate type test for one argument.

2419 if arg.type.typeobj_is_available():

2420 typeptr_cname = arg.type.typeptr_cname

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

2422 code.putln(

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

2424 arg_code,

2425 typeptr_cname,

2426 not arg.not_none,

2427 arg.name,

2428 arg.type.is_builtin_type,

2429 code.error_goto(arg.pos)))

2430 else:

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

2432 "without type object name specification")

2433

2434 def error_value(self):

2435 return self.entry.signature.error_value

2436

2437 def caller_will_check_exceptions(self):

2438 return 1

2439

2440 class OverrideCheckNode(StatNode):

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

2442 # is overriden.

2443 #

2444 # py_func

2445 #

2446 # args

2447 # func_temp

2448 # body

2449

2450 child_attrs = ['body']

2451

2452 body = None

2453

2454 def analyse_expressions(self, env):

2455 self.args = env.arg_entries

2456 if self.py_func.is_module_scope:

2457 first_arg = 0

2458 else:

2459 first_arg = 1

2460 import ExprNodes

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

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

2463 call_node = ExprNodes.SimpleCallNode(self.pos,

2464 function=self.func_node,

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

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

2467 self.body.analyse_expressions(env)

2468

2469 def generate_execution_code(self, code):

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

2471 # Check to see if we are an extension type

2472 if self.py_func.is_module_scope:

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

2474 else:

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

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

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

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

2479 if self.py_func.is_module_scope:

2480 code.putln("else {")

2481 else:

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

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

2484 self.func_node.set_cname(func_node_temp)

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

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

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

2488 func_node_temp, self_arg, interned_attr_cname, err))

2489 code.put_gotref(func_node_temp)

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

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

2492 func_node_temp, self.py_func.entry.func_cname)

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

2494 self.body.generate_execution_code(code)

2495 code.putln("}")

2496 code.put_decref_clear(func_node_temp, PyrexTypes.py_object_type)

2497 code.funcstate.release_temp(func_node_temp)

2498 code.putln("}")

2499

2500 class ClassDefNode(StatNode, BlockNode):

2501 pass

2502

2503 class PyClassDefNode(ClassDefNode):

2504 # A Python class definition.

2505 #

2506 # name EncodedString Name of the class

2507 # doc string or None

2508 # body StatNode Attribute definition code

2509 # entry Symtab.Entry

2510 # scope PyClassScope

2511 # decorators [DecoratorNode] list of decorators or None

2512 #

2513 # The following subnodes are constructed internally:

2514 #

2515 # dict DictNode Class dictionary

2516 # classobj ClassNode Class object

2517 # target NameNode Variable to assign class object to

2518

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

2520 decorators = None

2521

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

2523 StatNode.__init__(self, pos)

2524 self.name = name

2525 self.doc = doc

2526 self.body = body

2527 self.decorators = decorators

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 # FIXME: correct string node?

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

2534 else:

2535 doc_node = None

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

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

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

2539

2540 def as_cclass(self):

2541 """

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

2543 """

2544 bases = self.classobj.bases.args

2545 if len(bases) == 0:

2546 base_class_name = None

2547 base_class_module = None

2548 elif len(bases) == 1:

2549 base = bases[0]

2550 path = []

2551 from ExprNodes import AttributeNode, NameNode

2552 while isinstance(base, AttributeNode):

2553 path.insert(0, base.attribute)

2554 base = base.obj

2555 if isinstance(base, NameNode):

2556 path.insert(0, base.name)

2557 base_class_name = path[-1]

2558 if len(path) > 1:

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

2560 else:

2561 base_class_module = None

2562 else:

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

2564 else:

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

2566 return None

2567

2568 return CClassDefNode(self.pos,

2569 visibility = 'private',

2570 module_name = None,

2571 class_name = self.name,

2572 base_class_module = base_class_module,

2573 base_class_name = base_class_name,

2574 decorators = self.decorators,

2575 body = self.body,

2576 in_pxd = False,

2577 doc = self.doc)

2578

2579 def create_scope(self, env):

2580 genv = env

2581 while env.is_py_class_scope or env.is_c_class_scope:

2582 env = env.outer_scope

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

2584 return cenv

2585

2586 def analyse_declarations(self, env):

2587 self.target.analyse_target_declaration(env)

2588 cenv = self.create_scope(env)

2589 cenv.directives = env.directives

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

2591 self.body.analyse_declarations(cenv)

2592

2593 def analyse_expressions(self, env):

2594 self.dict.analyse_expressions(env)

2595 self.classobj.analyse_expressions(env)

2596 genv = env.global_scope()

2597 cenv = self.scope

2598 self.body.analyse_expressions(cenv)

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

2600

2601 def generate_function_definitions(self, env, code):

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

2603

2604 def generate_execution_code(self, code):

2605 code.pyclass_stack.append(self)

2606 cenv = self.scope

2607 self.dict.generate_evaluation_code(code)

2608 self.classobj.generate_evaluation_code(code)

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

2610 self.body.generate_execution_code(code)

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

2612 self.dict.generate_disposal_code(code)

2613 self.dict.free_temps(code)

2614 code.pyclass_stack.pop()

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 # decorators [DecoratorNode] list of decorators or None

2632 # doc string or None

2633 # body StatNode or None

2634 # entry Symtab.Entry

2635 # base_type PyExtensionType or None

2636 # buffer_defaults_node DictNode or None Declares defaults for a buffer

2637 # buffer_defaults_pos

2638

2639 child_attrs = ["body"]

2640 buffer_defaults_node = None

2641 buffer_defaults_pos = None

2642 typedef_flag = False

2643 api = False

2644 objstruct_name = None

2645 typeobj_name = None

2646 decorators = None

2647

2648 def analyse_declarations(self, env):

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

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

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

2652

2653 import Buffer

2654 if self.buffer_defaults_node:

2655 buffer_defaults = Buffer.analyse_buffer_options(self.buffer_defaults_pos,

2656 env, [], self.buffer_defaults_node,

2657 need_complete=False)

2658 else:

2659 buffer_defaults = None

2660

2661 if env.in_cinclude and not self.objstruct_name:

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

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

2664 self.base_type = None

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

2666 # import the modules for extern classes.

2667 if self.module_name:

2668 self.module = None

2669 for module in env.cimported_modules:

2670 if module.name == self.module_name:

2671 self.module = module

2672 if self.module is None:

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

2674 self.module.has_extern_class = 1

2675 env.add_imported_module(self.module)

2676

2677 if self.base_class_name:

2678 if self.base_class_module:

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

2680 else:

2681 base_class_scope = env

2682 if self.base_class_name == 'object':

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

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

2685 self.base_class_name = None

2686 self.base_class_module = None

2687 base_class_scope = None

2688 if base_class_scope:

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

2690 if base_class_entry:

2691 if not base_class_entry.is_type:

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

2693 elif not base_class_entry.type.is_extension_type:

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

2695 elif not base_class_entry.type.is_complete():

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

2697 else:

2698 self.base_type = base_class_entry.type

2699 has_body = self.body is not None

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

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

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

2703 if not home_scope:

2704 return

2705 else:

2706 home_scope = env

2707

2708 if self.visibility == 'extern':

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

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

2711

2712 self.entry = home_scope.declare_c_class(

2713 name = self.class_name,

2714 pos = self.pos,

2715 defining = has_body and self.in_pxd,

2716 implementing = has_body and not self.in_pxd,

2717 module_name = self.module_name,

2718 base_type = self.base_type,

2719 objstruct_cname = self.objstruct_name,

2720 typeobj_cname = self.typeobj_name,

2721 visibility = self.visibility,

2722 typedef_flag = self.typedef_flag,

2723 api = self.api,

2724 buffer_defaults = buffer_defaults)

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

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

2727 scope = self.entry.type.scope

2728 if scope is not None:

2729 scope.directives = env.directives

2730

2731 if self.doc and Options.docstrings:

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

2733

2734 if has_body:

2735 self.body.analyse_declarations(scope)

2736 if self.in_pxd:

2737 scope.defined = 1

2738 else:

2739 scope.implemented = 1

2740 env.allocate_vtable_names(self.entry)

2741

2742 def analyse_expressions(self, env):

2743 if self.body:

2744 scope = self.entry.type.scope

2745 self.body.analyse_expressions(scope)

2746

2747 def generate_function_definitions(self, env, code):

2748 if self.body:

2749 self.body.generate_function_definitions(

2750 self.entry.type.scope, code)

2751

2752 def generate_execution_code(self, code):

2753 # This is needed to generate evaluation code for

2754 # default values of method arguments.

2755 if self.body:

2756 self.body.generate_execution_code(code)

2757

2758 def annotate(self, code):

2759 if self.body:

2760 self.body.annotate(code)

2761

2762

2763 class PropertyNode(StatNode):

2764 # Definition of a property in an extension type.

2765 #

2766 # name string

2767 # doc EncodedString or None Doc string

2768 # body StatListNode

2769

2770 child_attrs = ["body"]

2771

2772 def analyse_declarations(self, env):

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

2774 if entry:

2775 entry.scope.directives = env.directives

2776 self.body.analyse_declarations(entry.scope)

2777

2778 def analyse_expressions(self, env):

2779 self.body.analyse_expressions(env)

2780

2781 def generate_function_definitions(self, env, code):

2782 self.body.generate_function_definitions(env, code)

2783

2784 def generate_execution_code(self, code):

2785 pass

2786

2787 def annotate(self, code):

2788 self.body.annotate(code)

2789

2790

2791 class GlobalNode(StatNode):

2792 # Global variable declaration.

2793 #

2794 # names [string]

2795

2796 child_attrs = []

2797

2798 def analyse_declarations(self, env):

2799 for name in self.names:

2800 env.declare_global(name, self.pos)

2801

2802 def analyse_expressions(self, env):

2803 pass

2804

2805 def generate_execution_code(self, code):

2806 pass

2807

2808

2809 class ExprStatNode(StatNode):

2810 # Expression used as a statement.

2811 #

2812 # expr ExprNode

2813

2814 child_attrs = ["expr"]

2815

2816 def analyse_declarations(self, env):

2817 import ExprNodes

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

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

2820 if func == u'declare':

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

2822 if len(args):

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

2824 for var, type_node in kwds.key_value_pairs:

2825 type = type_node.analyse_as_type(env)

2826 if type is None:

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

2828 else:

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

2830 self.__class__ = PassStatNode

2831

2832 def analyse_expressions(self, env):

2833 self.expr.analyse_expressions(env)

2834

2835 def generate_execution_code(self, code):

2836 self.expr.generate_evaluation_code(code)

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

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

2839 self.expr.generate_disposal_code(code)

2840 self.expr.free_temps(code)

2841

2842 def annotate(self, code):

2843 self.expr.annotate(code)

2844

2845

2846 class AssignmentNode(StatNode):

2847 # Abstract base class for assignment nodes.

2848 #

2849 # The analyse_expressions and generate_execution_code

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

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

2852 # parallel assignment to be evaluated before assigning

2853 # to any of the left hand sides.

2854

2855 def analyse_expressions(self, env):

2856 self.analyse_types(env)

2857

2858 # def analyse_expressions(self, env):

2859 # self.analyse_expressions_1(env)

2860 # self.analyse_expressions_2(env)

2861

2862 def generate_execution_code(self, code):

2863 self.generate_rhs_evaluation_code(code)

2864 self.generate_assignment_code(code)

2865

2866

2867 class SingleAssignmentNode(AssignmentNode):

2868 # The simplest case:

2869 #

2870 # a = b

2871 #

2872 # lhs ExprNode Left hand side

2873 # rhs ExprNode Right hand side

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

2875

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

2877 first = False

2878 declaration_only = False

2879

2880 def analyse_declarations(self, env):

2881 import ExprNodes

2882

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

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

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

2886 if func_name:

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

2888

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

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

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

2892 return

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

2894 if type is None:

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

2896 return

2897 lhs = self.lhs

2898 if func_name == 'declare':

2899 if isinstance(lhs, ExprNodes.NameNode):

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

2901 elif isinstance(lhs, ExprNodes.TupleNode):

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

2903 else:

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

2905 return

2906 for var, pos in vars:

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

2908 if len(args) == 2:

2909 # we have a value

2910 self.rhs = args[1]

2911 else:

2912 self.declaration_only = True

2913 else:

2914 self.declaration_only = True

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

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

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

2918

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

2920 self.declaration_only = True

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

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

2923 return

2924 members = []

2925 for member, type_node in kwds.key_value_pairs:

2926 type = type_node.analyse_as_type(env)

2927 if type is None:

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

2929 else:

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

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

2932 return

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

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

2935 name = self.lhs.name

2936 scope = StructOrUnionScope(name)

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

2938 for member, type, pos in members:

2939 scope.declare_var(member, type, pos)

2940

2941 if self.declaration_only:

2942 return

2943 else:

2944 self.lhs.analyse_target_declaration(env)

2945

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

2947 self.rhs.analyse_types(env)

2948 self.lhs.analyse_target_types(env)

2949 self.lhs.gil_assignment_check(env)

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

2951 if use_temp:

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

2953

2954 def generate_rhs_evaluation_code(self, code):

2955 self.rhs.generate_evaluation_code(code)

2956

2957 def generate_assignment_code(self, code):

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

2959

2960 def annotate(self, code):

2961 self.lhs.annotate(code)

2962 self.rhs.annotate(code)

2963

2964

2965 class CascadedAssignmentNode(AssignmentNode):

2966 # An assignment with multiple left hand sides:

2967 #

2968 # a = b = c

2969 #

2970 # lhs_list [ExprNode] Left hand sides

2971 # rhs ExprNode Right hand sides

2972 #

2973 # Used internally:

2974 #

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

2976

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

2978 coerced_rhs_list = None

2979

2980 def analyse_declarations(self, env):

2981 for lhs in self.lhs_list:

2982 lhs.analyse_target_declaration(env)

2983

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

2985 self.rhs.analyse_types(env)

2986 if use_temp:

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

2988 else:

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

2990 from ExprNodes import CloneNode

2991 self.coerced_rhs_list = []

2992 for lhs in self.lhs_list:

2993 lhs.analyse_target_types(env)

2994 lhs.gil_assignment_check(env)

2995 rhs = CloneNode(self.rhs)

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

2997 self.coerced_rhs_list.append(rhs)

2998

2999 def generate_rhs_evaluation_code(self, code):

3000 self.rhs.generate_evaluation_code(code)

3001

3002 def generate_assignment_code(self, code):

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

3004 lhs = self.lhs_list[i]

3005 rhs = self.coerced_rhs_list[i]

3006 rhs.generate_evaluation_code(code)

3007 lhs.generate_assignment_code(rhs, code)

3008 # Assignment has disposed of the cloned RHS

3009 self.rhs.generate_disposal_code(code)

3010 self.rhs.free_temps(code)

3011

3012 def annotate(self, code):

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

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

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

3016 self.rhs.annotate(code)

3017

3018

3019 class ParallelAssignmentNode(AssignmentNode):

3020 # A combined packing/unpacking assignment:

3021 #

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

3023 #

3024 # This has been rearranged by the parser into

3025 #

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

3027 #

3028 # but we must evaluate all the right hand sides

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

3030 #

3031 # stats [AssignmentNode] The constituent assignments

3032

3033 child_attrs = ["stats"]

3034

3035 def analyse_declarations(self, env):

3036 for stat in self.stats:

3037 stat.analyse_declarations(env)

3038

3039 def analyse_expressions(self, env):

3040 for stat in self.stats:

3041 stat.analyse_types(env, use_temp = 1)

3042

3043 # def analyse_expressions(self, env):

3044 # for stat in self.stats:

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

3046 # for stat in self.stats:

3047 # stat.analyse_expressions_2(env)

3048

3049 def generate_execution_code(self, code):

3050 for stat in self.stats:

3051 stat.generate_rhs_evaluation_code(code)

3052 for stat in self.stats:

3053 stat.generate_assignment_code(code)

3054

3055 def annotate(self, code):

3056 for stat in self.stats:

3057 stat.annotate(code)

3058

3059

3060 class InPlaceAssignmentNode(AssignmentNode):

3061 # An in place arithmatic operand:

3062 #

3063 # a += b

3064 # a -= b

3065 # ...

3066 #

3067 # lhs ExprNode Left hand side

3068 # rhs ExprNode Right hand side

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

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

3071 #

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

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

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

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

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

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

3078

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

3080 dup = None

3081

3082 def analyse_declarations(self, env):

3083 self.lhs.analyse_target_declaration(env)

3084

3085 def analyse_types(self, env):

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

3087 self.rhs.analyse_types(env)

3088 self.lhs.analyse_target_types(env)

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

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

3091 import ExprNodes

3092 if self.lhs.type.is_pyobject:

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

3094 elif self.rhs.type.is_pyobject:

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

3096 if self.lhs.type.is_pyobject:

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

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

3099

3100 def generate_execution_code(self, code):

3101 import ExprNodes

3102 self.rhs.generate_evaluation_code(code)

3103 self.dup.generate_subexpr_evaluation_code(code)

3104 if self.dup.is_temp:

3105 self.dup.allocate_temp_result(code)

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

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

3108 extra = ", Py_None"

3109 else:

3110 extra = ""

3111 if self.lhs.type.is_pyobject:

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

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

3114 self.dup.generate_result_code(code)

3115 self.result_value_temp.allocate(code)

3116 code.putln(

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

3118 self.result_value.result(),

3119 self.py_operation_function(),

3120 self.dup.py_result(),

3121 self.rhs.py_result(),

3122 extra,

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

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

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

3126 self.rhs.generate_disposal_code(code)

3127 self.rhs.free_temps(code)

3128 self.dup.generate_disposal_code(code)

3129 self.dup.free_temps(code)

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

3131 self.result_value_temp.release(code)

3132 else:

3133 c_op = self.operator

3134 if c_op == "//":

3135 c_op = "/"

3136 elif c_op == "**":

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

3138 elif self.lhs.type.is_complex:

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

3140

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

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

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

3144 else:

3145 self.dup.generate_result_code(code)

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

3147 self.rhs.generate_disposal_code(code)

3148 self.rhs.free_temps(code)

3149 if self.dup.is_temp:

3150 self.dup.generate_subexpr_disposal_code(code)

3151 self.dup.free_subexpr_temps(code)

3152

3153 def create_dup_node(self, env):

3154 import ExprNodes

3155 self.dup = self.lhs

3156 self.dup.analyse_types(env)

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

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

3159 name = self.dup.name,

3160 is_temp = self.dup.is_temp,

3161 entry = self.dup.entry)

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

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

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

3165 attribute = self.dup.attribute,

3166 is_temp = self.dup.is_temp)

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

3168 if self.lhs.index:

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

3170 else:

3171 index = None

3172 if self.lhs.indices:

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

3174 else:

3175 indices = []

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

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

3178 index = index,

3179 indices = indices,

3180 is_temp = self.dup.is_temp)

3181 else:

3182 assert False

3183 self.lhs = target_lhs

3184 return self.dup

3185

3186 def py_operation_function(self):

3187 return self.py_functions[self.operator]

3188

3189 py_functions = {

3190 "|": "PyNumber_InPlaceOr",

3191 "^": "PyNumber_InPlaceXor",

3192 "&": "PyNumber_InPlaceAnd",

3193 "+": "PyNumber_InPlaceAdd",

3194 "-": "PyNumber_InPlaceSubtract",

3195 "*": "PyNumber_InPlaceMultiply",

3196 "/": "PyNumber_InPlaceDivide",

3197 "%": "PyNumber_InPlaceRemainder",

3198 "<<": "PyNumber_InPlaceLshift",

3199 ">>": "PyNumber_InPlaceRshift",

3200 "**": "PyNumber_InPlacePower",

3201 "//": "PyNumber_InPlaceFloorDivide",

3202 }

3203

3204 def annotate(self, code):

3205 self.lhs.annotate(code)

3206 self.rhs.annotate(code)

3207 self.dup.annotate(code)

3208

3209 def create_binop_node(self):

3210 import ExprNodes

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

3212

3213

3214 class PrintStatNode(StatNode):

3215 # print statement

3216 #

3217 # arg_tuple TupleNode

3218 # append_newline boolean

3219

3220 child_attrs = ["arg_tuple"]

3221

3222 def analyse_expressions(self, env):

3223 self.arg_tuple.analyse_expressions(env)

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

3225 env.use_utility_code(printing_utility_code)

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

3227 env.use_utility_code(printing_one_utility_code)

3228

3229 nogil_check = Node.gil_error

3230 gil_message = "Python print statement"

3231

3232 def generate_execution_code(self, code):

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

3234 arg = self.arg_tuple.args[0]

3235 arg.generate_evaluation_code(code)

3236

3237 code.putln(

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

3239 arg.py_result(),

3240 code.error_goto(self.pos)))

3241 arg.generate_disposal_code(code)

3242 arg.free_temps(code)

3243 else:

3244 self.arg_tuple.generate_evaluation_code(code)

3245 code.putln(

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

3247 self.arg_tuple.py_result(),

3248 self.append_newline,

3249 code.error_goto(self.pos)))

3250 self.arg_tuple.generate_disposal_code(code)

3251 self.arg_tuple.free_temps(code)

3252

3253 def annotate(self, code):

3254 self.arg_tuple.annotate(code)

3255

3256

3257 class ExecStatNode(StatNode):

3258 # exec statement

3259 #

3260 # args [ExprNode]

3261

3262 child_attrs = ["args"]

3263

3264 def analyse_expressions(self, env):

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

3266 arg.analyse_expressions(env)

3267 arg = arg.coerce_to_pyobject(env)

3268 self.args[i] = arg

3269 env.use_utility_code(Builtin.pyexec_utility_code)

3270

3271 nogil_check = Node.gil_error

3272 gil_message = "Python exec statement"

3273

3274 def generate_execution_code(self, code):

3275 args = []

3276 for arg in self.args:

3277 arg.generate_evaluation_code(code)

3278 args.append( arg.py_result() )

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

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

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

3282 (temp_result,) + args))

3283 for arg in self.args:

3284 arg.generate_disposal_code(code)

3285 arg.free_temps(code)

3286 code.putln(

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

3288 code.put_gotref(temp_result)

3289 code.put_decref_clear(temp_result, py_object_type)

3290 code.funcstate.release_temp(temp_result)

3291

3292 def annotate(self, code):

3293 for arg in self.args:

3294 arg.annotate(code)

3295

3296

3297 class DelStatNode(StatNode):

3298 # del statement

3299 #

3300 # args [ExprNode]

3301

3302 child_attrs = ["args"]

3303

3304 def analyse_declarations(self, env):

3305 for arg in self.args:

3306 arg.analyse_target_declaration(env)

3307

3308 def analyse_expressions(self, env):

3309 for arg in self.args:

3310 arg.analyse_target_expression(env, None)

3311 if not arg.type.is_pyobject:

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

3313 #arg.release_target_temp(env)

3314

3315 def nogil_check(self, env):

3316 for arg in self.args:

3317 if arg.type.is_pyobject:

3318 self.gil_error()

3319

3320 gil_message = "Deleting Python object"

3321

3322 def generate_execution_code(self, code):

3323 for arg in self.args:

3324 if arg.type.is_pyobject:

3325 arg.generate_deletion_code(code)

3326 # else error reported earlier

3327

3328 def annotate(self, code):

3329 for arg in self.args:

3330 arg.annotate(code)

3331

3332

3333 class PassStatNode(StatNode):

3334 # pass statement

3335

3336 child_attrs = []

3337

3338 def analyse_expressions(self, env):

3339 pass

3340

3341 def generate_execution_code(self, code):

3342 pass

3343

3344

3345 class BreakStatNode(StatNode):

3346

3347 child_attrs = []

3348

3349 def analyse_expressions(self, env):

3350 pass

3351

3352 def generate_execution_code(self, code):

3353 if not code.break_label:

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

3355 else:

3356 code.put_goto(code.break_label)

3357

3358

3359 class ContinueStatNode(StatNode):

3360

3361 child_attrs = []

3362

3363 def analyse_expressions(self, env):

3364 pass

3365

3366 def generate_execution_code(self, code):

3367 if code.funcstate.in_try_finally:

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

3369 elif not code.continue_label:

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

3371 else:

3372 code.put_goto(code.continue_label)

3373

3374

3375 class ReturnStatNode(StatNode):

3376 # return statement

3377 #

3378 # value ExprNode or None

3379 # return_type PyrexType

3380

3381 child_attrs = ["value"]

3382

3383 def analyse_expressions(self, env):

3384 return_type = env.return_type

3385 self.return_type = return_type

3386 if not return_type:

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

3388 return

3389 if self.value:

3390 self.value.analyse_types(env)

3391 if return_type.is_void or return_type.is_returncode:

3392 error(self.value.pos,

3393 "Return with value in void function")

3394 else:

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

3396 else:

3397 if (not return_type.is_void

3398 and not return_type.is_pyobject

3399 and not return_type.is_returncode):

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

3401

3402 def nogil_check(self, env):

3403 if self.return_type.is_pyobject:

3404 self.gil_error()

3405

3406 gil_message = "Returning Python object"

3407

3408 def generate_execution_code(self, code):

3409 code.mark_pos(self.pos)

3410 if not self.return_type:

3411 # error reported earlier

3412 return

3413 if self.return_type.is_pyobject:

3414 code.put_xdecref(Naming.retval_cname,

3415 self.return_type)

3416 if self.value:

3417 self.value.generate_evaluation_code(code)

3418 self.value.make_owned_reference(code)

3419 code.putln(

3420 "%s = %s;" % (

3421 Naming.retval_cname,

3422 self.value.result_as(self.return_type)))

3423 self.value.generate_post_assignment_code(code)

3424 self.value.free_temps(code)

3425 else:

3426 if self.return_type.is_pyobject:

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

3428 elif self.return_type.is_returncode:

3429 code.putln(

3430 "%s = %s;" % (

3431 Naming.retval_cname,

3432 self.return_type.default_value))

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

3434 code.put_decref_clear(cname, type)

3435 code.put_goto(code.return_label)

3436

3437 def annotate(self, code):

3438 if self.value:

3439 self.value.annotate(code)

3440

3441

3442 class RaiseStatNode(StatNode):

3443 # raise statement

3444 #

3445 # exc_type ExprNode or None

3446 # exc_value ExprNode or None

3447 # exc_tb ExprNode or None

3448

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

3450

3451 def analyse_expressions(self, env):

3452 if self.exc_type:

3453 self.exc_type.analyse_types(env)

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

3455 if self.exc_value:

3456 self.exc_value.analyse_types(env)

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

3458 if self.exc_tb:

3459 self.exc_tb.analyse_types(env)

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

3461 env.use_utility_code(raise_utility_code)

3462 env.use_utility_code(restore_exception_utility_code)

3463

3464 nogil_check = Node.gil_error

3465 gil_message = "Raising exception"

3466

3467 def generate_execution_code(self, code):

3468 if self.exc_type:

3469 self.exc_type.generate_evaluation_code(code)

3470 type_code = self.exc_type.py_result()

3471 else:

3472 type_code = "0"

3473 if self.exc_value:

3474 self.exc_value.generate_evaluation_code(code)

3475 value_code = self.exc_value.py_result()

3476 else:

3477 value_code = "0"

3478 if self.exc_tb:

3479 self.exc_tb.generate_evaluation_code(code)

3480 tb_code = self.exc_tb.py_result()

3481 else:

3482 tb_code = "0"

3483 code.putln(

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

3485 type_code,

3486 value_code,

3487 tb_code))

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

3489 if obj:

3490 obj.generate_disposal_code(code)

3491 obj.free_temps(code)

3492 code.putln(

3493 code.error_goto(self.pos))

3494

3495 def annotate(self, code):

3496 if self.exc_type:

3497 self.exc_type.annotate(code)

3498 if self.exc_value:

3499 self.exc_value.annotate(code)

3500 if self.exc_tb:

3501 self.exc_tb.annotate(code)

3502

3503

3504 class ReraiseStatNode(StatNode):

3505

3506 child_attrs = []

3507

3508 def analyse_expressions(self, env):

3509 env.use_utility_code(raise_utility_code)

3510 env.use_utility_code(restore_exception_utility_code)

3511

3512 nogil_check = Node.gil_error

3513 gil_message = "Raising exception"

3514

3515 def generate_execution_code(self, code):

3516 vars = code.funcstate.exc_vars

3517 if vars:

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

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

3520 else:

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

3522

3523

3524 class AssertStatNode(StatNode):

3525 # assert statement

3526 #

3527 # cond ExprNode

3528 # value ExprNode or None

3529

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

3531

3532 def analyse_expressions(self, env):

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

3534 if self.value:

3535 self.value.analyse_types(env)

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

3537

3538 nogil_check = Node.gil_error

3539 gil_message = "Raising exception"

3540

3541 def generate_execution_code(self, code):

3542 code.putln("#ifndef PYREX_WITHOUT_ASSERTIONS")

3543 self.cond.generate_evaluation_code(code)

3544 code.putln(

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

3546 self.cond.result())

3547 if self.value:

3548 self.value.generate_evaluation_code(code)

3549 code.putln(

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

3551 self.value.py_result())

3552 self.value.generate_disposal_code(code)

3553 self.value.free_temps(code)

3554 else:

3555 code.putln(

3556 "PyErr_SetNone(PyExc_AssertionError);")

3557 code.putln(

3558 code.error_goto(self.pos))

3559 code.putln(

3560 "}")

3561 self.cond.generate_disposal_code(code)

3562 self.cond.free_temps(code)

3563 code.putln("#endif")

3564

3565 def annotate(self, code):

3566 self.cond.annotate(code)

3567 if self.value:

3568 self.value.annotate(code)

3569

3570

3571 class IfStatNode(StatNode):

3572 # if statement

3573 #

3574 # if_clauses [IfClauseNode]

3575 # else_clause StatNode or None

3576

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

3578

3579 def analyse_control_flow(self, env):

3580 env.start_branching(self.pos)

3581 for if_clause in self.if_clauses:

3582 if_clause.analyse_control_flow(env)

3583 env.next_branch(if_clause.end_pos())

3584 if self.else_clause:

3585 self.else_clause.analyse_control_flow(env)

3586 env.finish_branching(self.end_pos())

3587

3588 def analyse_declarations(self, env):

3589 for if_clause in self.if_clauses:

3590 if_clause.analyse_declarations(env)

3591 if self.else_clause:

3592 self.else_clause.analyse_declarations(env)

3593

3594 def analyse_expressions(self, env):

3595 for if_clause in self.if_clauses:

3596 if_clause.analyse_expressions(env)

3597 if self.else_clause:

3598 self.else_clause.analyse_expressions(env)

3599

3600 def generate_execution_code(self, code):

3601 code.mark_pos(self.pos)

3602 end_label = code.new_label()

3603 for if_clause in self.if_clauses:

3604 if_clause.generate_execution_code(code, end_label)

3605 if self.else_clause:

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

3607 self.else_clause.generate_execution_code(code)

3608 code.putln("}")

3609 code.put_label(end_label)

3610

3611 def annotate(self, code):

3612 for if_clause in self.if_clauses:

3613 if_clause.annotate(code)

3614 if self.else_clause:

3615 self.else_clause.annotate(code)

3616

3617

3618 class IfClauseNode(Node):

3619 # if or elif clause in an if statement

3620 #

3621 # condition ExprNode

3622 # body StatNode

3623

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

3625

3626 def analyse_control_flow(self, env):

3627 self.body.analyse_control_flow(env)

3628

3629 def analyse_declarations(self, env):

3630 self.condition.analyse_declarations(env)

3631 self.body.analyse_declarations(env)

3632

3633 def analyse_expressions(self, env):

3634 self.condition = \

3635 self.condition.analyse_temp_boolean_expression(env)

3636 self.body.analyse_expressions(env)

3637

3638 def generate_execution_code(self, code, end_label):

3639 self.condition.generate_evaluation_code(code)

3640 code.putln(

3641 "if (%s) {" %

3642 self.condition.result())

3643 self.condition.generate_disposal_code(code)

3644 self.condition.free_temps(code)

3645 self.body.generate_execution_code(code)

3646 #code.putln(

3647 # "goto %s;" %

3648 # end_label)

3649 code.put_goto(end_label)

3650 code.putln("}")

3651

3652 def annotate(self, code):

3653 self.condition.annotate(code)

3654 self.body.annotate(code)

3655

3656

3657 class SwitchCaseNode(StatNode):

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

3659 #

3660 # conditions [ExprNode]

3661 # body StatNode

3662

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

3664

3665 def generate_execution_code(self, code):

3666 for cond in self.conditions:

3667 code.mark_pos(cond.pos)

3668 cond.generate_evaluation_code(code)

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

3670 self.body.generate_execution_code(code)

3671 code.putln("break;")

3672

3673 def annotate(self, code):

3674 for cond in self.conditions:

3675 cond.annotate(code)

3676 self.body.annotate(code)

3677

3678 class SwitchStatNode(StatNode):

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

3680 #

3681 # test ExprNode

3682 # cases [SwitchCaseNode]

3683 # else_clause StatNode or None

3684

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

3686

3687 def generate_execution_code(self, code):

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

3689 for case in self.cases:

3690 case.generate_execution_code(code)

3691 if self.else_clause is not None:

3692 code.putln("default:")

3693 self.else_clause.generate_execution_code(code)

3694 code.putln("break;")

3695 code.putln("}")

3696

3697 def annotate(self, code):

3698 self.test.annotate(code)

3699 for case in self.cases:

3700 case.annotate(code)

3701 if self.else_clause is not None:

3702 self.else_clause.annotate(code)

3703

3704 class LoopNode(object):

3705

3706 def analyse_control_flow(self, env):

3707 env.start_branching(self.pos)

3708 self.body.analyse_control_flow(env)

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

3710 if self.else_clause:

3711 self.else_clause.analyse_control_flow(env)

3712 env.finish_branching(self.end_pos())

3713

3714

3715 class WhileStatNode(LoopNode, StatNode):

3716 # while statement

3717 #

3718 # condition ExprNode

3719 # body StatNode

3720 # else_clause StatNode

3721

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

3723

3724 def analyse_declarations(self, env):

3725 self.body.analyse_declarations(env)

3726 if self.else_clause:

3727 self.else_clause.analyse_declarations(env)

3728

3729 def analyse_expressions(self, env):

3730 self.condition = \

3731 self.condition.analyse_temp_boolean_expression(env)

3732 self.body.analyse_expressions(env)

3733 if self.else_clause:

3734 self.else_clause.analyse_expressions(env)

3735

3736 def generate_execution_code(self, code):

3737 old_loop_labels = code.new_loop_labels()

3738 code.putln(

3739 "while (1) {")

3740 self.condition.generate_evaluation_code(code)

3741 self.condition.generate_disposal_code(code)

3742 code.putln(

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

3744 self.condition.result())

3745 self.condition.free_temps(code)

3746 self.body.generate_execution_code(code)

3747 code.put_label(code.continue_label)

3748 code.putln("}")

3749 break_label = code.break_label

3750 code.set_loop_labels(old_loop_labels)

3751 if self.else_clause:

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

3753 self.else_clause.generate_execution_code(code)

3754 code.putln("}")

3755 code.put_label(break_label)

3756

3757 def annotate(self, code):

3758 self.condition.annotate(code)

3759 self.body.annotate(code)

3760 if self.else_clause:

3761 self.else_clause.annotate(code)

3762

3763

3764 def ForStatNode(pos, **kw):

3765 if 'iterator' in kw:

3766 return ForInStatNode(pos, **kw)

3767 else:

3768 return ForFromStatNode(pos, **kw)

3769

3770 class ForInStatNode(LoopNode, StatNode):

3771 # for statement

3772 #

3773 # target ExprNode

3774 # iterator IteratorNode

3775 # body StatNode

3776 # else_clause StatNode

3777 # item NextNode used internally

3778

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

3780 item = None

3781

3782 def analyse_declarations(self, env):

3783 self.target.analyse_target_declaration(env)

3784 self.body.analyse_declarations(env)

3785 if self.else_clause:

3786 self.else_clause.analyse_declarations(env)

3787

3788 def analyse_expressions(self, env):

3789 import ExprNodes

3790 self.target.analyse_target_types(env)

3791 self.iterator.analyse_expressions(env)

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

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

3794 self.body.analyse_expressions(env)

3795 if self.else_clause:

3796 self.else_clause.analyse_expressions(env)

3797

3798 def generate_execution_code(self, code):

3799 old_loop_labels = code.new_loop_labels()

3800 self.iterator.allocate_counter_temp(code)

3801 self.iterator.generate_evaluation_code(code)

3802 code.putln(

3803 "for (;;) {")

3804 self.item.generate_evaluation_code(code)

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

3806 self.body.generate_execution_code(code)

3807 code.put_label(code.continue_label)

3808 code.putln(

3809 "}")

3810 break_label = code.break_label

3811 code.set_loop_labels(old_loop_labels)

3812 if self.else_clause:

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

3814 self.else_clause.generate_execution_code(code)

3815 code.putln("}")

3816 code.put_label(break_label)

3817 self.iterator.release_counter_temp(code)

3818 self.iterator.generate_disposal_code(code)

3819 self.iterator.free_temps(code)

3820

3821 def annotate(self, code):

3822 self.target.annotate(code)

3823 self.iterator.annotate(code)

3824 self.body.annotate(code)

3825 if self.else_clause:

3826 self.else_clause.annotate(code)

3827 self.item.annotate(code)

3828

3829

3830 class ForFromStatNode(LoopNode, StatNode):

3831 # for name from expr rel name rel expr

3832 #

3833 # target NameNode

3834 # bound1 ExprNode

3835 # relation1 string

3836 # relation2 string

3837 # bound2 ExprNode

3838 # step ExprNode or None

3839 # body StatNode

3840 # else_clause StatNode or None

3841 #

3842 # Used internally:

3843 #

3844 # from_range bool

3845 # is_py_target bool

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

3847 # py_loopvar_node PyTempNode or None

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

3849

3850 is_py_target = False

3851 loopvar_node = None

3852 py_loopvar_node = None

3853 from_range = False

3854

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

3856

3857 def nogil_check(self, env):

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

3859 if x.type.is_pyobject:

3860 self.gil_error()

3861

3862 def analyse_declarations(self, env):

3863 self.target.analyse_target_declaration(env)

3864 self.body.analyse_declarations(env)

3865 if self.else_clause:

3866 self.else_clause.analyse_declarations(env)

3867

3868 def analyse_expressions(self, env):

3869 import ExprNodes

3870 self.target.analyse_target_types(env)

3871 self.bound1.analyse_types(env)

3872 self.bound2.analyse_types(env)

3873 if self.step is not None:

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

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

3876 self.step.analyse_types(env)

3877

3878 target_type = self.target.type

3879 if self.target.type.is_numeric:

3880 loop_type = self.target.type

3881 else:

3882 loop_type = PyrexTypes.c_int_type

3883 if not self.bound1.type.is_pyobject:

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

3885 if not self.bound2.type.is_pyobject:

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

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

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

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

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

3891 if not self.bound2.is_literal:

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

3893 if self.step is not None:

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

3895 if not self.step.is_literal:

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

3897

3898 target_type = self.target.type

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

3900 error(self.target.pos,

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

3902 if target_type.is_numeric:

3903 self.is_py_target = False

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

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

3906 self.loopvar_node = self.target

3907 self.py_loopvar_node = None

3908 else:

3909 self.is_py_target = True

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

3911 self.loopvar_node = c_loopvar_node

3912 self.py_loopvar_node = \

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

3914 self.body.analyse_expressions(env)

3915 if self.else_clause:

3916 self.else_clause.analyse_expressions(env)

3917

3918 def generate_execution_code(self, code):

3919 old_loop_labels = code.new_loop_labels()

3920 from_range = self.from_range

3921 self.bound1.generate_evaluation_code(code)

3922 self.bound2.generate_evaluation_code(code)

3923 offset, incop = self.relation_table[self.relation1]

3924 if self.step is not None:

3925 self.step.generate_evaluation_code(code)

3926 step = self.step.result()

3927 incop = "%s=%s" % (incop[0], step)

3928 import ExprNodes

3929 if isinstance(self.loopvar_node, ExprNodes.TempNode):

3930 self.loopvar_node.allocate(code)

3931 if isinstance(self.py_loopvar_node, ExprNodes.TempNode):

3932 self.py_loopvar_node.allocate(code)

3933 if from_range:

3934 loopvar_name = code.funcstate.allocate_temp(self.target.type, False)

3935 else:

3936 loopvar_name = self.loopvar_node.result()

3937 code.putln(

3938 "for (%s = %s%s; %s %s %s; %s%s) {" % (

3939 loopvar_name,

3940 self.bound1.result(), offset,

3941 loopvar_name, self.relation2, self.bound2.result(),

3942 loopvar_name, incop))

3943 if self.py_loopvar_node:

3944 self.py_loopvar_node.generate_evaluation_code(code)

3945 self.target.generate_assignment_code(self.py_loopvar_node, code)

3946 elif from_range:

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

3948 self.target.result(), loopvar_name))

3949 self.body.generate_execution_code(code)

3950 code.put_label(code.continue_label)

3951 if self.py_loopvar_node:

3952 # This mess is to make for..from loops with python targets behave

3953 # exactly like those with C targets with regards to re-assignment

3954 # of the loop variable.

3955 import ExprNodes

3956 if self.target.entry.is_pyglobal:

3957 # We know target is a NameNode, this is the only ugly case.

3958 target_node = ExprNodes.PyTempNode(self.target.pos, None)

3959 target_node.allocate(code)

3960 interned_cname = code.intern_identifier(self.target.entry.name)

3961 code.putln("/*here*/")

3962 code.putln("%s = __Pyx_GetName(%s, %s); %s" % (

3963 target_node.result(),

3964 Naming.module_cname,

3965 interned_cname,

3966 code.error_goto_if_null(target_node.result(), self.target.pos)))

3967 code.put_gotref(target_node.result())

3968 else:

3969 target_node = self.target

3970 from_py_node = ExprNodes.CoerceFromPyTypeNode(self.loopvar_node.type, target_node, None)

3971 from_py_node.temp_code = loopvar_name

3972 from_py_node.generate_result_code(code)