?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge Chromium + Blink git repositories
[chromium-blink-merge.git] / third_party / cython / src / Cython / Compiler / Nodes.py
blobd88b0059dd1d39c16c40d779d0cd6f720ebb21fd
1 #
2 # Parse tree nodes
3 #
4
5 import cython
6 cython.declare(sys=object, os=object, copy=object,
7 Builtin=object, error=object, warning=object, Naming=object, PyrexTypes=object,
8 py_object_type=object, ModuleScope=object, LocalScope=object, ClosureScope=object,
9 StructOrUnionScope=object, PyClassScope=object,
10 CppClassScope=object, UtilityCode=object, EncodedString=object,
11 absolute_path_length=cython.Py_ssize_t)
12
13 import sys, os, copy
14 from itertools import chain
15
16 import Builtin
17 from Errors import error, warning, InternalError, CompileError
18 import Naming
19 import PyrexTypes
20 import TypeSlots
21 from PyrexTypes import py_object_type, error_type
22 from Symtab import (ModuleScope, LocalScope, ClosureScope,
23 StructOrUnionScope, PyClassScope, CppClassScope, TemplateScope)
24 from Code import UtilityCode
25 from StringEncoding import EncodedString, escape_byte_string, split_string_literal
26 import Options
27 import DebugFlags
28 from Cython.Utils import cached_function
29
30 absolute_path_length = 0
31
32 def relative_position(pos):
33 """
34 We embed the relative filename in the generated C file, since we
35 don't want to have to regenerate and compile all the source code
36 whenever the Python install directory moves (which could happen,
37 e.g,. when distributing binaries.)
38
39 INPUT:
40 a position tuple -- (absolute filename, line number column position)
41
42 OUTPUT:
43 relative filename
44 line number
45
46 AUTHOR: William Stein
47 """
48 global absolute_path_length
49 if absolute_path_length==0:
50 absolute_path_length = len(os.path.abspath(os.getcwd()))
51 return (pos[0].get_filenametable_entry()[absolute_path_length+1:], pos[1])
52
53 def embed_position(pos, docstring):
54 if not Options.embed_pos_in_docstring:
55 return docstring
56 pos_line = u'File: %s (starting at line %s)' % relative_position(pos)
57 if docstring is None:
58 # unicode string
59 return EncodedString(pos_line)
60
61 # make sure we can encode the filename in the docstring encoding
62 # otherwise make the docstring a unicode string
63 encoding = docstring.encoding
64 if encoding is not None:
65 try:
66 pos_line.encode(encoding)
67 except UnicodeEncodeError:
68 encoding = None
69
70 if not docstring:
71 # reuse the string encoding of the original docstring
72 doc = EncodedString(pos_line)
73 else:
74 doc = EncodedString(pos_line + u'\n' + docstring)
75 doc.encoding = encoding
76 return doc
77
78
79 def write_func_call(func, codewriter_class):
80 def f(*args, **kwds):
81 if len(args) > 1 and isinstance(args[1], codewriter_class):
82 # here we annotate the code with this function call
83 # but only if new code is generated
84 node, code = args[:2]
85 marker = ' /* %s -> %s.%s %s */' % (
86 ' ' * code.call_level,
87 node.__class__.__name__,
88 func.__name__,
89 node.pos[1:])
90 pristine = code.buffer.stream.tell()
91 code.putln(marker)
92 start = code.buffer.stream.tell()
93 code.call_level += 4
94 res = func(*args, **kwds)
95 code.call_level -= 4
96 if start == code.buffer.stream.tell():
97 code.buffer.stream.seek(pristine)
98 else:
99 marker = marker.replace('->', '<-')
100 code.putln(marker)
101 return res
102 else:
103 return func(*args, **kwds)
104 return f
105
106 class VerboseCodeWriter(type):
107 # Set this as a metaclass to trace function calls in code.
108 # This slows down code generation and makes much larger files.
109 def __new__(cls, name, bases, attrs):
110 from types import FunctionType
111 from Code import CCodeWriter
112 attrs = dict(attrs)
113 for mname, m in attrs.items():
114 if isinstance(m, FunctionType):
115 attrs[mname] = write_func_call(m, CCodeWriter)
116 return super(VerboseCodeWriter, cls).__new__(cls, name, bases, attrs)
117
118
119 class CheckAnalysers(type):
120 """Metaclass to check that type analysis functions return a node.
121 """
122 methods = set(['analyse_types',
123 'analyse_expressions',
124 'analyse_target_types'])
125
126 def __new__(cls, name, bases, attrs):
127 from types import FunctionType
128 def check(name, func):
129 def call(*args, **kwargs):
130 retval = func(*args, **kwargs)
131 if retval is None:
132 print name, args, kwargs
133 return retval
134 return call
135
136 attrs = dict(attrs)
137 for mname, m in attrs.items():
138 if isinstance(m, FunctionType) and mname in cls.methods:
139 attrs[mname] = check(mname, m)
140 return super(CheckAnalysers, cls).__new__(cls, name, bases, attrs)
141
142
143 class Node(object):
144 # pos (string, int, int) Source file position
145 # is_name boolean Is a NameNode
146 # is_literal boolean Is a ConstNode
147
148 #__metaclass__ = CheckAnalysers
149 if DebugFlags.debug_trace_code_generation:
150 __metaclass__ = VerboseCodeWriter
151
152 is_name = 0
153 is_none = 0
154 is_nonecheck = 0
155 is_literal = 0
156 is_terminator = 0
157 temps = None
158
159 # All descendants should set child_attrs to a list of the attributes
160 # containing nodes considered "children" in the tree. Each such attribute
161 # can either contain a single node or a list of nodes. See Visitor.py.
162 child_attrs = None
163
164 cf_state = None
165
166 # This may be an additional (or 'actual') type that will be checked when
167 # this node is coerced to another type. This could be useful to set when
168 # the actual type to which it can coerce is known, but you want to leave
169 # the type a py_object_type
170 coercion_type = None
171
172 def __init__(self, pos, **kw):
173 self.pos = pos
174 self.__dict__.update(kw)
175
176 gil_message = "Operation"
177
178 nogil_check = None
179
180 def gil_error(self, env=None):
181 error(self.pos, "%s not allowed without gil" % self.gil_message)
182
183 cpp_message = "Operation"
184
185 def cpp_check(self, env):
186 if not env.is_cpp():
187 self.cpp_error()
188
189 def cpp_error(self):
190 error(self.pos, "%s only allowed in c++" % self.cpp_message)
191
192 def clone_node(self):
193 """Clone the node. This is defined as a shallow copy, except for member lists
194 amongst the child attributes (from get_child_accessors) which are also
195 copied. Lists containing child nodes are thus seen as a way for the node
196 to hold multiple children directly; the list is not treated as a separate
197 level in the tree."""
198 result = copy.copy(self)
199 for attrname in result.child_attrs:
200 value = getattr(result, attrname)
201 if isinstance(value, list):
202 setattr(result, attrname, [x for x in value])
203 return result
204
205
206 #
207 # There are 3 phases of parse tree processing, applied in order to
208 # all the statements in a given scope-block:
209 #
210 # (0) analyse_declarations
211 # Make symbol table entries for all declarations at the current
212 # level, both explicit (def, cdef, etc.) and implicit (assignment
213 # to an otherwise undeclared name).
214 #
215 # (1) analyse_expressions
216 # Determine the result types of expressions and fill in the
217 # 'type' attribute of each ExprNode. Insert coercion nodes into the
218 # tree where needed to convert to and from Python objects.
219 # Allocate temporary locals for intermediate results. Fill
220 # in the 'result_code' attribute of each ExprNode with a C code
221 # fragment.
222 #
223 # (2) generate_code
224 # Emit C code for all declarations, statements and expressions.
225 # Recursively applies the 3 processing phases to the bodies of
226 # functions.
227 #
228
229 def analyse_declarations(self, env):
230 pass
231
232 def analyse_expressions(self, env):
233 raise InternalError("analyse_expressions not implemented for %s" % \
234 self.__class__.__name__)
235
236 def generate_code(self, code):
237 raise InternalError("generate_code not implemented for %s" % \
238 self.__class__.__name__)
239
240 def annotate(self, code):
241 # mro does the wrong thing
242 if isinstance(self, BlockNode):
243 self.body.annotate(code)
244
245 def end_pos(self):
246 try:
247 return self._end_pos
248 except AttributeError:
249 pos = self.pos
250 if not self.child_attrs:
251 self._end_pos = pos
252 return pos
253 for attr in self.child_attrs:
254 child = getattr(self, attr)
255 # Sometimes lists, sometimes nodes
256 if child is None:
257 pass
258 elif isinstance(child, list):
259 for c in child:
260 pos = max(pos, c.end_pos())
261 else:
262 pos = max(pos, child.end_pos())
263 self._end_pos = pos
264 return pos
265
266 def dump(self, level=0, filter_out=("pos",), cutoff=100, encountered=None):
267 """Debug helper method that returns a recursive string representation of this node.
268 """
269 if cutoff == 0:
270 return "<...nesting level cutoff...>"
271 if encountered is None:
272 encountered = set()
273 if id(self) in encountered:
274 return "<%s (0x%x) -- already output>" % (self.__class__.__name__, id(self))
275 encountered.add(id(self))
276
277 def dump_child(x, level):
278 if isinstance(x, Node):
279 return x.dump(level, filter_out, cutoff-1, encountered)
280 elif isinstance(x, list):
281 return "[%s]" % ", ".join([dump_child(item, level) for item in x])
282 else:
283 return repr(x)
284
285
286 attrs = [(key, value) for key, value in self.__dict__.items() if key not in filter_out]
287 if len(attrs) == 0:
288 return "<%s (0x%x)>" % (self.__class__.__name__, id(self))
289 else:
290 indent = " " * level
291 res = "<%s (0x%x)\n" % (self.__class__.__name__, id(self))
292 for key, value in attrs:
293 res += "%s %s: %s\n" % (indent, key, dump_child(value, level + 1))
294 res += "%s>" % indent
295 return res
296
297 def dump_pos(self, mark_column=False, marker='(#)'):
298 """Debug helper method that returns the source code context of this node as a string.
299 """
300 if not self.pos:
301 return u''
302 source_desc, line, col = self.pos
303 contents = source_desc.get_lines(encoding='ASCII',
304 error_handling='ignore')
305 # line numbers start at 1
306 lines = contents[max(0,line-3):line]
307 current = lines[-1]
308 if mark_column:
309 current = current[:col] + marker + current[col:]
310 lines[-1] = current.rstrip() + u' # <<<<<<<<<<<<<<\n'
311 lines += contents[line:line+2]
312 return u'"%s":%d:%d\n%s\n' % (
313 source_desc.get_escaped_description(), line, col, u''.join(lines))
314
315 class CompilerDirectivesNode(Node):
316 """
317 Sets compiler directives for the children nodes
318 """
319 # directives {string:value} A dictionary holding the right value for
320 # *all* possible directives.
321 # body Node
322 child_attrs = ["body"]
323
324 def analyse_declarations(self, env):
325 old = env.directives
326 env.directives = self.directives
327 self.body.analyse_declarations(env)
328 env.directives = old
329
330 def analyse_expressions(self, env):
331 old = env.directives
332 env.directives = self.directives
333 self.body = self.body.analyse_expressions(env)
334 env.directives = old
335 return self
336
337 def generate_function_definitions(self, env, code):
338 env_old = env.directives
339 code_old = code.globalstate.directives
340 code.globalstate.directives = self.directives
341 self.body.generate_function_definitions(env, code)
342 env.directives = env_old
343 code.globalstate.directives = code_old
344
345 def generate_execution_code(self, code):
346 old = code.globalstate.directives
347 code.globalstate.directives = self.directives
348 self.body.generate_execution_code(code)
349 code.globalstate.directives = old
350
351 def annotate(self, code):
352 old = code.globalstate.directives
353 code.globalstate.directives = self.directives
354 self.body.annotate(code)
355 code.globalstate.directives = old
356
357 class BlockNode(object):
358 # Mixin class for nodes representing a declaration block.
359
360 def generate_cached_builtins_decls(self, env, code):
361 entries = env.global_scope().undeclared_cached_builtins
362 for entry in entries:
363 code.globalstate.add_cached_builtin_decl(entry)
364 del entries[:]
365
366 def generate_lambda_definitions(self, env, code):
367 for node in env.lambda_defs:
368 node.generate_function_definitions(env, code)
369
370 class StatListNode(Node):
371 # stats a list of StatNode
372
373 child_attrs = ["stats"]
374
375 def create_analysed(pos, env, *args, **kw):
376 node = StatListNode(pos, *args, **kw)
377 return node # No node-specific analysis necesarry
378 create_analysed = staticmethod(create_analysed)
379
380 def analyse_declarations(self, env):
381 #print "StatListNode.analyse_declarations" ###
382 for stat in self.stats:
383 stat.analyse_declarations(env)
384
385 def analyse_expressions(self, env):
386 #print "StatListNode.analyse_expressions" ###
387 self.stats = [ stat.analyse_expressions(env)
388 for stat in self.stats ]
389 return self
390
391 def generate_function_definitions(self, env, code):
392 #print "StatListNode.generate_function_definitions" ###
393 for stat in self.stats:
394 stat.generate_function_definitions(env, code)
395
396 def generate_execution_code(self, code):
397 #print "StatListNode.generate_execution_code" ###
398 for stat in self.stats:
399 code.mark_pos(stat.pos)
400 stat.generate_execution_code(code)
401
402 def annotate(self, code):
403 for stat in self.stats:
404 stat.annotate(code)
405
406
407 class StatNode(Node):
408 #
409 # Code generation for statements is split into the following subphases:
410 #
411 # (1) generate_function_definitions
412 # Emit C code for the definitions of any structs,
413 # unions, enums and functions defined in the current
414 # scope-block.
415 #
416 # (2) generate_execution_code
417 # Emit C code for executable statements.
418 #
419
420 def generate_function_definitions(self, env, code):
421 pass
422
423 def generate_execution_code(self, code):
424 raise InternalError("generate_execution_code not implemented for %s" % \
425 self.__class__.__name__)
426
427
428 class CDefExternNode(StatNode):
429 # include_file string or None
430 # body StatNode
431
432 child_attrs = ["body"]
433
434 def analyse_declarations(self, env):
435 if self.include_file:
436 env.add_include_file(self.include_file)
437 old_cinclude_flag = env.in_cinclude
438 env.in_cinclude = 1
439 self.body.analyse_declarations(env)
440 env.in_cinclude = old_cinclude_flag
441
442 def analyse_expressions(self, env):
443 return self
444
445 def generate_execution_code(self, code):
446 pass
447
448 def annotate(self, code):
449 self.body.annotate(code)
450
451
452 class CDeclaratorNode(Node):
453 # Part of a C declaration.
454 #
455 # Processing during analyse_declarations phase:
456 #
457 # analyse
458 # Returns (name, type) pair where name is the
459 # CNameDeclaratorNode of the name being declared
460 # and type is the type it is being declared as.
461 #
462 # calling_convention string Calling convention of CFuncDeclaratorNode
463 # for which this is a base
464
465 child_attrs = []
466
467 calling_convention = ""
468
469 def analyse_templates(self):
470 # Only C++ functions have templates.
471 return None
472
473 class CNameDeclaratorNode(CDeclaratorNode):
474 # name string The Cython name being declared
475 # cname string or None C name, if specified
476 # default ExprNode or None the value assigned on declaration
477
478 child_attrs = ['default']
479
480 default = None
481
482 def analyse(self, base_type, env, nonempty = 0):
483 if nonempty and self.name == '':
484 # May have mistaken the name for the type.
485 if base_type.is_ptr or base_type.is_array or base_type.is_buffer:
486 error(self.pos, "Missing argument name")
487 elif base_type.is_void:
488 error(self.pos, "Use spam() rather than spam(void) to declare a function with no arguments.")
489 else:
490 self.name = base_type.declaration_code("", for_display=1, pyrex=1)
491 base_type = py_object_type
492
493 if base_type.is_fused and env.fused_to_specific:
494 base_type = base_type.specialize(env.fused_to_specific)
495
496 self.type = base_type
497 return self, base_type
498
499 class CPtrDeclaratorNode(CDeclaratorNode):
500 # base CDeclaratorNode
501
502 child_attrs = ["base"]
503
504 def analyse(self, base_type, env, nonempty = 0):
505 if base_type.is_pyobject:
506 error(self.pos,
507 "Pointer base type cannot be a Python object")
508 ptr_type = PyrexTypes.c_ptr_type(base_type)
509 return self.base.analyse(ptr_type, env, nonempty = nonempty)
510
511 class CReferenceDeclaratorNode(CDeclaratorNode):
512 # base CDeclaratorNode
513
514 child_attrs = ["base"]
515
516 def analyse(self, base_type, env, nonempty = 0):
517 if base_type.is_pyobject:
518 error(self.pos,
519 "Reference base type cannot be a Python object")
520 ref_type = PyrexTypes.c_ref_type(base_type)
521 return self.base.analyse(ref_type, env, nonempty = nonempty)
522
523 class CArrayDeclaratorNode(CDeclaratorNode):
524 # base CDeclaratorNode
525 # dimension ExprNode
526
527 child_attrs = ["base", "dimension"]
528
529 def analyse(self, base_type, env, nonempty = 0):
530 if base_type.is_cpp_class or base_type.is_cfunction:
531 from ExprNodes import TupleNode
532 if isinstance(self.dimension, TupleNode):
533 args = self.dimension.args
534 else:
535 args = self.dimension,
536 values = [v.analyse_as_type(env) for v in args]
537 if None in values:
538 ix = values.index(None)
539 error(args[ix].pos, "Template parameter not a type")
540 base_type = error_type
541 else:
542 base_type = base_type.specialize_here(self.pos, values)
543 return self.base.analyse(base_type, env, nonempty = nonempty)
544 if self.dimension:
545 self.dimension = self.dimension.analyse_const_expression(env)
546 if not self.dimension.type.is_int:
547 error(self.dimension.pos, "Array dimension not integer")
548 size = self.dimension.get_constant_c_result_code()
549 if size is not None:
550 try:
551 size = int(size)
552 except ValueError:
553 # runtime constant?
554 pass
555 else:
556 size = None
557 if not base_type.is_complete():
558 error(self.pos,
559 "Array element type '%s' is incomplete" % base_type)
560 if base_type.is_pyobject:
561 error(self.pos,
562 "Array element cannot be a Python object")
563 if base_type.is_cfunction:
564 error(self.pos,
565 "Array element cannot be a function")
566 array_type = PyrexTypes.c_array_type(base_type, size)
567 return self.base.analyse(array_type, env, nonempty = nonempty)
568
569
570 class CFuncDeclaratorNode(CDeclaratorNode):
571 # base CDeclaratorNode
572 # args [CArgDeclNode]
573 # templates [TemplatePlaceholderType]
574 # has_varargs boolean
575 # exception_value ConstNode
576 # exception_check boolean True if PyErr_Occurred check needed
577 # nogil boolean Can be called without gil
578 # with_gil boolean Acquire gil around function body
579 # is_const_method boolean Whether this is a const method
580
581 child_attrs = ["base", "args", "exception_value"]
582
583 overridable = 0
584 optional_arg_count = 0
585 is_const_method = 0
586 templates = None
587
588 def analyse_templates(self):
589 if isinstance(self.base, CArrayDeclaratorNode):
590 from ExprNodes import TupleNode, NameNode
591 template_node = self.base.dimension
592 if isinstance(template_node, TupleNode):
593 template_nodes = template_node.args
594 elif isinstance(template_node, NameNode):
595 template_nodes = [template_node]
596 else:
597 error(template_node.pos, "Template arguments must be a list of names")
598 return None
599 self.templates = []
600 for template in template_nodes:
601 if isinstance(template, NameNode):
602 self.templates.append(PyrexTypes.TemplatePlaceholderType(template.name))
603 else:
604 error(template.pos, "Template arguments must be a list of names")
605 self.base = self.base.base
606 return self.templates
607 else:
608 return None
609
610 def analyse(self, return_type, env, nonempty = 0, directive_locals = {}):
611 if nonempty:
612 nonempty -= 1
613 func_type_args = []
614 for i, arg_node in enumerate(self.args):
615 name_declarator, type = arg_node.analyse(env, nonempty = nonempty,
616 is_self_arg = (i == 0 and env.is_c_class_scope))
617 name = name_declarator.name
618 if name in directive_locals:
619 type_node = directive_locals[name]
620 other_type = type_node.analyse_as_type(env)
621 if other_type is None:
622 error(type_node.pos, "Not a type")
623 elif (type is not PyrexTypes.py_object_type
624 and not type.same_as(other_type)):
625 error(self.base.pos, "Signature does not agree with previous declaration")
626 error(type_node.pos, "Previous declaration here")
627 else:
628 type = other_type
629 if name_declarator.cname:
630 error(self.pos,
631 "Function argument cannot have C name specification")
632 if i==0 and env.is_c_class_scope and type.is_unspecified:
633 # fix the type of self
634 type = env.parent_type
635 # Turn *[] argument into **
636 if type.is_array:
637 type = PyrexTypes.c_ptr_type(type.base_type)
638 # Catch attempted C-style func(void) decl
639 if type.is_void:
640 error(arg_node.pos, "Use spam() rather than spam(void) to declare a function with no arguments.")
641 func_type_args.append(
642 PyrexTypes.CFuncTypeArg(name, type, arg_node.pos))
643 if arg_node.default:
644 self.optional_arg_count += 1
645 elif self.optional_arg_count:
646 error(self.pos, "Non-default argument follows default argument")
647
648 exc_val = None
649 exc_check = 0
650 if self.exception_check == '+':
651 env.add_include_file('ios') # for std::ios_base::failure
652 env.add_include_file('new') # for std::bad_alloc
653 env.add_include_file('stdexcept')
654 env.add_include_file('typeinfo') # for std::bad_cast
655 if (return_type.is_pyobject
656 and (self.exception_value or self.exception_check)
657 and self.exception_check != '+'):
658 error(self.pos,
659 "Exception clause not allowed for function returning Python object")
660 else:
661 if self.exception_value:
662 self.exception_value = self.exception_value.analyse_const_expression(env)
663 if self.exception_check == '+':
664 exc_val_type = self.exception_value.type
665 if (not exc_val_type.is_error
666 and not exc_val_type.is_pyobject
667 and not (exc_val_type.is_cfunction
668 and not exc_val_type.return_type.is_pyobject
669 and not exc_val_type.args)):
670 error(self.exception_value.pos,
671 "Exception value must be a Python exception or cdef function with no arguments.")
672 exc_val = self.exception_value
673 else:
674 self.exception_value = self.exception_value.coerce_to(
675 return_type, env).analyse_const_expression(env)
676 exc_val = self.exception_value.get_constant_c_result_code()
677 if exc_val is None:
678 raise InternalError(
679 "get_constant_c_result_code not implemented for %s" %
680 self.exception_value.__class__.__name__)
681 if not return_type.assignable_from(self.exception_value.type):
682 error(self.exception_value.pos,
683 "Exception value incompatible with function return type")
684 exc_check = self.exception_check
685 if return_type.is_cfunction:
686 error(self.pos,
687 "Function cannot return a function")
688 func_type = PyrexTypes.CFuncType(
689 return_type, func_type_args, self.has_varargs,
690 optional_arg_count = self.optional_arg_count,
691 exception_value = exc_val, exception_check = exc_check,
692 calling_convention = self.base.calling_convention,
693 nogil = self.nogil, with_gil = self.with_gil, is_overridable = self.overridable,
694 is_const_method = self.is_const_method,
695 templates = self.templates)
696
697 if self.optional_arg_count:
698 if func_type.is_fused:
699 # This is a bit of a hack... When we need to create specialized CFuncTypes
700 # on the fly because the cdef is defined in a pxd, we need to declare the specialized optional arg
701 # struct
702 def declare_opt_arg_struct(func_type, fused_cname):
703 self.declare_optional_arg_struct(func_type, env, fused_cname)
704
705 func_type.declare_opt_arg_struct = declare_opt_arg_struct
706 else:
707 self.declare_optional_arg_struct(func_type, env)
708
709 callspec = env.directives['callspec']
710 if callspec:
711 current = func_type.calling_convention
712 if current and current != callspec:
713 error(self.pos, "cannot have both '%s' and '%s' "
714 "calling conventions" % (current, callspec))
715 func_type.calling_convention = callspec
716 return self.base.analyse(func_type, env)
717
718 def declare_optional_arg_struct(self, func_type, env, fused_cname=None):
719 """
720 Declares the optional argument struct (the struct used to hold the
721 values for optional arguments). For fused cdef functions, this is
722 deferred as analyse_declarations is called only once (on the fused
723 cdef function).
724 """
725 scope = StructOrUnionScope()
726 arg_count_member = '%sn' % Naming.pyrex_prefix
727 scope.declare_var(arg_count_member, PyrexTypes.c_int_type, self.pos)
728
729 for arg in func_type.args[len(func_type.args)-self.optional_arg_count:]:
730 scope.declare_var(arg.name, arg.type, arg.pos, allow_pyobject = 1)
731
732 struct_cname = env.mangle(Naming.opt_arg_prefix, self.base.name)
733
734 if fused_cname is not None:
735 struct_cname = PyrexTypes.get_fused_cname(fused_cname, struct_cname)
736
737 op_args_struct = env.global_scope().declare_struct_or_union(
738 name = struct_cname,
739 kind = 'struct',
740 scope = scope,
741 typedef_flag = 0,
742 pos = self.pos,
743 cname = struct_cname)
744
745 op_args_struct.defined_in_pxd = 1
746 op_args_struct.used = 1
747
748 func_type.op_arg_struct = PyrexTypes.c_ptr_type(op_args_struct.type)
749
750
751 class CConstDeclaratorNode(CDeclaratorNode):
752 # base CDeclaratorNode
753
754 child_attrs = ["base"]
755
756 def analyse(self, base_type, env, nonempty = 0):
757 if base_type.is_pyobject:
758 error(self.pos,
759 "Const base type cannot be a Python object")
760 const = PyrexTypes.c_const_type(base_type)
761 return self.base.analyse(const, env, nonempty = nonempty)
762
763
764 class CArgDeclNode(Node):
765 # Item in a function declaration argument list.
766 #
767 # base_type CBaseTypeNode
768 # declarator CDeclaratorNode
769 # not_none boolean Tagged with 'not None'
770 # or_none boolean Tagged with 'or None'
771 # accept_none boolean Resolved boolean for not_none/or_none
772 # default ExprNode or None
773 # default_value PyObjectConst constant for default value
774 # annotation ExprNode or None Py3 function arg annotation
775 # is_self_arg boolean Is the "self" arg of an extension type method
776 # is_type_arg boolean Is the "class" arg of an extension type classmethod
777 # is_kw_only boolean Is a keyword-only argument
778 # is_dynamic boolean Non-literal arg stored inside CyFunction
779
780 child_attrs = ["base_type", "declarator", "default", "annotation"]
781
782 is_self_arg = 0
783 is_type_arg = 0
784 is_generic = 1
785 kw_only = 0
786 not_none = 0
787 or_none = 0
788 type = None
789 name_declarator = None
790 default_value = None
791 annotation = None
792 is_dynamic = 0
793
794 def analyse(self, env, nonempty = 0, is_self_arg = False):
795 if is_self_arg:
796 self.base_type.is_self_arg = self.is_self_arg = True
797 if self.type is None:
798 # The parser may misinterpret names as types. We fix that here.
799 if isinstance(self.declarator, CNameDeclaratorNode) and self.declarator.name == '':
800 if nonempty:
801 if self.base_type.is_basic_c_type:
802 # char, short, long called "int"
803 type = self.base_type.analyse(env, could_be_name = True)
804 arg_name = type.declaration_code("")
805 else:
806 arg_name = self.base_type.name
807 self.declarator.name = EncodedString(arg_name)
808 self.base_type.name = None
809 self.base_type.is_basic_c_type = False
810 could_be_name = True
811 else:
812 could_be_name = False
813 self.base_type.is_arg = True
814 base_type = self.base_type.analyse(env, could_be_name = could_be_name)
815 if hasattr(self.base_type, 'arg_name') and self.base_type.arg_name:
816 self.declarator.name = self.base_type.arg_name
817 # The parser is unable to resolve the ambiguity of [] as part of the
818 # type (e.g. in buffers) or empty declarator (as with arrays).
819 # This is only arises for empty multi-dimensional arrays.
820 if (base_type.is_array
821 and isinstance(self.base_type, TemplatedTypeNode)
822 and isinstance(self.declarator, CArrayDeclaratorNode)):
823 declarator = self.declarator
824 while isinstance(declarator.base, CArrayDeclaratorNode):
825 declarator = declarator.base
826 declarator.base = self.base_type.array_declarator
827 base_type = base_type.base_type
828 return self.declarator.analyse(base_type, env, nonempty = nonempty)
829 else:
830 return self.name_declarator, self.type
831
832 def calculate_default_value_code(self, code):
833 if self.default_value is None:
834 if self.default:
835 if self.default.is_literal:
836 # will not output any code, just assign the result_code
837 self.default.generate_evaluation_code(code)
838 return self.type.cast_code(self.default.result())
839 self.default_value = code.get_argument_default_const(self.type)
840 return self.default_value
841
842 def annotate(self, code):
843 if self.default:
844 self.default.annotate(code)
845
846 def generate_assignment_code(self, code, target=None):
847 default = self.default
848 if default is None or default.is_literal:
849 return
850 if target is None:
851 target = self.calculate_default_value_code(code)
852 default.generate_evaluation_code(code)
853 default.make_owned_reference(code)
854 result = default.result_as(self.type)
855 code.putln("%s = %s;" % (target, result))
856 if self.type.is_pyobject:
857 code.put_giveref(default.result())
858 default.generate_post_assignment_code(code)
859 default.free_temps(code)
860
861
862 class CBaseTypeNode(Node):
863 # Abstract base class for C base type nodes.
864 #
865 # Processing during analyse_declarations phase:
866 #
867 # analyse
868 # Returns the type.
869
870 pass
871
872 def analyse_as_type(self, env):
873 return self.analyse(env)
874
875 class CAnalysedBaseTypeNode(Node):
876 # type type
877
878 child_attrs = []
879
880 def analyse(self, env, could_be_name = False):
881 return self.type
882
883 class CSimpleBaseTypeNode(CBaseTypeNode):
884 # name string
885 # module_path [string] Qualifying name components
886 # is_basic_c_type boolean
887 # signed boolean
888 # longness integer
889 # complex boolean
890 # is_self_arg boolean Is self argument of C method
891 # ##is_type_arg boolean Is type argument of class method
892
893 child_attrs = []
894 arg_name = None # in case the argument name was interpreted as a type
895 module_path = []
896 is_basic_c_type = False
897 complex = False
898
899 def analyse(self, env, could_be_name = False):
900 # Return type descriptor.
901 #print "CSimpleBaseTypeNode.analyse: is_self_arg =", self.is_self_arg ###
902 type = None
903 if self.is_basic_c_type:
904 type = PyrexTypes.simple_c_type(self.signed, self.longness, self.name)
905 if not type:
906 error(self.pos, "Unrecognised type modifier combination")
907 elif self.name == "object" and not self.module_path:
908 type = py_object_type
909 elif self.name is None:
910 if self.is_self_arg and env.is_c_class_scope:
911 #print "CSimpleBaseTypeNode.analyse: defaulting to parent type" ###
912 type = env.parent_type
913 ## elif self.is_type_arg and env.is_c_class_scope:
914 ## type = Builtin.type_type
915 else:
916 type = py_object_type
917 else:
918 if self.module_path:
919 # Maybe it's a nested C++ class.
920 scope = env
921 for item in self.module_path:
922 entry = scope.lookup(item)
923 if entry is not None and entry.is_cpp_class:
924 scope = entry.type.scope
925 else:
926 scope = None
927 break
928
929 if scope is None:
930 # Maybe it's a cimport.
931 scope = env.find_imported_module(self.module_path, self.pos)
932 if scope:
933 scope.fused_to_specific = env.fused_to_specific
934 else:
935 scope = env
936
937 if scope:
938 if scope.is_c_class_scope:
939 scope = scope.global_scope()
940
941 type = scope.lookup_type(self.name)
942 if type is not None:
943 pass
944 elif could_be_name:
945 if self.is_self_arg and env.is_c_class_scope:
946 type = env.parent_type
947 ## elif self.is_type_arg and env.is_c_class_scope:
948 ## type = Builtin.type_type
949 else:
950 type = py_object_type
951 self.arg_name = EncodedString(self.name)
952 else:
953 if self.templates:
954 if not self.name in self.templates:
955 error(self.pos, "'%s' is not a type identifier" % self.name)
956 type = PyrexTypes.TemplatePlaceholderType(self.name)
957 else:
958 error(self.pos, "'%s' is not a type identifier" % self.name)
959 if self.complex:
960 if not type.is_numeric or type.is_complex:
961 error(self.pos, "can only complexify c numeric types")
962 type = PyrexTypes.CComplexType(type)
963 type.create_declaration_utility_code(env)
964 elif type is Builtin.complex_type:
965 # Special case: optimise builtin complex type into C's
966 # double complex. The parser cannot do this (as for the
967 # normal scalar types) as the user may have redeclared the
968 # 'complex' type. Testing for the exact type here works.
969 type = PyrexTypes.c_double_complex_type
970 type.create_declaration_utility_code(env)
971 self.complex = True
972 if type:
973 return type
974 else:
975 return PyrexTypes.error_type
976
977 class MemoryViewSliceTypeNode(CBaseTypeNode):
978
979 name = 'memoryview'
980 child_attrs = ['base_type_node', 'axes']
981
982 def analyse(self, env, could_be_name = False):
983
984 base_type = self.base_type_node.analyse(env)
985 if base_type.is_error: return base_type
986
987 import MemoryView
988
989 try:
990 axes_specs = MemoryView.get_axes_specs(env, self.axes)
991 except CompileError, e:
992 error(e.position, e.message_only)
993 self.type = PyrexTypes.ErrorType()
994 return self.type
995
996 if not MemoryView.validate_axes(self.pos, axes_specs):
997 self.type = error_type
998 else:
999 MemoryView.validate_memslice_dtype(self.pos, base_type)
1000 self.type = PyrexTypes.MemoryViewSliceType(base_type, axes_specs)
1001 self.use_memview_utilities(env)
1002
1003 return self.type
1004
1005 def use_memview_utilities(self, env):
1006 import MemoryView
1007 env.use_utility_code(MemoryView.view_utility_code)
1008
1009
1010 class CNestedBaseTypeNode(CBaseTypeNode):
1011 # For C++ classes that live inside other C++ classes.
1012
1013 # name string
1014 # base_type CBaseTypeNode
1015
1016 child_attrs = ['base_type']
1017
1018 def analyse(self, env, could_be_name = None):
1019 base_type = self.base_type.analyse(env)
1020 if base_type is PyrexTypes.error_type:
1021 return PyrexTypes.error_type
1022 if not base_type.is_cpp_class:
1023 error(self.pos, "'%s' is not a valid type scope" % base_type)
1024 return PyrexTypes.error_type
1025 type_entry = base_type.scope.lookup_here(self.name)
1026 if not type_entry or not type_entry.is_type:
1027 error(self.pos, "'%s.%s' is not a type identifier" % (base_type, self.name))
1028 return PyrexTypes.error_type
1029 return type_entry.type
1030
1031
1032 class TemplatedTypeNode(CBaseTypeNode):
1033 # After parsing:
1034 # positional_args [ExprNode] List of positional arguments
1035 # keyword_args DictNode Keyword arguments
1036 # base_type_node CBaseTypeNode
1037
1038 # After analysis:
1039 # type PyrexTypes.BufferType or PyrexTypes.CppClassType ...containing the right options
1040
1041 child_attrs = ["base_type_node", "positional_args",
1042 "keyword_args", "dtype_node"]
1043
1044 dtype_node = None
1045
1046 name = None
1047
1048 def analyse(self, env, could_be_name = False, base_type = None):
1049 if base_type is None:
1050 base_type = self.base_type_node.analyse(env)
1051 if base_type.is_error: return base_type
1052
1053 if base_type.is_cpp_class:
1054 # Templated class
1055 if self.keyword_args and self.keyword_args.key_value_pairs:
1056 error(self.pos, "c++ templates cannot take keyword arguments")
1057 self.type = PyrexTypes.error_type
1058 else:
1059 template_types = []
1060 for template_node in self.positional_args:
1061 type = template_node.analyse_as_type(env)
1062 if type is None:
1063 error(template_node.pos, "unknown type in template argument")
1064 return error_type
1065 template_types.append(type)
1066 self.type = base_type.specialize_here(self.pos, template_types)
1067
1068 elif base_type.is_pyobject:
1069 # Buffer
1070 import Buffer
1071
1072 options = Buffer.analyse_buffer_options(
1073 self.pos,
1074 env,
1075 self.positional_args,
1076 self.keyword_args,
1077 base_type.buffer_defaults)
1078
1079 if sys.version_info[0] < 3:
1080 # Py 2.x enforces byte strings as keyword arguments ...
1081 options = dict([ (name.encode('ASCII'), value)
1082 for name, value in options.items() ])
1083
1084 self.type = PyrexTypes.BufferType(base_type, **options)
1085
1086 else:
1087 # Array
1088 empty_declarator = CNameDeclaratorNode(self.pos, name="", cname=None)
1089 if len(self.positional_args) > 1 or self.keyword_args.key_value_pairs:
1090 error(self.pos, "invalid array declaration")
1091 self.type = PyrexTypes.error_type
1092 else:
1093 # It would be nice to merge this class with CArrayDeclaratorNode,
1094 # but arrays are part of the declaration, not the type...
1095 if not self.positional_args:
1096 dimension = None
1097 else:
1098 dimension = self.positional_args[0]
1099 self.array_declarator = CArrayDeclaratorNode(self.pos,
1100 base = empty_declarator,
1101 dimension = dimension)
1102 self.type = self.array_declarator.analyse(base_type, env)[1]
1103
1104 if self.type.is_fused and env.fused_to_specific:
1105 self.type = self.type.specialize(env.fused_to_specific)
1106
1107 return self.type
1108
1109 class CComplexBaseTypeNode(CBaseTypeNode):
1110 # base_type CBaseTypeNode
1111 # declarator CDeclaratorNode
1112
1113 child_attrs = ["base_type", "declarator"]
1114
1115 def analyse(self, env, could_be_name = False):
1116 base = self.base_type.analyse(env, could_be_name)
1117 _, type = self.declarator.analyse(base, env)
1118 return type
1119
1120
1121 class FusedTypeNode(CBaseTypeNode):
1122 """
1123 Represents a fused type in a ctypedef statement:
1124
1125 ctypedef cython.fused_type(int, long, long long) integral
1126
1127 name str name of this fused type
1128 types [CSimpleBaseTypeNode] is the list of types to be fused
1129 """
1130
1131 child_attrs = []
1132
1133 def analyse_declarations(self, env):
1134 type = self.analyse(env)
1135 entry = env.declare_typedef(self.name, type, self.pos)
1136
1137 # Omit the typedef declaration that self.declarator would produce
1138 entry.in_cinclude = True
1139
1140 def analyse(self, env):
1141 types = []
1142 for type_node in self.types:
1143 type = type_node.analyse_as_type(env)
1144
1145 if not type:
1146 error(type_node.pos, "Not a type")
1147 continue
1148
1149 if type in types:
1150 error(type_node.pos, "Type specified multiple times")
1151 elif type.is_fused:
1152 error(type_node.pos, "Cannot fuse a fused type")
1153 else:
1154 types.append(type)
1155
1156 # if len(self.types) == 1:
1157 # return types[0]
1158
1159 return PyrexTypes.FusedType(types, name=self.name)
1160
1161
1162 class CConstTypeNode(CBaseTypeNode):
1163 # base_type CBaseTypeNode
1164
1165 child_attrs = ["base_type"]
1166
1167 def analyse(self, env, could_be_name = False):
1168 base = self.base_type.analyse(env, could_be_name)
1169 if base.is_pyobject:
1170 error(self.pos,
1171 "Const base type cannot be a Python object")
1172 return PyrexTypes.c_const_type(base)
1173
1174
1175 class CVarDefNode(StatNode):
1176 # C variable definition or forward/extern function declaration.
1177 #
1178 # visibility 'private' or 'public' or 'extern'
1179 # base_type CBaseTypeNode
1180 # declarators [CDeclaratorNode]
1181 # in_pxd boolean
1182 # api boolean
1183 # overridable boolean whether it is a cpdef
1184 # modifiers ['inline']
1185
1186 # decorators [cython.locals(...)] or None
1187 # directive_locals { string : NameNode } locals defined by cython.locals(...)
1188
1189 child_attrs = ["base_type", "declarators"]
1190
1191 decorators = None
1192 directive_locals = None
1193
1194 def analyse_declarations(self, env, dest_scope = None):
1195 if self.directive_locals is None:
1196 self.directive_locals = {}
1197 if not dest_scope:
1198 dest_scope = env
1199 self.dest_scope = dest_scope
1200
1201 if self.declarators:
1202 templates = self.declarators[0].analyse_templates()
1203 else:
1204 templates = None
1205 if templates is not None:
1206 if self.visibility != 'extern':
1207 error(self.pos, "Only extern functions allowed")
1208 if len(self.declarators) > 1:
1209 error(self.declarators[1].pos, "Can't multiply declare template types")
1210 env = TemplateScope('func_template', env)
1211 env.directives = env.outer_scope.directives
1212 for template_param in templates:
1213 env.declare_type(template_param.name, template_param, self.pos)
1214
1215 base_type = self.base_type.analyse(env)
1216
1217 if base_type.is_fused and not self.in_pxd and (env.is_c_class_scope or
1218 env.is_module_scope):
1219 error(self.pos, "Fused types not allowed here")
1220 return error_type
1221
1222 self.entry = None
1223 visibility = self.visibility
1224
1225 for declarator in self.declarators:
1226
1227 if (len(self.declarators) > 1
1228 and not isinstance(declarator, CNameDeclaratorNode)
1229 and env.directives['warn.multiple_declarators']):
1230 warning(declarator.pos,
1231 "Non-trivial type declarators in shared declaration (e.g. mix of pointers and values). " +
1232 "Each pointer declaration should be on its own line.", 1)
1233
1234 if isinstance(declarator, CFuncDeclaratorNode):
1235 name_declarator, type = declarator.analyse(base_type, env, directive_locals=self.directive_locals)
1236 else:
1237 name_declarator, type = declarator.analyse(base_type, env)
1238 if not type.is_complete():
1239 if not (self.visibility == 'extern' and type.is_array or type.is_memoryviewslice):
1240 error(declarator.pos,
1241 "Variable type '%s' is incomplete" % type)
1242 if self.visibility == 'extern' and type.is_pyobject:
1243 error(declarator.pos,
1244 "Python object cannot be declared extern")
1245 name = name_declarator.name
1246 cname = name_declarator.cname
1247 if name == '':
1248 error(declarator.pos, "Missing name in declaration.")
1249 return
1250 if type.is_cfunction:
1251 self.entry = dest_scope.declare_cfunction(name, type, declarator.pos,
1252 cname = cname, visibility = self.visibility, in_pxd = self.in_pxd,
1253 api = self.api, modifiers = self.modifiers)
1254 if self.entry is not None:
1255 self.entry.is_overridable = self.overridable
1256 self.entry.directive_locals = copy.copy(self.directive_locals)
1257 else:
1258 if self.directive_locals:
1259 error(self.pos, "Decorators can only be followed by functions")
1260 self.entry = dest_scope.declare_var(name, type, declarator.pos,
1261 cname=cname, visibility=visibility, in_pxd=self.in_pxd,
1262 api=self.api, is_cdef=1)
1263 if Options.docstrings:
1264 self.entry.doc = embed_position(self.pos, self.doc)
1265
1266
1267 class CStructOrUnionDefNode(StatNode):
1268 # name string
1269 # cname string or None
1270 # kind "struct" or "union"
1271 # typedef_flag boolean
1272 # visibility "public" or "private"
1273 # api boolean
1274 # in_pxd boolean
1275 # attributes [CVarDefNode] or None
1276 # entry Entry
1277 # packed boolean
1278
1279 child_attrs = ["attributes"]
1280
1281 def declare(self, env, scope=None):
1282 if self.visibility == 'extern' and self.packed and not scope:
1283 error(self.pos, "Cannot declare extern struct as 'packed'")
1284 self.entry = env.declare_struct_or_union(
1285 self.name, self.kind, scope, self.typedef_flag, self.pos,
1286 self.cname, visibility = self.visibility, api = self.api,
1287 packed = self.packed)
1288
1289 def analyse_declarations(self, env):
1290 scope = None
1291 if self.attributes is not None:
1292 scope = StructOrUnionScope(self.name)
1293 self.declare(env, scope)
1294 if self.attributes is not None:
1295 if self.in_pxd and not env.in_cinclude:
1296 self.entry.defined_in_pxd = 1
1297 for attr in self.attributes:
1298 attr.analyse_declarations(env, scope)
1299 if self.visibility != 'extern':
1300 for attr in scope.var_entries:
1301 type = attr.type
1302 while type.is_array:
1303 type = type.base_type
1304 if type == self.entry.type:
1305 error(attr.pos, "Struct cannot contain itself as a member.")
1306
1307 def analyse_expressions(self, env):
1308 return self
1309
1310 def generate_execution_code(self, code):
1311 pass
1312
1313
1314 class CppClassNode(CStructOrUnionDefNode, BlockNode):
1315
1316 # name string
1317 # cname string or None
1318 # visibility "extern"
1319 # in_pxd boolean
1320 # attributes [CVarDefNode] or None
1321 # entry Entry
1322 # base_classes [CBaseTypeNode]
1323 # templates [string] or None
1324
1325 def declare(self, env):
1326 if self.templates is None:
1327 template_types = None
1328 else:
1329 template_types = [PyrexTypes.TemplatePlaceholderType(template_name) for template_name in self.templates]
1330 self.entry = env.declare_cpp_class(
1331 self.name, None, self.pos,
1332 self.cname, base_classes = [], visibility = self.visibility, templates = template_types)
1333
1334 def analyse_declarations(self, env):
1335 scope = None
1336 if self.attributes is not None:
1337 scope = CppClassScope(self.name, env, templates = self.templates)
1338 def base_ok(base_class):
1339 if base_class.is_cpp_class or base_class.is_struct:
1340 return True
1341 else:
1342 error(self.pos, "Base class '%s' not a struct or class." % base_class)
1343 base_class_types = filter(base_ok, [b.analyse(scope or env) for b in self.base_classes])
1344 if self.templates is None:
1345 template_types = None
1346 else:
1347 template_types = [PyrexTypes.TemplatePlaceholderType(template_name) for template_name in self.templates]
1348 self.entry = env.declare_cpp_class(
1349 self.name, scope, self.pos,
1350 self.cname, base_class_types, visibility = self.visibility, templates = template_types)
1351 if self.entry is None:
1352 return
1353 self.entry.is_cpp_class = 1
1354 if scope is not None:
1355 scope.type = self.entry.type
1356 defined_funcs = []
1357 if self.attributes is not None:
1358 if self.in_pxd and not env.in_cinclude:
1359 self.entry.defined_in_pxd = 1
1360 for attr in self.attributes:
1361 attr.analyse_declarations(scope)
1362 if isinstance(attr, CFuncDefNode):
1363 defined_funcs.append(attr)
1364 if self.templates is not None:
1365 attr.template_declaration = "template <typename %s>" % ", typename ".join(self.templates)
1366 self.body = StatListNode(self.pos, stats=defined_funcs)
1367 self.scope = scope
1368
1369 def analyse_expressions(self, env):
1370 self.body = self.body.analyse_expressions(self.entry.type.scope)
1371 return self
1372
1373 def generate_function_definitions(self, env, code):
1374 self.body.generate_function_definitions(self.entry.type.scope, code)
1375
1376 def generate_execution_code(self, code):
1377 self.body.generate_execution_code(code)
1378
1379 def annotate(self, code):
1380 self.body.annotate(code)
1381
1382
1383 class CEnumDefNode(StatNode):
1384 # name string or None
1385 # cname string or None
1386 # items [CEnumDefItemNode]
1387 # typedef_flag boolean
1388 # visibility "public" or "private"
1389 # api boolean
1390 # in_pxd boolean
1391 # entry Entry
1392
1393 child_attrs = ["items"]
1394
1395 def declare(self, env):
1396 self.entry = env.declare_enum(self.name, self.pos,
1397 cname = self.cname, typedef_flag = self.typedef_flag,
1398 visibility = self.visibility, api = self.api)
1399
1400 def analyse_declarations(self, env):
1401 if self.items is not None:
1402 if self.in_pxd and not env.in_cinclude:
1403 self.entry.defined_in_pxd = 1
1404 for item in self.items:
1405 item.analyse_declarations(env, self.entry)
1406
1407 def analyse_expressions(self, env):
1408 return self
1409
1410 def generate_execution_code(self, code):
1411 if self.visibility == 'public' or self.api:
1412 temp = code.funcstate.allocate_temp(PyrexTypes.py_object_type, manage_ref=True)
1413 for item in self.entry.enum_values:
1414 code.putln("%s = PyInt_FromLong(%s); %s" % (
1415 temp,
1416 item.cname,
1417 code.error_goto_if_null(temp, item.pos)))
1418 code.put_gotref(temp)
1419 code.putln('if (PyDict_SetItemString(%s, "%s", %s) < 0) %s' % (
1420 Naming.moddict_cname,
1421 item.name,
1422 temp,
1423 code.error_goto(item.pos)))
1424 code.put_decref_clear(temp, PyrexTypes.py_object_type)
1425 code.funcstate.release_temp(temp)
1426
1427
1428 class CEnumDefItemNode(StatNode):
1429 # name string
1430 # cname string or None
1431 # value ExprNode or None
1432
1433 child_attrs = ["value"]
1434
1435 def analyse_declarations(self, env, enum_entry):
1436 if self.value:
1437 self.value = self.value.analyse_const_expression(env)
1438 if not self.value.type.is_int:
1439 self.value = self.value.coerce_to(PyrexTypes.c_int_type, env)
1440 self.value = self.value.analyse_const_expression(env)
1441 entry = env.declare_const(self.name, enum_entry.type,
1442 self.value, self.pos, cname = self.cname,
1443 visibility = enum_entry.visibility, api = enum_entry.api)
1444 enum_entry.enum_values.append(entry)
1445
1446
1447 class CTypeDefNode(StatNode):
1448 # base_type CBaseTypeNode
1449 # declarator CDeclaratorNode
1450 # visibility "public" or "private"
1451 # api boolean
1452 # in_pxd boolean
1453
1454 child_attrs = ["base_type", "declarator"]
1455
1456 def analyse_declarations(self, env):
1457 base = self.base_type.analyse(env)
1458 name_declarator, type = self.declarator.analyse(base, env)
1459 name = name_declarator.name
1460 cname = name_declarator.cname
1461
1462 entry = env.declare_typedef(name, type, self.pos,
1463 cname = cname, visibility = self.visibility, api = self.api)
1464
1465 if type.is_fused:
1466 entry.in_cinclude = True
1467
1468 if self.in_pxd and not env.in_cinclude:
1469 entry.defined_in_pxd = 1
1470
1471 def analyse_expressions(self, env):
1472 return self
1473
1474 def generate_execution_code(self, code):
1475 pass
1476
1477
1478 class FuncDefNode(StatNode, BlockNode):
1479 # Base class for function definition nodes.
1480 #
1481 # return_type PyrexType
1482 # #filename string C name of filename string const
1483 # entry Symtab.Entry
1484 # needs_closure boolean Whether or not this function has inner functions/classes/yield
1485 # needs_outer_scope boolean Whether or not this function requires outer scope
1486 # pymethdef_required boolean Force Python method struct generation
1487 # directive_locals { string : ExprNode } locals defined by cython.locals(...)
1488 # directive_returns [ExprNode] type defined by cython.returns(...)
1489 # star_arg PyArgDeclNode or None * argument
1490 # starstar_arg PyArgDeclNode or None ** argument
1491
1492 # has_fused_arguments boolean
1493 # Whether this cdef function has fused parameters. This is needed
1494 # by AnalyseDeclarationsTransform, so it can replace CFuncDefNodes
1495 # with fused argument types with a FusedCFuncDefNode
1496
1497 py_func = None
1498 needs_closure = False
1499 needs_outer_scope = False
1500 pymethdef_required = False
1501 is_generator = False
1502 is_generator_body = False
1503 modifiers = []
1504 has_fused_arguments = False
1505 star_arg = None
1506 starstar_arg = None
1507 is_cyfunction = False
1508
1509 def analyse_default_values(self, env):
1510 default_seen = 0
1511 for arg in self.args:
1512 if arg.default:
1513 default_seen = 1
1514 if arg.is_generic:
1515 arg.default = arg.default.analyse_types(env)
1516 arg.default = arg.default.coerce_to(arg.type, env)
1517 else:
1518 error(arg.pos,
1519 "This argument cannot have a default value")
1520 arg.default = None
1521 elif arg.kw_only:
1522 default_seen = 1
1523 elif default_seen:
1524 error(arg.pos, "Non-default argument following default argument")
1525
1526 def align_argument_type(self, env, arg):
1527 directive_locals = self.directive_locals
1528 type = arg.type
1529 if arg.name in directive_locals:
1530 type_node = directive_locals[arg.name]
1531 other_type = type_node.analyse_as_type(env)
1532 if other_type is None:
1533 error(type_node.pos, "Not a type")
1534 elif (type is not PyrexTypes.py_object_type
1535 and not type.same_as(other_type)):
1536 error(arg.base_type.pos, "Signature does not agree with previous declaration")
1537 error(type_node.pos, "Previous declaration here")
1538 else:
1539 arg.type = other_type
1540 return arg
1541
1542 def need_gil_acquisition(self, lenv):
1543 return 0
1544
1545 def create_local_scope(self, env):
1546 genv = env
1547 while genv.is_py_class_scope or genv.is_c_class_scope:
1548 genv = genv.outer_scope
1549 if self.needs_closure:
1550 lenv = ClosureScope(name=self.entry.name,
1551 outer_scope = genv,
1552 parent_scope = env,
1553 scope_name=self.entry.cname)
1554 else:
1555 lenv = LocalScope(name=self.entry.name,
1556 outer_scope=genv,
1557 parent_scope=env)
1558 lenv.return_type = self.return_type
1559 type = self.entry.type
1560 if type.is_cfunction:
1561 lenv.nogil = type.nogil and not type.with_gil
1562 self.local_scope = lenv
1563 lenv.directives = env.directives
1564 return lenv
1565
1566 def generate_function_body(self, env, code):
1567 self.body.generate_execution_code(code)
1568
1569 def generate_function_definitions(self, env, code):
1570 import Buffer
1571 if self.return_type.is_memoryviewslice:
1572 import MemoryView
1573
1574 lenv = self.local_scope
1575 if lenv.is_closure_scope and not lenv.is_passthrough:
1576 outer_scope_cname = "%s->%s" % (Naming.cur_scope_cname,
1577 Naming.outer_scope_cname)
1578 else:
1579 outer_scope_cname = Naming.outer_scope_cname
1580 lenv.mangle_closure_cnames(outer_scope_cname)
1581 # Generate closure function definitions
1582 self.body.generate_function_definitions(lenv, code)
1583 # generate lambda function definitions
1584 self.generate_lambda_definitions(lenv, code)
1585
1586 is_getbuffer_slot = (self.entry.name == "__getbuffer__" and
1587 self.entry.scope.is_c_class_scope)
1588 is_releasebuffer_slot = (self.entry.name == "__releasebuffer__" and
1589 self.entry.scope.is_c_class_scope)
1590 is_buffer_slot = is_getbuffer_slot or is_releasebuffer_slot
1591 if is_buffer_slot:
1592 if 'cython_unused' not in self.modifiers:
1593 self.modifiers = self.modifiers + ['cython_unused']
1594
1595 preprocessor_guard = self.get_preprocessor_guard()
1596
1597 profile = code.globalstate.directives['profile']
1598 linetrace = code.globalstate.directives['linetrace']
1599 if (linetrace or profile) and lenv.nogil:
1600 warning(self.pos, "Cannot profile nogil function.", 1)
1601 profile = linetrace = False
1602 if profile or linetrace:
1603 code.globalstate.use_utility_code(
1604 UtilityCode.load_cached("Profile", "Profile.c"))
1605
1606 # Generate C code for header and body of function
1607 code.enter_cfunc_scope()
1608 code.return_from_error_cleanup_label = code.new_label()
1609
1610 # ----- Top-level constants used by this function
1611 code.mark_pos(self.pos)
1612 self.generate_cached_builtins_decls(lenv, code)
1613 # ----- Function header
1614 code.putln("")
1615
1616 if preprocessor_guard:
1617 code.putln(preprocessor_guard)
1618
1619 with_pymethdef = (self.needs_assignment_synthesis(env, code) or
1620 self.pymethdef_required)
1621 if self.py_func:
1622 self.py_func.generate_function_header(code,
1623 with_pymethdef = with_pymethdef,
1624 proto_only=True)
1625 self.generate_function_header(code,
1626 with_pymethdef = with_pymethdef)
1627 # ----- Local variable declarations
1628 # Find function scope
1629 cenv = env
1630 while cenv.is_py_class_scope or cenv.is_c_class_scope:
1631 cenv = cenv.outer_scope
1632 if self.needs_closure:
1633 code.put(lenv.scope_class.type.declaration_code(Naming.cur_scope_cname))
1634 code.putln(";")
1635 elif self.needs_outer_scope:
1636 if lenv.is_passthrough:
1637 code.put(lenv.scope_class.type.declaration_code(Naming.cur_scope_cname))
1638 code.putln(";")
1639 code.put(cenv.scope_class.type.declaration_code(Naming.outer_scope_cname))
1640 code.putln(";")
1641 self.generate_argument_declarations(lenv, code)
1642
1643 for entry in lenv.var_entries:
1644 if not (entry.in_closure or entry.is_arg):
1645 code.put_var_declaration(entry)
1646
1647 # Initialize the return variable __pyx_r
1648 init = ""
1649 if not self.return_type.is_void:
1650 if self.return_type.is_pyobject:
1651 init = " = NULL"
1652 elif self.return_type.is_memoryviewslice:
1653 init = ' = ' + MemoryView.memslice_entry_init
1654
1655 code.putln(
1656 "%s%s;" %
1657 (self.return_type.declaration_code(Naming.retval_cname),
1658 init))
1659
1660 tempvardecl_code = code.insertion_point()
1661 self.generate_keyword_list(code)
1662
1663 if profile or linetrace:
1664 code.put_trace_declarations()
1665
1666 # ----- Extern library function declarations
1667 lenv.generate_library_function_declarations(code)
1668
1669 # ----- GIL acquisition
1670 acquire_gil = self.acquire_gil
1671
1672 # See if we need to acquire the GIL for variable declarations, or for
1673 # refnanny only
1674
1675 # Profiling or closures are not currently possible for cdef nogil
1676 # functions, but check them anyway
1677 have_object_args = (self.needs_closure or self.needs_outer_scope or
1678 profile or linetrace)
1679 for arg in lenv.arg_entries:
1680 if arg.type.is_pyobject:
1681 have_object_args = True
1682 break
1683
1684 acquire_gil_for_var_decls_only = (
1685 lenv.nogil and lenv.has_with_gil_block and
1686 (have_object_args or lenv.buffer_entries))
1687
1688 acquire_gil_for_refnanny_only = (
1689 lenv.nogil and lenv.has_with_gil_block and not
1690 acquire_gil_for_var_decls_only)
1691
1692 use_refnanny = not lenv.nogil or lenv.has_with_gil_block
1693
1694 if acquire_gil or acquire_gil_for_var_decls_only:
1695 code.put_ensure_gil()
1696 elif lenv.nogil and lenv.has_with_gil_block:
1697 code.declare_gilstate()
1698
1699 # ----- set up refnanny
1700 if use_refnanny:
1701 tempvardecl_code.put_declare_refcount_context()
1702 code.put_setup_refcount_context(
1703 self.entry.name, acquire_gil=acquire_gil_for_refnanny_only)
1704
1705 # ----- Automatic lead-ins for certain special functions
1706 if is_getbuffer_slot:
1707 self.getbuffer_init(code)
1708 # ----- Create closure scope object
1709 if self.needs_closure:
1710 tp_slot = TypeSlots.ConstructorSlot("tp_new", '__new__')
1711 slot_func_cname = TypeSlots.get_slot_function(lenv.scope_class.type.scope, tp_slot)
1712 if not slot_func_cname:
1713 slot_func_cname = '%s->tp_new' % lenv.scope_class.type.typeptr_cname
1714 code.putln("%s = (%s)%s(%s, %s, NULL);" % (
1715 Naming.cur_scope_cname,
1716 lenv.scope_class.type.declaration_code(''),
1717 slot_func_cname,
1718 lenv.scope_class.type.typeptr_cname,
1719 Naming.empty_tuple))
1720 code.putln("if (unlikely(!%s)) {" % Naming.cur_scope_cname)
1721 if is_getbuffer_slot:
1722 self.getbuffer_error_cleanup(code)
1723
1724 if use_refnanny:
1725 code.put_finish_refcount_context()
1726 if acquire_gil or acquire_gil_for_var_decls_only:
1727 code.put_release_ensured_gil()
1728
1729 # FIXME: what if the error return value is a Python value?
1730 code.putln("return %s;" % self.error_value())
1731 code.putln("}")
1732 code.put_gotref(Naming.cur_scope_cname)
1733 # Note that it is unsafe to decref the scope at this point.
1734 if self.needs_outer_scope:
1735 if self.is_cyfunction:
1736 code.putln("%s = (%s) __Pyx_CyFunction_GetClosure(%s);" % (
1737 outer_scope_cname,
1738 cenv.scope_class.type.declaration_code(''),
1739 Naming.self_cname))
1740 else:
1741 code.putln("%s = (%s) %s;" % (
1742 outer_scope_cname,
1743 cenv.scope_class.type.declaration_code(''),
1744 Naming.self_cname))
1745 if lenv.is_passthrough:
1746 code.putln("%s = %s;" % (Naming.cur_scope_cname, outer_scope_cname))
1747 elif self.needs_closure:
1748 # inner closures own a reference to their outer parent
1749 code.put_incref(outer_scope_cname, cenv.scope_class.type)
1750 code.put_giveref(outer_scope_cname)
1751 # ----- Trace function call
1752 if profile or linetrace:
1753 # this looks a bit late, but if we don't get here due to a
1754 # fatal error before hand, it's not really worth tracing
1755 code.put_trace_call(self.entry.name, self.pos)
1756 code.funcstate.can_trace = True
1757 # ----- Fetch arguments
1758 self.generate_argument_parsing_code(env, code)
1759 # If an argument is assigned to in the body, we must
1760 # incref it to properly keep track of refcounts.
1761 is_cdef = isinstance(self, CFuncDefNode)
1762 for entry in lenv.arg_entries:
1763 if entry.type.is_pyobject:
1764 if ((acquire_gil or len(entry.cf_assignments) > 1) and
1765 not entry.in_closure):
1766 code.put_var_incref(entry)
1767
1768 # Note: defaults are always incref-ed. For def functions, we
1769 # we aquire arguments from object converstion, so we have
1770 # new references. If we are a cdef function, we need to
1771 # incref our arguments
1772 elif (is_cdef and entry.type.is_memoryviewslice and
1773 len(entry.cf_assignments) > 1):
1774 code.put_incref_memoryviewslice(entry.cname,
1775 have_gil=not lenv.nogil)
1776 for entry in lenv.var_entries:
1777 if entry.is_arg and len(entry.cf_assignments) > 1:
1778 code.put_var_incref(entry)
1779
1780 # ----- Initialise local buffer auxiliary variables
1781 for entry in lenv.var_entries + lenv.arg_entries:
1782 if entry.type.is_buffer and entry.buffer_aux.buflocal_nd_var.used:
1783 Buffer.put_init_vars(entry, code)
1784
1785 # ----- Check and convert arguments
1786 self.generate_argument_type_tests(code)
1787 # ----- Acquire buffer arguments
1788 for entry in lenv.arg_entries:
1789 if entry.type.is_buffer:
1790 Buffer.put_acquire_arg_buffer(entry, code, self.pos)
1791
1792 if acquire_gil_for_var_decls_only:
1793 code.put_release_ensured_gil()
1794
1795 # -------------------------
1796 # ----- Function body -----
1797 # -------------------------
1798 self.generate_function_body(env, code)
1799
1800 code.mark_pos(self.pos)
1801 code.putln("")
1802 code.putln("/* function exit code */")
1803
1804 # ----- Default return value
1805 if not self.body.is_terminator:
1806 if self.return_type.is_pyobject:
1807 #if self.return_type.is_extension_type:
1808 # lhs = "(PyObject *)%s" % Naming.retval_cname
1809 #else:
1810 lhs = Naming.retval_cname
1811 code.put_init_to_py_none(lhs, self.return_type)
1812 else:
1813 val = self.return_type.default_value
1814 if val:
1815 code.putln("%s = %s;" % (Naming.retval_cname, val))
1816 # ----- Error cleanup
1817 if code.error_label in code.labels_used:
1818 if not self.body.is_terminator:
1819 code.put_goto(code.return_label)
1820 code.put_label(code.error_label)
1821 for cname, type in code.funcstate.all_managed_temps():
1822 code.put_xdecref(cname, type, have_gil=not lenv.nogil)
1823
1824 # Clean up buffers -- this calls a Python function
1825 # so need to save and restore error state
1826 buffers_present = len(lenv.buffer_entries) > 0
1827 memslice_entries = [e for e in lenv.entries.itervalues()
1828 if e.type.is_memoryviewslice]
1829 if buffers_present:
1830 code.globalstate.use_utility_code(restore_exception_utility_code)
1831 code.putln("{ PyObject *__pyx_type, *__pyx_value, *__pyx_tb;")
1832 code.putln("__Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);")
1833 for entry in lenv.buffer_entries:
1834 Buffer.put_release_buffer_code(code, entry)
1835 #code.putln("%s = 0;" % entry.cname)
1836 code.putln("__Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}")
1837
1838 if self.return_type.is_memoryviewslice:
1839 MemoryView.put_init_entry(Naming.retval_cname, code)
1840 err_val = Naming.retval_cname
1841 else:
1842 err_val = self.error_value()
1843
1844 exc_check = self.caller_will_check_exceptions()
1845 if err_val is not None or exc_check:
1846 # TODO: Fix exception tracing (though currently unused by cProfile).
1847 # code.globalstate.use_utility_code(get_exception_tuple_utility_code)
1848 # code.put_trace_exception()
1849
1850 if lenv.nogil and not lenv.has_with_gil_block:
1851 code.putln("{")
1852 code.put_ensure_gil()
1853
1854 code.put_add_traceback(self.entry.qualified_name)
1855
1856 if lenv.nogil and not lenv.has_with_gil_block:
1857 code.put_release_ensured_gil()
1858 code.putln("}")
1859 else:
1860 warning(self.entry.pos,
1861 "Unraisable exception in function '%s'." %
1862 self.entry.qualified_name, 0)
1863 code.put_unraisable(self.entry.qualified_name)
1864 default_retval = self.return_type.default_value
1865 if err_val is None and default_retval:
1866 err_val = default_retval
1867 if err_val is not None:
1868 code.putln("%s = %s;" % (Naming.retval_cname, err_val))
1869
1870 if is_getbuffer_slot:
1871 self.getbuffer_error_cleanup(code)
1872
1873 # If we are using the non-error cleanup section we should
1874 # jump past it if we have an error. The if-test below determine
1875 # whether this section is used.
1876 if buffers_present or is_getbuffer_slot or self.return_type.is_memoryviewslice:
1877 code.put_goto(code.return_from_error_cleanup_label)
1878
1879 # ----- Non-error return cleanup
1880 code.put_label(code.return_label)
1881 for entry in lenv.buffer_entries:
1882 if entry.used:
1883 Buffer.put_release_buffer_code(code, entry)
1884 if is_getbuffer_slot:
1885 self.getbuffer_normal_cleanup(code)
1886
1887 if self.return_type.is_memoryviewslice:
1888 # See if our return value is uninitialized on non-error return
1889 # import MemoryView
1890 # MemoryView.err_if_nogil_initialized_check(self.pos, env)
1891 cond = code.unlikely(self.return_type.error_condition(
1892 Naming.retval_cname))
1893 code.putln(
1894 'if (%s) {' % cond)
1895 if env.nogil:
1896 code.put_ensure_gil()
1897 code.putln(
1898 'PyErr_SetString('
1899 'PyExc_TypeError,'
1900 '"Memoryview return value is not initialized");')
1901 if env.nogil:
1902 code.put_release_ensured_gil()
1903 code.putln(
1904 '}')
1905
1906 # ----- Return cleanup for both error and no-error return
1907 code.put_label(code.return_from_error_cleanup_label)
1908
1909 for entry in lenv.var_entries:
1910 if not entry.used or entry.in_closure:
1911 continue
1912
1913 if entry.type.is_memoryviewslice:
1914 code.put_xdecref_memoryviewslice(entry.cname,
1915 have_gil=not lenv.nogil)
1916 elif entry.type.is_pyobject:
1917 if not entry.is_arg or len(entry.cf_assignments) > 1:
1918 code.put_var_decref(entry)
1919
1920 # Decref any increfed args
1921 for entry in lenv.arg_entries:
1922 if entry.type.is_pyobject:
1923 if ((acquire_gil or len(entry.cf_assignments) > 1) and
1924 not entry.in_closure):
1925 code.put_var_decref(entry)
1926 elif (entry.type.is_memoryviewslice and
1927 (not is_cdef or len(entry.cf_assignments) > 1)):
1928 # decref slices of def functions and acquired slices from cdef
1929 # functions, but not borrowed slices from cdef functions.
1930 code.put_xdecref_memoryviewslice(entry.cname,
1931 have_gil=not lenv.nogil)
1932 if self.needs_closure:
1933 code.put_decref(Naming.cur_scope_cname, lenv.scope_class.type)
1934
1935 # ----- Return
1936 # This code is duplicated in ModuleNode.generate_module_init_func
1937 if not lenv.nogil:
1938 default_retval = self.return_type.default_value
1939 err_val = self.error_value()
1940 if err_val is None and default_retval:
1941 err_val = default_retval # FIXME: why is err_val not used?
1942 if self.return_type.is_pyobject:
1943 code.put_xgiveref(self.return_type.as_pyobject(Naming.retval_cname))
1944
1945 if self.entry.is_special and self.entry.name == "__hash__":
1946 # Returning -1 for __hash__ is supposed to signal an error
1947 # We do as Python instances and coerce -1 into -2.
1948 code.putln("if (unlikely(%s == -1) && !PyErr_Occurred()) %s = -2;" % (
1949 Naming.retval_cname, Naming.retval_cname))
1950
1951 if profile or linetrace:
1952 code.funcstate.can_trace = False
1953 if self.return_type.is_pyobject:
1954 code.put_trace_return(Naming.retval_cname)
1955 else:
1956 code.put_trace_return("Py_None")
1957
1958 if not lenv.nogil:
1959 # GIL holding function
1960 code.put_finish_refcount_context()
1961
1962 if acquire_gil or (lenv.nogil and lenv.has_with_gil_block):
1963 # release the GIL (note that with-gil blocks acquire it on exit in their EnsureGILNode)
1964 code.put_release_ensured_gil()
1965
1966 if not self.return_type.is_void:
1967 code.putln("return %s;" % Naming.retval_cname)
1968
1969 code.putln("}")
1970
1971 if preprocessor_guard:
1972 code.putln("#endif /*!(%s)*/" % preprocessor_guard)
1973
1974 # ----- Go back and insert temp variable declarations
1975 tempvardecl_code.put_temp_declarations(code.funcstate)
1976
1977 # ----- Python version
1978 code.exit_cfunc_scope()
1979 if self.py_func:
1980 self.py_func.generate_function_definitions(env, code)
1981 self.generate_wrapper_functions(code)
1982
1983 def declare_argument(self, env, arg):
1984 if arg.type.is_void:
1985 error(arg.pos, "Invalid use of 'void'")
1986 elif not arg.type.is_complete() and not (arg.type.is_array or arg.type.is_memoryviewslice):
1987 error(arg.pos,
1988 "Argument type '%s' is incomplete" % arg.type)
1989 return env.declare_arg(arg.name, arg.type, arg.pos)
1990
1991 def generate_arg_type_test(self, arg, code):
1992 # Generate type test for one argument.
1993 if arg.type.typeobj_is_available():
1994 code.globalstate.use_utility_code(
1995 UtilityCode.load_cached("ArgTypeTest", "FunctionArguments.c"))
1996 typeptr_cname = arg.type.typeptr_cname
1997 arg_code = "((PyObject *)%s)" % arg.entry.cname
1998 code.putln(
1999 'if (unlikely(!__Pyx_ArgTypeTest(%s, %s, %d, "%s", %s))) %s' % (
2000 arg_code,
2001 typeptr_cname,
2002 arg.accept_none,
2003 arg.name,
2004 arg.type.is_builtin_type,
2005 code.error_goto(arg.pos)))
2006 else:
2007 error(arg.pos, "Cannot test type of extern C class "
2008 "without type object name specification")
2009
2010 def generate_arg_none_check(self, arg, code):
2011 # Generate None check for one argument.
2012 if arg.type.is_memoryviewslice:
2013 cname = "%s.memview" % arg.entry.cname
2014 else:
2015 cname = arg.entry.cname
2016
2017 code.putln('if (unlikely(((PyObject *)%s) == Py_None)) {' % cname)
2018 code.putln('''PyErr_Format(PyExc_TypeError, "Argument '%%.%ds' must not be None", "%s"); %s''' % (
2019 max(200, len(arg.name)), arg.name,
2020 code.error_goto(arg.pos)))
2021 code.putln('}')
2022
2023 def generate_wrapper_functions(self, code):
2024 pass
2025
2026 def generate_execution_code(self, code):
2027 # Evaluate and store argument default values
2028 for arg in self.args:
2029 if not arg.is_dynamic:
2030 arg.generate_assignment_code(code)
2031
2032 #
2033 # Special code for the __getbuffer__ function
2034 #
2035 def getbuffer_init(self, code):
2036 info = self.local_scope.arg_entries[1].cname
2037 # Python 3.0 betas have a bug in memoryview which makes it call
2038 # getbuffer with a NULL parameter. For now we work around this;
2039 # the following block should be removed when this bug is fixed.
2040 code.putln("if (%s != NULL) {" % info)
2041 code.putln("%s->obj = Py_None; __Pyx_INCREF(Py_None);" % info)
2042 code.put_giveref("%s->obj" % info) # Do not refnanny object within structs
2043 code.putln("}")
2044
2045 def getbuffer_error_cleanup(self, code):
2046 info = self.local_scope.arg_entries[1].cname
2047 code.putln("if (%s != NULL && %s->obj != NULL) {"
2048 % (info, info))
2049 code.put_gotref("%s->obj" % info)
2050 code.putln("__Pyx_DECREF(%s->obj); %s->obj = NULL;"
2051 % (info, info))
2052 code.putln("}")
2053
2054 def getbuffer_normal_cleanup(self, code):
2055 info = self.local_scope.arg_entries[1].cname
2056 code.putln("if (%s != NULL && %s->obj == Py_None) {" % (info, info))
2057 code.put_gotref("Py_None")
2058 code.putln("__Pyx_DECREF(Py_None); %s->obj = NULL;" % info)
2059 code.putln("}")
2060
2061 def get_preprocessor_guard(self):
2062 if not self.entry.is_special:
2063 return None
2064 name = self.entry.name
2065 slot = TypeSlots.method_name_to_slot.get(name)
2066 if not slot:
2067 return None
2068 if name == '__long__' and not self.entry.scope.lookup_here('__int__'):
2069 return None
2070 if name in ("__getbuffer__", "__releasebuffer__") and self.entry.scope.is_c_class_scope:
2071 return None
2072 return slot.preprocessor_guard_code()
2073
2074
2075 class CFuncDefNode(FuncDefNode):
2076 # C function definition.
2077 #
2078 # modifiers ['inline']
2079 # visibility 'private' or 'public' or 'extern'
2080 # base_type CBaseTypeNode
2081 # declarator CDeclaratorNode
2082 # cfunc_declarator the CFuncDeclarator of this function
2083 # (this is also available through declarator or a
2084 # base thereof)
2085 # body StatListNode
2086 # api boolean
2087 # decorators [DecoratorNode] list of decorators
2088 #
2089 # with_gil boolean Acquire GIL around body
2090 # type CFuncType
2091 # py_func wrapper for calling from Python
2092 # overridable whether or not this is a cpdef function
2093 # inline_in_pxd whether this is an inline function in a pxd file
2094 # template_declaration String or None Used for c++ class methods
2095 # is_const_method whether this is a const method
2096
2097 child_attrs = ["base_type", "declarator", "body", "py_func"]
2098
2099 inline_in_pxd = False
2100 decorators = None
2101 directive_locals = None
2102 directive_returns = None
2103 override = None
2104 template_declaration = None
2105 is_const_method = False
2106
2107 def unqualified_name(self):
2108 return self.entry.name
2109
2110 def analyse_declarations(self, env):
2111 if self.directive_locals is None:
2112 self.directive_locals = {}
2113 self.directive_locals.update(env.directives['locals'])
2114 if self.directive_returns is not None:
2115 base_type = self.directive_returns.analyse_as_type(env)
2116 if base_type is None:
2117 error(self.directive_returns.pos, "Not a type")
2118 base_type = PyrexTypes.error_type
2119 else:
2120 base_type = self.base_type.analyse(env)
2121 # The 2 here is because we need both function and argument names.
2122 if isinstance(self.declarator, CFuncDeclaratorNode):
2123 name_declarator, type = self.declarator.analyse(base_type, env,
2124 nonempty = 2 * (self.body is not None),
2125 directive_locals = self.directive_locals)
2126 else:
2127 name_declarator, type = self.declarator.analyse(base_type, env, nonempty = 2 * (self.body is not None))
2128 if not type.is_cfunction:
2129 error(self.pos,
2130 "Suite attached to non-function declaration")
2131 # Remember the actual type according to the function header
2132 # written here, because the type in the symbol table entry
2133 # may be different if we're overriding a C method inherited
2134 # from the base type of an extension type.
2135 self.type = type
2136 type.is_overridable = self.overridable
2137 declarator = self.declarator
2138 while not hasattr(declarator, 'args'):
2139 declarator = declarator.base
2140
2141 self.cfunc_declarator = declarator
2142 self.args = declarator.args
2143
2144 opt_arg_count = self.cfunc_declarator.optional_arg_count
2145 if (self.visibility == 'public' or self.api) and opt_arg_count:
2146 error(self.cfunc_declarator.pos,
2147 "Function with optional arguments may not be declared "
2148 "public or api")
2149
2150 if (type.exception_check == '+' and self.visibility != 'extern'):
2151 warning(self.cfunc_declarator.pos,
2152 "Only extern functions can throw C++ exceptions.")
2153
2154 for formal_arg, type_arg in zip(self.args, type.args):
2155 self.align_argument_type(env, type_arg)
2156 formal_arg.type = type_arg.type
2157 formal_arg.name = type_arg.name
2158 formal_arg.cname = type_arg.cname
2159
2160 self._validate_type_visibility(type_arg.type, type_arg.pos, env)
2161
2162 if type_arg.type.is_fused:
2163 self.has_fused_arguments = True
2164
2165 if type_arg.type.is_buffer and 'inline' in self.modifiers:
2166 warning(formal_arg.pos, "Buffer unpacking not optimized away.", 1)
2167
2168 if type_arg.type.is_buffer:
2169 if self.type.nogil:
2170 error(formal_arg.pos,
2171 "Buffer may not be acquired without the GIL. "
2172 "Consider using memoryview slices instead.")
2173 elif 'inline' in self.modifiers:
2174 warning(formal_arg.pos, "Buffer unpacking not optimized away.", 1)
2175
2176 self._validate_type_visibility(type.return_type, self.pos, env)
2177
2178 name = name_declarator.name
2179 cname = name_declarator.cname
2180
2181 type.is_const_method = self.is_const_method
2182 self.entry = env.declare_cfunction(
2183 name, type, self.pos,
2184 cname = cname, visibility = self.visibility, api = self.api,
2185 defining = self.body is not None, modifiers = self.modifiers)
2186 self.entry.inline_func_in_pxd = self.inline_in_pxd
2187 self.return_type = type.return_type
2188 if self.return_type.is_array and self.visibility != 'extern':
2189 error(self.pos,
2190 "Function cannot return an array")
2191 if self.return_type.is_cpp_class:
2192 self.return_type.check_nullary_constructor(self.pos, "used as a return value")
2193
2194 if self.overridable and not env.is_module_scope:
2195 if len(self.args) < 1 or not self.args[0].type.is_pyobject:
2196 # An error will be produced in the cdef function
2197 self.overridable = False
2198
2199 self.declare_cpdef_wrapper(env)
2200 self.create_local_scope(env)
2201
2202 def declare_cpdef_wrapper(self, env):
2203 if self.overridable:
2204 name = self.entry.name
2205 py_func_body = self.call_self_node(is_module_scope = env.is_module_scope)
2206 self.py_func = DefNode(pos = self.pos,
2207 name = self.entry.name,
2208 args = self.args,
2209 star_arg = None,
2210 starstar_arg = None,
2211 doc = self.doc,
2212 body = py_func_body,
2213 is_wrapper = 1)
2214 self.py_func.is_module_scope = env.is_module_scope
2215 self.py_func.analyse_declarations(env)
2216 self.entry.as_variable = self.py_func.entry
2217 self.entry.used = self.entry.as_variable.used = True
2218 # Reset scope entry the above cfunction
2219 env.entries[name] = self.entry
2220 if (not self.entry.is_final_cmethod and
2221 (not env.is_module_scope or Options.lookup_module_cpdef)):
2222 self.override = OverrideCheckNode(self.pos, py_func = self.py_func)
2223 self.body = StatListNode(self.pos, stats=[self.override, self.body])
2224
2225 def _validate_type_visibility(self, type, pos, env):
2226 """
2227 Ensure that types used in cdef functions are public or api, or
2228 defined in a C header.
2229 """
2230 public_or_api = (self.visibility == 'public' or self.api)
2231 entry = getattr(type, 'entry', None)
2232 if public_or_api and entry and env.is_module_scope:
2233 if not (entry.visibility in ('public', 'extern') or
2234 entry.api or entry.in_cinclude):
2235 error(pos, "Function declared public or api may not have "
2236 "private types")
2237
2238 def call_self_node(self, omit_optional_args=0, is_module_scope=0):
2239 import ExprNodes
2240 args = self.type.args
2241 if omit_optional_args:
2242 args = args[:len(args) - self.type.optional_arg_count]
2243 arg_names = [arg.name for arg in args]
2244 if is_module_scope:
2245 cfunc = ExprNodes.NameNode(self.pos, name=self.entry.name)
2246 else:
2247 self_arg = ExprNodes.NameNode(self.pos, name=arg_names[0])
2248 cfunc = ExprNodes.AttributeNode(self.pos, obj=self_arg, attribute=self.entry.name)
2249 skip_dispatch = not is_module_scope or Options.lookup_module_cpdef
2250 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)
2251 return ReturnStatNode(pos=self.pos, return_type=PyrexTypes.py_object_type, value=c_call)
2252
2253 def declare_arguments(self, env):
2254 for arg in self.type.args:
2255 if not arg.name:
2256 error(arg.pos, "Missing argument name")
2257 self.declare_argument(env, arg)
2258
2259 def need_gil_acquisition(self, lenv):
2260 return self.type.with_gil
2261
2262 def nogil_check(self, env):
2263 type = self.type
2264 with_gil = type.with_gil
2265 if type.nogil and not with_gil:
2266 if type.return_type.is_pyobject:
2267 error(self.pos,
2268 "Function with Python return type cannot be declared nogil")
2269 for entry in self.local_scope.var_entries:
2270 if entry.type.is_pyobject and not entry.in_with_gil_block:
2271 error(self.pos, "Function declared nogil has Python locals or temporaries")
2272
2273 def analyse_expressions(self, env):
2274 self.local_scope.directives = env.directives
2275 if self.py_func is not None:
2276 # this will also analyse the default values
2277 self.py_func = self.py_func.analyse_expressions(env)
2278 else:
2279 self.analyse_default_values(env)
2280 self.acquire_gil = self.need_gil_acquisition(self.local_scope)
2281 return self
2282
2283 def needs_assignment_synthesis(self, env, code=None):
2284 return False
2285
2286 def generate_function_header(self, code, with_pymethdef, with_opt_args = 1, with_dispatch = 1, cname = None):
2287 scope = self.local_scope
2288 arg_decls = []
2289 type = self.type
2290 for arg in type.args[:len(type.args)-type.optional_arg_count]:
2291 arg_decl = arg.declaration_code()
2292 entry = scope.lookup(arg.name)
2293 if not entry.cf_used:
2294 arg_decl = 'CYTHON_UNUSED %s' % arg_decl
2295 arg_decls.append(arg_decl)
2296 if with_dispatch and self.overridable:
2297 dispatch_arg = PyrexTypes.c_int_type.declaration_code(
2298 Naming.skip_dispatch_cname)
2299 if self.override:
2300 arg_decls.append(dispatch_arg)
2301 else:
2302 arg_decls.append('CYTHON_UNUSED %s' % dispatch_arg)
2303 if type.optional_arg_count and with_opt_args:
2304 arg_decls.append(type.op_arg_struct.declaration_code(Naming.optional_args_cname))
2305 if type.has_varargs:
2306 arg_decls.append("...")
2307 if not arg_decls:
2308 arg_decls = ["void"]
2309 if cname is None:
2310 cname = self.entry.func_cname
2311 entity = type.function_header_code(cname, ', '.join(arg_decls))
2312 if self.entry.visibility == 'private' and '::' not in cname:
2313 storage_class = "static "
2314 else:
2315 storage_class = ""
2316 dll_linkage = None
2317 modifiers = code.build_function_modifiers(self.entry.func_modifiers)
2318
2319 header = self.return_type.declaration_code(entity, dll_linkage=dll_linkage)
2320 #print (storage_class, modifiers, header)
2321 if self.template_declaration:
2322 code.putln(self.template_declaration)
2323 code.putln("%s%s%s {" % (storage_class, modifiers, header))
2324
2325 def generate_argument_declarations(self, env, code):
2326 scope = self.local_scope
2327 for arg in self.args:
2328 if arg.default:
2329 entry = scope.lookup(arg.name)
2330 if self.override or entry.cf_used:
2331 result = arg.calculate_default_value_code(code)
2332 code.putln('%s = %s;' % (
2333 arg.type.declaration_code(arg.cname), result))
2334
2335 def generate_keyword_list(self, code):
2336 pass
2337
2338 def generate_argument_parsing_code(self, env, code):
2339 i = 0
2340 used = 0
2341 if self.type.optional_arg_count:
2342 scope = self.local_scope
2343 code.putln('if (%s) {' % Naming.optional_args_cname)
2344 for arg in self.args:
2345 if arg.default:
2346 entry = scope.lookup(arg.name)
2347 if self.override or entry.cf_used:
2348 code.putln('if (%s->%sn > %s) {' %
2349 (Naming.optional_args_cname,
2350 Naming.pyrex_prefix, i))
2351 declarator = arg.declarator
2352 while not hasattr(declarator, 'name'):
2353 declarator = declarator.base
2354 code.putln('%s = %s->%s;' %
2355 (arg.cname, Naming.optional_args_cname,
2356 self.type.opt_arg_cname(declarator.name)))
2357 used += 1
2358 i += 1
2359 for _ in range(used):
2360 code.putln('}')
2361 code.putln('}')
2362
2363 def generate_argument_conversion_code(self, code):
2364 pass
2365
2366 def generate_argument_type_tests(self, code):
2367 # Generate type tests for args whose type in a parent
2368 # class is a supertype of the declared type.
2369 for arg in self.type.args:
2370 if arg.needs_type_test:
2371 self.generate_arg_type_test(arg, code)
2372 elif arg.type.is_pyobject and not arg.accept_none:
2373 self.generate_arg_none_check(arg, code)
2374
2375 def error_value(self):
2376 if self.return_type.is_pyobject:
2377 return "0"
2378 else:
2379 #return None
2380 return self.entry.type.exception_value
2381
2382 def caller_will_check_exceptions(self):
2383 return self.entry.type.exception_check
2384
2385 def generate_wrapper_functions(self, code):
2386 # If the C signature of a function has changed, we need to generate
2387 # wrappers to put in the slots here.
2388 k = 0
2389 entry = self.entry
2390 func_type = entry.type
2391 while entry.prev_entry is not None:
2392 k += 1
2393 entry = entry.prev_entry
2394 entry.func_cname = "%s%swrap_%s" % (self.entry.func_cname, Naming.pyrex_prefix, k)
2395 code.putln()
2396 self.generate_function_header(code,
2397 0,
2398 with_dispatch = entry.type.is_overridable,
2399 with_opt_args = entry.type.optional_arg_count,
2400 cname = entry.func_cname)
2401 if not self.return_type.is_void:
2402 code.put('return ')
2403 args = self.type.args
2404 arglist = [arg.cname for arg in args[:len(args)-self.type.optional_arg_count]]
2405 if entry.type.is_overridable:
2406 arglist.append(Naming.skip_dispatch_cname)
2407 elif func_type.is_overridable:
2408 arglist.append('0')
2409 if entry.type.optional_arg_count:
2410 arglist.append(Naming.optional_args_cname)
2411 elif func_type.optional_arg_count:
2412 arglist.append('NULL')
2413 code.putln('%s(%s);' % (self.entry.func_cname, ', '.join(arglist)))
2414 code.putln('}')
2415
2416
2417 class PyArgDeclNode(Node):
2418 # Argument which must be a Python object (used
2419 # for * and ** arguments).
2420 #
2421 # name string
2422 # entry Symtab.Entry
2423 # annotation ExprNode or None Py3 argument annotation
2424 child_attrs = []
2425 is_self_arg = False
2426 is_type_arg = False
2427
2428 def generate_function_definitions(self, env, code):
2429 self.entry.generate_function_definitions(env, code)
2430
2431 class DecoratorNode(Node):
2432 # A decorator
2433 #
2434 # decorator NameNode or CallNode or AttributeNode
2435 child_attrs = ['decorator']
2436
2437
2438 class DefNode(FuncDefNode):
2439 # A Python function definition.
2440 #
2441 # name string the Python name of the function
2442 # lambda_name string the internal name of a lambda 'function'
2443 # decorators [DecoratorNode] list of decorators
2444 # args [CArgDeclNode] formal arguments
2445 # doc EncodedString or None
2446 # body StatListNode
2447 # return_type_annotation
2448 # ExprNode or None the Py3 return type annotation
2449 #
2450 # The following subnode is constructed internally
2451 # when the def statement is inside a Python class definition.
2452 #
2453 # fused_py_func DefNode The original fused cpdef DefNode
2454 # (in case this is a specialization)
2455 # specialized_cpdefs [DefNode] list of specialized cpdef DefNodes
2456 # py_cfunc_node PyCFunctionNode/InnerFunctionNode The PyCFunction to create and assign
2457 #
2458 # decorator_indirection IndirectionNode Used to remove __Pyx_Method_ClassMethod for fused functions
2459
2460 child_attrs = ["args", "star_arg", "starstar_arg", "body", "decorators"]
2461
2462 lambda_name = None
2463 reqd_kw_flags_cname = "0"
2464 is_wrapper = 0
2465 no_assignment_synthesis = 0
2466 decorators = None
2467 return_type_annotation = None
2468 entry = None
2469 acquire_gil = 0
2470 self_in_stararg = 0
2471 py_cfunc_node = None
2472 requires_classobj = False
2473 defaults_struct = None # Dynamic kwrds structure name
2474 doc = None
2475
2476 fused_py_func = False
2477 specialized_cpdefs = None
2478 py_wrapper = None
2479 py_wrapper_required = True
2480 func_cname = None
2481
2482 defaults_getter = None
2483
2484 def __init__(self, pos, **kwds):
2485 FuncDefNode.__init__(self, pos, **kwds)
2486 k = rk = r = 0
2487 for arg in self.args:
2488 if arg.kw_only:
2489 k += 1
2490 if not arg.default:
2491 rk += 1
2492 if not arg.default:
2493 r += 1
2494 self.num_kwonly_args = k
2495 self.num_required_kw_args = rk
2496 self.num_required_args = r
2497
2498 def as_cfunction(self, cfunc=None, scope=None, overridable=True, returns=None):
2499 if self.star_arg:
2500 error(self.star_arg.pos, "cdef function cannot have star argument")
2501 if self.starstar_arg:
2502 error(self.starstar_arg.pos, "cdef function cannot have starstar argument")
2503 if cfunc is None:
2504 cfunc_args = []
2505 for formal_arg in self.args:
2506 name_declarator, type = formal_arg.analyse(scope, nonempty=1)
2507 cfunc_args.append(PyrexTypes.CFuncTypeArg(name = name_declarator.name,
2508 cname = None,
2509 type = py_object_type,
2510 pos = formal_arg.pos))
2511 cfunc_type = PyrexTypes.CFuncType(return_type = py_object_type,
2512 args = cfunc_args,
2513 has_varargs = False,
2514 exception_value = None,
2515 exception_check = False,
2516 nogil = False,
2517 with_gil = False,
2518 is_overridable = overridable)
2519 cfunc = CVarDefNode(self.pos, type=cfunc_type)
2520 else:
2521 if scope is None:
2522 scope = cfunc.scope
2523 cfunc_type = cfunc.type
2524 if len(self.args) != len(cfunc_type.args) or cfunc_type.has_varargs:
2525 error(self.pos, "wrong number of arguments")
2526 error(cfunc.pos, "previous declaration here")
2527 for i, (formal_arg, type_arg) in enumerate(zip(self.args, cfunc_type.args)):
2528 name_declarator, type = formal_arg.analyse(scope, nonempty=1,
2529 is_self_arg = (i == 0 and scope.is_c_class_scope))
2530 if type is None or type is PyrexTypes.py_object_type:
2531 formal_arg.type = type_arg.type
2532 formal_arg.name_declarator = name_declarator
2533 import ExprNodes
2534 if cfunc_type.exception_value is None:
2535 exception_value = None
2536 else:
2537 exception_value = ExprNodes.ConstNode(self.pos, value=cfunc_type.exception_value, type=cfunc_type.return_type)
2538 declarator = CFuncDeclaratorNode(self.pos,
2539 base = CNameDeclaratorNode(self.pos, name=self.name, cname=None),
2540 args = self.args,
2541 has_varargs = False,
2542 exception_check = cfunc_type.exception_check,
2543 exception_value = exception_value,
2544 with_gil = cfunc_type.with_gil,
2545 nogil = cfunc_type.nogil)
2546 return CFuncDefNode(self.pos,
2547 modifiers = [],
2548 base_type = CAnalysedBaseTypeNode(self.pos, type=cfunc_type.return_type),
2549 declarator = declarator,
2550 body = self.body,
2551 doc = self.doc,
2552 overridable = cfunc_type.is_overridable,
2553 type = cfunc_type,
2554 with_gil = cfunc_type.with_gil,
2555 nogil = cfunc_type.nogil,
2556 visibility = 'private',
2557 api = False,
2558 directive_locals = getattr(cfunc, 'directive_locals', {}),
2559 directive_returns = returns)
2560
2561 def is_cdef_func_compatible(self):
2562 """Determines if the function's signature is compatible with a
2563 cdef function. This can be used before calling
2564 .as_cfunction() to see if that will be successful.
2565 """
2566 if self.needs_closure:
2567 return False
2568 if self.star_arg or self.starstar_arg:
2569 return False
2570 return True
2571
2572 def analyse_declarations(self, env):
2573 self.is_classmethod = self.is_staticmethod = False
2574 if self.decorators:
2575 for decorator in self.decorators:
2576 func = decorator.decorator
2577 if func.is_name:
2578 self.is_classmethod |= func.name == 'classmethod'
2579 self.is_staticmethod |= func.name == 'staticmethod'
2580
2581 if self.is_classmethod and env.lookup_here('classmethod'):
2582 # classmethod() was overridden - not much we can do here ...
2583 self.is_classmethod = False
2584 if self.is_staticmethod and env.lookup_here('staticmethod'):
2585 # staticmethod() was overridden - not much we can do here ...
2586 self.is_staticmethod = False
2587
2588 if self.name == '__new__' and env.is_py_class_scope:
2589 self.is_staticmethod = 1
2590
2591 self.analyse_argument_types(env)
2592 if self.name == '<lambda>':
2593 self.declare_lambda_function(env)
2594 else:
2595 self.declare_pyfunction(env)
2596
2597 self.analyse_signature(env)
2598 self.return_type = self.entry.signature.return_type()
2599 self.create_local_scope(env)
2600
2601 self.py_wrapper = DefNodeWrapper(
2602 self.pos,
2603 target=self,
2604 name=self.entry.name,
2605 args=self.args,
2606 star_arg=self.star_arg,
2607 starstar_arg=self.starstar_arg,
2608 return_type=self.return_type)
2609 self.py_wrapper.analyse_declarations(env)
2610
2611 def analyse_argument_types(self, env):
2612 self.directive_locals = env.directives['locals']
2613 allow_none_for_extension_args = env.directives['allow_none_for_extension_args']
2614
2615 f2s = env.fused_to_specific
2616 env.fused_to_specific = None
2617
2618 for arg in self.args:
2619 if hasattr(arg, 'name'):
2620 name_declarator = None
2621 else:
2622 base_type = arg.base_type.analyse(env)
2623 name_declarator, type = \
2624 arg.declarator.analyse(base_type, env)
2625 arg.name = name_declarator.name
2626 arg.type = type
2627
2628 if type.is_fused:
2629 self.has_fused_arguments = True
2630
2631 self.align_argument_type(env, arg)
2632 if name_declarator and name_declarator.cname:
2633 error(self.pos,
2634 "Python function argument cannot have C name specification")
2635 arg.type = arg.type.as_argument_type()
2636 arg.hdr_type = None
2637 arg.needs_conversion = 0
2638 arg.needs_type_test = 0
2639 arg.is_generic = 1
2640 if arg.type.is_pyobject or arg.type.is_buffer or arg.type.is_memoryviewslice:
2641 if arg.or_none:
2642 arg.accept_none = True
2643 elif arg.not_none:
2644 arg.accept_none = False
2645 elif (arg.type.is_extension_type or arg.type.is_builtin_type
2646 or arg.type.is_buffer or arg.type.is_memoryviewslice):
2647 if arg.default and arg.default.constant_result is None:
2648 # special case: def func(MyType obj = None)
2649 arg.accept_none = True
2650 else:
2651 # default depends on compiler directive
2652 arg.accept_none = allow_none_for_extension_args
2653 else:
2654 # probably just a plain 'object'
2655 arg.accept_none = True
2656 else:
2657 arg.accept_none = True # won't be used, but must be there
2658 if arg.not_none:
2659 error(arg.pos, "Only Python type arguments can have 'not None'")
2660 if arg.or_none:
2661 error(arg.pos, "Only Python type arguments can have 'or None'")
2662
2663 env.fused_to_specific = f2s
2664
2665 def analyse_signature(self, env):
2666 if self.entry.is_special:
2667 if self.decorators:
2668 error(self.pos, "special functions of cdef classes cannot have decorators")
2669 self.entry.trivial_signature = len(self.args) == 1 and not (self.star_arg or self.starstar_arg)
2670 elif not env.directives['always_allow_keywords'] and not (self.star_arg or self.starstar_arg):
2671 # Use the simpler calling signature for zero- and one-argument functions.
2672 if self.entry.signature is TypeSlots.pyfunction_signature:
2673 if len(self.args) == 0:
2674 self.entry.signature = TypeSlots.pyfunction_noargs
2675 elif len(self.args) == 1:
2676 if self.args[0].default is None and not self.args[0].kw_only:
2677 self.entry.signature = TypeSlots.pyfunction_onearg
2678 elif self.entry.signature is TypeSlots.pymethod_signature:
2679 if len(self.args) == 1:
2680 self.entry.signature = TypeSlots.unaryfunc
2681 elif len(self.args) == 2:
2682 if self.args[1].default is None and not self.args[1].kw_only:
2683 self.entry.signature = TypeSlots.ibinaryfunc
2684
2685 sig = self.entry.signature
2686 nfixed = sig.num_fixed_args()
2687 if sig is TypeSlots.pymethod_signature and nfixed == 1 \
2688 and len(self.args) == 0 and self.star_arg:
2689 # this is the only case where a diverging number of
2690 # arguments is not an error - when we have no explicit
2691 # 'self' parameter as in method(*args)
2692 sig = self.entry.signature = TypeSlots.pyfunction_signature # self is not 'really' used
2693 self.self_in_stararg = 1
2694 nfixed = 0
2695
2696 if self.is_staticmethod and env.is_c_class_scope:
2697 nfixed = 0
2698 self.self_in_stararg = True # FIXME: why for staticmethods?
2699
2700 self.entry.signature = sig = copy.copy(sig)
2701 sig.fixed_arg_format = "*"
2702 sig.is_staticmethod = True
2703 sig.has_generic_args = True
2704
2705 if ((self.is_classmethod or self.is_staticmethod) and
2706 self.has_fused_arguments and env.is_c_class_scope):
2707 del self.decorator_indirection.stats[:]
2708
2709 for i in range(min(nfixed, len(self.args))):
2710 arg = self.args[i]
2711 arg.is_generic = 0
2712 if sig.is_self_arg(i) and not self.is_staticmethod:
2713 if self.is_classmethod:
2714 arg.is_type_arg = 1
2715 arg.hdr_type = arg.type = Builtin.type_type
2716 else:
2717 arg.is_self_arg = 1
2718 arg.hdr_type = arg.type = env.parent_type
2719 arg.needs_conversion = 0
2720 else:
2721 arg.hdr_type = sig.fixed_arg_type(i)
2722 if not arg.type.same_as(arg.hdr_type):
2723 if arg.hdr_type.is_pyobject and arg.type.is_pyobject:
2724 arg.needs_type_test = 1
2725 else:
2726 arg.needs_conversion = 1
2727 if arg.needs_conversion:
2728 arg.hdr_cname = Naming.arg_prefix + arg.name
2729 else:
2730 arg.hdr_cname = Naming.var_prefix + arg.name
2731
2732 if nfixed > len(self.args):
2733 self.bad_signature()
2734 return
2735 elif nfixed < len(self.args):
2736 if not sig.has_generic_args:
2737 self.bad_signature()
2738 for arg in self.args:
2739 if arg.is_generic and \
2740 (arg.type.is_extension_type or arg.type.is_builtin_type):
2741 arg.needs_type_test = 1
2742
2743 def bad_signature(self):
2744 sig = self.entry.signature
2745 expected_str = "%d" % sig.num_fixed_args()
2746 if sig.has_generic_args:
2747 expected_str += " or more"
2748 name = self.name
2749 if name.startswith("__") and name.endswith("__"):
2750 desc = "Special method"
2751 else:
2752 desc = "Method"
2753 error(self.pos,
2754 "%s %s has wrong number of arguments "
2755 "(%d declared, %s expected)" % (
2756 desc, self.name, len(self.args), expected_str))
2757
2758 def declare_pyfunction(self, env):
2759 #print "DefNode.declare_pyfunction:", self.name, "in", env ###
2760 name = self.name
2761 entry = env.lookup_here(name)
2762 if entry:
2763 if entry.is_final_cmethod and not env.parent_type.is_final_type:
2764 error(self.pos, "Only final types can have final Python (def/cpdef) methods")
2765 if (entry.type.is_cfunction and not entry.is_builtin_cmethod
2766 and not self.is_wrapper):
2767 warning(self.pos, "Overriding cdef method with def method.", 5)
2768 entry = env.declare_pyfunction(name, self.pos, allow_redefine=not self.is_wrapper)
2769 self.entry = entry
2770 prefix = env.next_id(env.scope_prefix)
2771 self.entry.pyfunc_cname = Naming.pyfunc_prefix + prefix + name
2772 if Options.docstrings:
2773 entry.doc = embed_position(self.pos, self.doc)
2774 entry.doc_cname = Naming.funcdoc_prefix + prefix + name
2775 if entry.is_special:
2776 if entry.name in TypeSlots.invisible or not entry.doc or (entry.name in '__getattr__' and env.directives['fast_getattr']):
2777 entry.wrapperbase_cname = None
2778 else:
2779 entry.wrapperbase_cname = Naming.wrapperbase_prefix + prefix + name
2780 else:
2781 entry.doc = None
2782
2783 def declare_lambda_function(self, env):
2784 entry = env.declare_lambda_function(self.lambda_name, self.pos)
2785 entry.doc = None
2786 self.entry = entry
2787 self.entry.pyfunc_cname = entry.cname
2788
2789 def declare_arguments(self, env):
2790 for arg in self.args:
2791 if not arg.name:
2792 error(arg.pos, "Missing argument name")
2793 if arg.needs_conversion:
2794 arg.entry = env.declare_var(arg.name, arg.type, arg.pos)
2795 if arg.type.is_pyobject:
2796 arg.entry.init = "0"
2797 else:
2798 arg.entry = self.declare_argument(env, arg)
2799 arg.entry.is_arg = 1
2800 arg.entry.used = 1
2801 arg.entry.is_self_arg = arg.is_self_arg
2802 self.declare_python_arg(env, self.star_arg)
2803 self.declare_python_arg(env, self.starstar_arg)
2804
2805 def declare_python_arg(self, env, arg):
2806 if arg:
2807 if env.directives['infer_types'] != False:
2808 type = PyrexTypes.unspecified_type
2809 else:
2810 type = py_object_type
2811 entry = env.declare_var(arg.name, type, arg.pos)
2812 entry.is_arg = 1
2813 entry.used = 1
2814 entry.init = "0"
2815 entry.xdecref_cleanup = 1
2816 arg.entry = entry
2817
2818 def analyse_expressions(self, env):
2819 self.local_scope.directives = env.directives
2820 self.analyse_default_values(env)
2821
2822 if not self.needs_assignment_synthesis(env) and self.decorators:
2823 for decorator in self.decorators[::-1]:
2824 decorator.decorator = decorator.decorator.analyse_expressions(env)
2825
2826 self.py_wrapper.prepare_argument_coercion(env)
2827 return self
2828
2829 def needs_assignment_synthesis(self, env, code=None):
2830 if self.is_wrapper or self.specialized_cpdefs or self.entry.is_fused_specialized:
2831 return False
2832 if self.is_staticmethod:
2833 return True
2834 if self.no_assignment_synthesis:
2835 return False
2836 # Should enable for module level as well, that will require more testing...
2837 if self.entry.is_anonymous:
2838 return True
2839 if env.is_module_scope:
2840 if code is None:
2841 return env.directives['binding']
2842 else:
2843 return code.globalstate.directives['binding']
2844 return env.is_py_class_scope or env.is_closure_scope
2845
2846 def error_value(self):
2847 return self.entry.signature.error_value
2848
2849 def caller_will_check_exceptions(self):
2850 return self.entry.signature.exception_check
2851
2852 def generate_function_definitions(self, env, code):
2853 if self.defaults_getter:
2854 self.defaults_getter.generate_function_definitions(env, code)
2855
2856 # Before closure cnames are mangled
2857 if self.py_wrapper_required:
2858 # func_cname might be modified by @cname
2859 self.py_wrapper.func_cname = self.entry.func_cname
2860 self.py_wrapper.generate_function_definitions(env, code)
2861 FuncDefNode.generate_function_definitions(self, env, code)
2862
2863 def generate_function_header(self, code, with_pymethdef, proto_only=0):
2864 if proto_only:
2865 if self.py_wrapper_required:
2866 self.py_wrapper.generate_function_header(
2867 code, with_pymethdef, True)
2868 return
2869 arg_code_list = []
2870 if self.entry.signature.has_dummy_arg:
2871 self_arg = 'PyObject *%s' % Naming.self_cname
2872 if not self.needs_outer_scope:
2873 self_arg = 'CYTHON_UNUSED ' + self_arg
2874 arg_code_list.append(self_arg)
2875
2876 def arg_decl_code(arg):
2877 entry = arg.entry
2878 if entry.in_closure:
2879 cname = entry.original_cname
2880 else:
2881 cname = entry.cname
2882 decl = entry.type.declaration_code(cname)
2883 if not entry.cf_used:
2884 decl = 'CYTHON_UNUSED ' + decl
2885 return decl
2886
2887 for arg in self.args:
2888 arg_code_list.append(arg_decl_code(arg))
2889 if self.star_arg:
2890 arg_code_list.append(arg_decl_code(self.star_arg))
2891 if self.starstar_arg:
2892 arg_code_list.append(arg_decl_code(self.starstar_arg))
2893 arg_code = ', '.join(arg_code_list)
2894 dc = self.return_type.declaration_code(self.entry.pyfunc_cname)
2895
2896 decls_code = code.globalstate['decls']
2897 preprocessor_guard = self.get_preprocessor_guard()
2898 if preprocessor_guard:
2899 decls_code.putln(preprocessor_guard)
2900 decls_code.putln(
2901 "static %s(%s); /* proto */" % (dc, arg_code))
2902 if preprocessor_guard:
2903 decls_code.putln("#endif")
2904 code.putln("static %s(%s) {" % (dc, arg_code))
2905
2906 def generate_argument_declarations(self, env, code):
2907 pass
2908
2909 def generate_keyword_list(self, code):
2910 pass
2911
2912 def generate_argument_parsing_code(self, env, code):
2913 # Move arguments into closure if required
2914 def put_into_closure(entry):
2915 if entry.in_closure:
2916 code.putln('%s = %s;' % (entry.cname, entry.original_cname))
2917 code.put_var_incref(entry)
2918 code.put_var_giveref(entry)
2919 for arg in self.args:
2920 put_into_closure(arg.entry)
2921 for arg in self.star_arg, self.starstar_arg:
2922 if arg:
2923 put_into_closure(arg.entry)
2924
2925 def generate_argument_type_tests(self, code):
2926 pass
2927
2928
2929 class DefNodeWrapper(FuncDefNode):
2930 # DefNode python wrapper code generator
2931
2932 defnode = None
2933 target = None # Target DefNode
2934
2935 def __init__(self, *args, **kwargs):
2936 FuncDefNode.__init__(self, *args, **kwargs)
2937 self.num_kwonly_args = self.target.num_kwonly_args
2938 self.num_required_kw_args = self.target.num_required_kw_args
2939 self.num_required_args = self.target.num_required_args
2940 self.self_in_stararg = self.target.self_in_stararg
2941 self.signature = None
2942
2943 def analyse_declarations(self, env):
2944 target_entry = self.target.entry
2945 name = self.name
2946 prefix = env.next_id(env.scope_prefix)
2947 target_entry.func_cname = Naming.pywrap_prefix + prefix + name
2948 target_entry.pymethdef_cname = Naming.pymethdef_prefix + prefix + name
2949
2950 self.signature = target_entry.signature
2951
2952 def prepare_argument_coercion(self, env):
2953 # This is only really required for Cython utility code at this time,
2954 # everything else can be done during code generation. But we expand
2955 # all utility code here, simply because we cannot easily distinguish
2956 # different code types.
2957 for arg in self.args:
2958 if not arg.type.is_pyobject:
2959 if not arg.type.create_from_py_utility_code(env):
2960 pass # will fail later
2961 elif arg.hdr_type and not arg.hdr_type.is_pyobject:
2962 if not arg.hdr_type.create_to_py_utility_code(env):
2963 pass # will fail later
2964
2965 def signature_has_nongeneric_args(self):
2966 argcount = len(self.args)
2967 if argcount == 0 or (
2968 argcount == 1 and (self.args[0].is_self_arg or
2969 self.args[0].is_type_arg)):
2970 return 0
2971 return 1
2972
2973 def signature_has_generic_args(self):
2974 return self.signature.has_generic_args
2975
2976 def generate_function_body(self, code):
2977 args = []
2978 if self.signature.has_dummy_arg:
2979 args.append(Naming.self_cname)
2980 for arg in self.args:
2981 if arg.hdr_type and not (arg.type.is_memoryviewslice or
2982 arg.type.is_struct or
2983 arg.type.is_complex):
2984 args.append(arg.type.cast_code(arg.entry.cname))
2985 else:
2986 args.append(arg.entry.cname)
2987 if self.star_arg:
2988 args.append(self.star_arg.entry.cname)
2989 if self.starstar_arg:
2990 args.append(self.starstar_arg.entry.cname)
2991 args = ', '.join(args)
2992 if not self.return_type.is_void:
2993 code.put('%s = ' % Naming.retval_cname)
2994 code.putln('%s(%s);' % (
2995 self.target.entry.pyfunc_cname, args))
2996
2997 def generate_function_definitions(self, env, code):
2998 lenv = self.target.local_scope
2999 # Generate C code for header and body of function
3000 code.mark_pos(self.pos)
3001 code.putln("")
3002 code.putln("/* Python wrapper */")
3003 preprocessor_guard = self.target.get_preprocessor_guard()
3004 if preprocessor_guard:
3005 code.putln(preprocessor_guard)
3006
3007 code.enter_cfunc_scope()
3008 code.return_from_error_cleanup_label = code.new_label()
3009
3010 with_pymethdef = (self.target.needs_assignment_synthesis(env, code) or
3011 self.target.pymethdef_required)
3012 self.generate_function_header(code, with_pymethdef)
3013 self.generate_argument_declarations(lenv, code)
3014 tempvardecl_code = code.insertion_point()
3015
3016 if self.return_type.is_pyobject:
3017 retval_init = ' = 0'
3018 else:
3019 retval_init = ''
3020 if not self.return_type.is_void:
3021 code.putln('%s%s;' % (
3022 self.return_type.declaration_code(Naming.retval_cname),
3023 retval_init))
3024 code.put_declare_refcount_context()
3025 code.put_setup_refcount_context('%s (wrapper)' % self.name)
3026
3027 self.generate_argument_parsing_code(lenv, code)
3028 self.generate_argument_type_tests(code)
3029 self.generate_function_body(code)
3030
3031 # ----- Go back and insert temp variable declarations
3032 tempvardecl_code.put_temp_declarations(code.funcstate)
3033
3034 code.mark_pos(self.pos)
3035 code.putln("")
3036 code.putln("/* function exit code */")
3037
3038 # ----- Error cleanup
3039 if code.error_label in code.labels_used:
3040 code.put_goto(code.return_label)
3041 code.put_label(code.error_label)
3042 for cname, type in code.funcstate.all_managed_temps():
3043 code.put_xdecref(cname, type)
3044 err_val = self.error_value()
3045 if err_val is not None:
3046 code.putln("%s = %s;" % (Naming.retval_cname, err_val))
3047
3048 # ----- Non-error return cleanup
3049 code.put_label(code.return_label)
3050 for entry in lenv.var_entries:
3051 if entry.is_arg and entry.type.is_pyobject:
3052 code.put_var_decref(entry)
3053
3054 code.put_finish_refcount_context()
3055 if not self.return_type.is_void:
3056 code.putln("return %s;" % Naming.retval_cname)
3057 code.putln('}')
3058 code.exit_cfunc_scope()
3059 if preprocessor_guard:
3060 code.putln("#endif /*!(%s)*/" % preprocessor_guard)
3061
3062 def generate_function_header(self, code, with_pymethdef, proto_only=0):
3063 arg_code_list = []
3064 sig = self.signature
3065
3066 if sig.has_dummy_arg or self.self_in_stararg:
3067 arg_code = "PyObject *%s" % Naming.self_cname
3068 if not sig.has_dummy_arg:
3069 arg_code = 'CYTHON_UNUSED ' + arg_code
3070 arg_code_list.append(arg_code)
3071
3072 for arg in self.args:
3073 if not arg.is_generic:
3074 if arg.is_self_arg or arg.is_type_arg:
3075 arg_code_list.append("PyObject *%s" % arg.hdr_cname)
3076 else:
3077 arg_code_list.append(
3078 arg.hdr_type.declaration_code(arg.hdr_cname))
3079 entry = self.target.entry
3080 if not entry.is_special and sig.method_flags() == [TypeSlots.method_noargs]:
3081 arg_code_list.append("CYTHON_UNUSED PyObject *unused")
3082 if entry.scope.is_c_class_scope and entry.name == "__ipow__":
3083 arg_code_list.append("CYTHON_UNUSED PyObject *unused")
3084 if sig.has_generic_args:
3085 arg_code_list.append(
3086 "PyObject *%s, PyObject *%s"
3087 % (Naming.args_cname, Naming.kwds_cname))
3088 arg_code = ", ".join(arg_code_list)
3089
3090 # Prevent warning: unused function '__pyx_pw_5numpy_7ndarray_1__getbuffer__'
3091 mf = ""
3092 if (entry.name in ("__getbuffer__", "__releasebuffer__")
3093 and entry.scope.is_c_class_scope):
3094 mf = "CYTHON_UNUSED "
3095 with_pymethdef = False
3096
3097 dc = self.return_type.declaration_code(entry.func_cname)
3098 header = "static %s%s(%s)" % (mf, dc, arg_code)
3099 code.putln("%s; /*proto*/" % header)
3100
3101 if proto_only:
3102 if self.target.fused_py_func:
3103 # If we are the specialized version of the cpdef, we still
3104 # want the prototype for the "fused cpdef", in case we're
3105 # checking to see if our method was overridden in Python
3106 self.target.fused_py_func.generate_function_header(
3107 code, with_pymethdef, proto_only=True)
3108 return
3109
3110 if (Options.docstrings and entry.doc and
3111 not self.target.fused_py_func and
3112 not entry.scope.is_property_scope and
3113 (not entry.is_special or entry.wrapperbase_cname)):
3114 # h_code = code.globalstate['h_code']
3115 docstr = entry.doc
3116
3117 if docstr.is_unicode:
3118 docstr = docstr.utf8encode()
3119
3120 code.putln(
3121 'static char %s[] = "%s";' % (
3122 entry.doc_cname,
3123 split_string_literal(escape_byte_string(docstr))))
3124
3125 if entry.is_special:
3126 code.putln('#if CYTHON_COMPILING_IN_CPYTHON')
3127 code.putln(
3128 "struct wrapperbase %s;" % entry.wrapperbase_cname)
3129 code.putln('#endif')
3130
3131 if with_pymethdef or self.target.fused_py_func:
3132 code.put(
3133 "static PyMethodDef %s = " %
3134 entry.pymethdef_cname)
3135 code.put_pymethoddef(self.target.entry, ";", allow_skip=False)
3136 code.putln("%s {" % header)
3137
3138 def generate_argument_declarations(self, env, code):
3139 for arg in self.args:
3140 if arg.is_generic:
3141 if arg.needs_conversion:
3142 code.putln("PyObject *%s = 0;" % arg.hdr_cname)
3143 else:
3144 code.put_var_declaration(arg.entry)
3145 for entry in env.var_entries:
3146 if entry.is_arg:
3147 code.put_var_declaration(entry)
3148
3149 def generate_argument_parsing_code(self, env, code):
3150 # Generate fast equivalent of PyArg_ParseTuple call for
3151 # generic arguments, if any, including args/kwargs
3152 old_error_label = code.new_error_label()
3153 our_error_label = code.error_label
3154 end_label = code.new_label("argument_unpacking_done")
3155
3156 has_kwonly_args = self.num_kwonly_args > 0
3157 has_star_or_kw_args = self.star_arg is not None \
3158 or self.starstar_arg is not None or has_kwonly_args
3159
3160 for arg in self.args:
3161 if not arg.type.is_pyobject:
3162 if not arg.type.create_from_py_utility_code(env):
3163 pass # will fail later
3164
3165 if not self.signature_has_generic_args():
3166 if has_star_or_kw_args:
3167 error(self.pos, "This method cannot have * or keyword arguments")
3168 self.generate_argument_conversion_code(code)
3169
3170 elif not self.signature_has_nongeneric_args():
3171 # func(*args) or func(**kw) or func(*args, **kw)
3172 self.generate_stararg_copy_code(code)
3173
3174 else:
3175 self.generate_tuple_and_keyword_parsing_code(self.args, end_label, code)
3176
3177 code.error_label = old_error_label
3178 if code.label_used(our_error_label):
3179 if not code.label_used(end_label):
3180 code.put_goto(end_label)
3181 code.put_label(our_error_label)
3182 if has_star_or_kw_args:
3183 self.generate_arg_decref(self.star_arg, code)
3184 if self.starstar_arg:
3185 if self.starstar_arg.entry.xdecref_cleanup:
3186 code.put_var_xdecref_clear(self.starstar_arg.entry)
3187 else:
3188 code.put_var_decref_clear(self.starstar_arg.entry)
3189 code.put_add_traceback(self.target.entry.qualified_name)
3190 code.put_finish_refcount_context()
3191 code.putln("return %s;" % self.error_value())
3192 if code.label_used(end_label):
3193 code.put_label(end_label)
3194
3195 def generate_arg_xdecref(self, arg, code):
3196 if arg:
3197 code.put_var_xdecref_clear(arg.entry)
3198
3199 def generate_arg_decref(self, arg, code):
3200 if arg:
3201 code.put_var_decref_clear(arg.entry)
3202
3203 def generate_stararg_copy_code(self, code):
3204 if not self.star_arg:
3205 code.globalstate.use_utility_code(
3206 UtilityCode.load_cached("RaiseArgTupleInvalid", "FunctionArguments.c"))
3207 code.putln("if (unlikely(PyTuple_GET_SIZE(%s) > 0)) {" %
3208 Naming.args_cname)
3209 code.put('__Pyx_RaiseArgtupleInvalid("%s", 1, 0, 0, PyTuple_GET_SIZE(%s)); return %s;' % (
3210 self.name, Naming.args_cname, self.error_value()))
3211 code.putln("}")
3212
3213 if self.starstar_arg:
3214 if self.star_arg:
3215 kwarg_check = "unlikely(%s)" % Naming.kwds_cname
3216 else:
3217 kwarg_check = "%s" % Naming.kwds_cname
3218 else:
3219 kwarg_check = "unlikely(%s) && unlikely(PyDict_Size(%s) > 0)" % (
3220 Naming.kwds_cname, Naming.kwds_cname)
3221 code.globalstate.use_utility_code(
3222 UtilityCode.load_cached("KeywordStringCheck", "FunctionArguments.c"))
3223 code.putln(
3224 "if (%s && unlikely(!__Pyx_CheckKeywordStrings(%s, \"%s\", %d))) return %s;" % (
3225 kwarg_check, Naming.kwds_cname, self.name,
3226 bool(self.starstar_arg), self.error_value()))
3227
3228 if self.starstar_arg:
3229 code.putln("%s = (%s) ? PyDict_Copy(%s) : PyDict_New();" % (
3230 self.starstar_arg.entry.cname,
3231 Naming.kwds_cname,
3232 Naming.kwds_cname))
3233 code.putln("if (unlikely(!%s)) return %s;" % (
3234 self.starstar_arg.entry.cname, self.error_value()))
3235 self.starstar_arg.entry.xdecref_cleanup = 0
3236 code.put_gotref(self.starstar_arg.entry.cname)
3237
3238 if self.self_in_stararg and not self.target.is_staticmethod:
3239 # need to create a new tuple with 'self' inserted as first item
3240 code.put("%s = PyTuple_New(PyTuple_GET_SIZE(%s)+1); if (unlikely(!%s)) " % (
3241 self.star_arg.entry.cname,
3242 Naming.args_cname,
3243 self.star_arg.entry.cname))
3244 if self.starstar_arg:
3245 code.putln("{")
3246 code.put_decref_clear(self.starstar_arg.entry.cname, py_object_type)
3247 code.putln("return %s;" % self.error_value())
3248 code.putln("}")
3249 else:
3250 code.putln("return %s;" % self.error_value())
3251 code.put_gotref(self.star_arg.entry.cname)
3252 code.put_incref(Naming.self_cname, py_object_type)
3253 code.put_giveref(Naming.self_cname)
3254 code.putln("PyTuple_SET_ITEM(%s, 0, %s);" % (
3255 self.star_arg.entry.cname, Naming.self_cname))
3256 temp = code.funcstate.allocate_temp(PyrexTypes.c_py_ssize_t_type, manage_ref=False)
3257 code.putln("for (%s=0; %s < PyTuple_GET_SIZE(%s); %s++) {" % (
3258 temp, temp, Naming.args_cname, temp))
3259 code.putln("PyObject* item = PyTuple_GET_ITEM(%s, %s);" % (
3260 Naming.args_cname, temp))
3261 code.put_incref("item", py_object_type)
3262 code.put_giveref("item")
3263 code.putln("PyTuple_SET_ITEM(%s, %s+1, item);" % (
3264 self.star_arg.entry.cname, temp))
3265 code.putln("}")
3266 code.funcstate.release_temp(temp)
3267 self.star_arg.entry.xdecref_cleanup = 0
3268 elif self.star_arg:
3269 code.put_incref(Naming.args_cname, py_object_type)
3270 code.putln("%s = %s;" % (
3271 self.star_arg.entry.cname,
3272 Naming.args_cname))
3273 self.star_arg.entry.xdecref_cleanup = 0
3274
3275 def generate_tuple_and_keyword_parsing_code(self, args, success_label, code):
3276 argtuple_error_label = code.new_label("argtuple_error")
3277
3278 positional_args = []
3279 required_kw_only_args = []
3280 optional_kw_only_args = []
3281 for arg in args:
3282 if arg.is_generic:
3283 if arg.default:
3284 if not arg.is_self_arg and not arg.is_type_arg:
3285 if arg.kw_only:
3286 optional_kw_only_args.append(arg)
3287 else:
3288 positional_args.append(arg)
3289 elif arg.kw_only:
3290 required_kw_only_args.append(arg)
3291 elif not arg.is_self_arg and not arg.is_type_arg:
3292 positional_args.append(arg)
3293
3294 # sort required kw-only args before optional ones to avoid special
3295 # cases in the unpacking code
3296 kw_only_args = required_kw_only_args + optional_kw_only_args
3297
3298 min_positional_args = self.num_required_args - self.num_required_kw_args
3299 if len(args) > 0 and (args[0].is_self_arg or args[0].is_type_arg):
3300 min_positional_args -= 1
3301 max_positional_args = len(positional_args)
3302 has_fixed_positional_count = not self.star_arg and \
3303 min_positional_args == max_positional_args
3304 has_kw_only_args = bool(kw_only_args)
3305
3306 if self.num_required_kw_args:
3307 code.globalstate.use_utility_code(
3308 UtilityCode.load_cached("RaiseKeywordRequired", "FunctionArguments.c"))
3309
3310 if self.starstar_arg or self.star_arg:
3311 self.generate_stararg_init_code(max_positional_args, code)
3312
3313 code.putln('{')
3314 all_args = tuple(positional_args) + tuple(kw_only_args)
3315 code.putln("static PyObject **%s[] = {%s,0};" % (
3316 Naming.pykwdlist_cname,
3317 ','.join([ '&%s' % code.intern_identifier(arg.name)
3318 for arg in all_args ])))
3319
3320 # Before being converted and assigned to the target variables,
3321 # borrowed references to all unpacked argument values are
3322 # collected into a local PyObject* array called "values",
3323 # regardless if they were taken from default arguments,
3324 # positional arguments or keyword arguments. Note that
3325 # C-typed default arguments are handled at conversion time,
3326 # so their array value is NULL in the end if no argument
3327 # was passed for them.
3328 self.generate_argument_values_setup_code(all_args, code)
3329
3330 # --- optimised code when we receive keyword arguments
3331 code.putln("if (%s(%s)) {" % (
3332 (self.num_required_kw_args > 0) and "likely" or "unlikely",
3333 Naming.kwds_cname))
3334 self.generate_keyword_unpacking_code(
3335 min_positional_args, max_positional_args,
3336 has_fixed_positional_count, has_kw_only_args,
3337 all_args, argtuple_error_label, code)
3338
3339 # --- optimised code when we do not receive any keyword arguments
3340 if (self.num_required_kw_args and min_positional_args > 0) or min_positional_args == max_positional_args:
3341 # Python raises arg tuple related errors first, so we must
3342 # check the length here
3343 if min_positional_args == max_positional_args and not self.star_arg:
3344 compare = '!='
3345 else:
3346 compare = '<'
3347 code.putln('} else if (PyTuple_GET_SIZE(%s) %s %d) {' % (
3348 Naming.args_cname, compare, min_positional_args))
3349 code.put_goto(argtuple_error_label)
3350
3351 if self.num_required_kw_args:
3352 # pure error case: keywords required but not passed
3353 if max_positional_args > min_positional_args and not self.star_arg:
3354 code.putln('} else if (PyTuple_GET_SIZE(%s) > %d) {' % (
3355 Naming.args_cname, max_positional_args))
3356 code.put_goto(argtuple_error_label)
3357 code.putln('} else {')
3358 for i, arg in enumerate(kw_only_args):
3359 if not arg.default:
3360 pystring_cname = code.intern_identifier(arg.name)
3361 # required keyword-only argument missing
3362 code.put('__Pyx_RaiseKeywordRequired("%s", %s); ' % (
3363 self.name,
3364 pystring_cname))
3365 code.putln(code.error_goto(self.pos))
3366 break
3367
3368 else:
3369 # optimised tuple unpacking code
3370 code.putln('} else {')
3371 if min_positional_args == max_positional_args:
3372 # parse the exact number of positional arguments from
3373 # the args tuple
3374 for i, arg in enumerate(positional_args):
3375 code.putln("values[%d] = PyTuple_GET_ITEM(%s, %d);" % (i, Naming.args_cname, i))
3376 else:
3377 # parse the positional arguments from the variable length
3378 # args tuple and reject illegal argument tuple sizes
3379 code.putln('switch (PyTuple_GET_SIZE(%s)) {' % Naming.args_cname)
3380 if self.star_arg:
3381 code.putln('default:')
3382 reversed_args = list(enumerate(positional_args))[::-1]
3383 for i, arg in reversed_args:
3384 if i >= min_positional_args-1:
3385 code.put('case %2d: ' % (i+1))
3386 code.putln("values[%d] = PyTuple_GET_ITEM(%s, %d);" % (i, Naming.args_cname, i))
3387 if min_positional_args == 0:
3388 code.put('case 0: ')
3389 code.putln('break;')
3390 if self.star_arg:
3391 if min_positional_args:
3392 for i in range(min_positional_args-1, -1, -1):
3393 code.putln('case %2d:' % i)
3394 code.put_goto(argtuple_error_label)
3395 else:
3396 code.put('default: ')
3397 code.put_goto(argtuple_error_label)
3398 code.putln('}')
3399
3400 code.putln('}') # end of the conditional unpacking blocks
3401
3402 # Convert arg values to their final type and assign them.
3403 # Also inject non-Python default arguments, which do cannot
3404 # live in the values[] array.
3405 for i, arg in enumerate(all_args):
3406 self.generate_arg_assignment(arg, "values[%d]" % i, code)
3407
3408 code.putln('}') # end of the whole argument unpacking block
3409
3410 if code.label_used(argtuple_error_label):
3411 code.put_goto(success_label)
3412 code.put_label(argtuple_error_label)
3413 code.globalstate.use_utility_code(
3414 UtilityCode.load_cached("RaiseArgTupleInvalid", "FunctionArguments.c"))
3415 code.put('__Pyx_RaiseArgtupleInvalid("%s", %d, %d, %d, PyTuple_GET_SIZE(%s)); ' % (
3416 self.name, has_fixed_positional_count,
3417 min_positional_args, max_positional_args,
3418 Naming.args_cname))
3419 code.putln(code.error_goto(self.pos))
3420
3421 def generate_arg_assignment(self, arg, item, code):
3422 if arg.type.is_pyobject:
3423 # Python default arguments were already stored in 'item' at the very beginning
3424 if arg.is_generic:
3425 item = PyrexTypes.typecast(arg.type, PyrexTypes.py_object_type, item)
3426 entry = arg.entry
3427 code.putln("%s = %s;" % (entry.cname, item))
3428 else:
3429 func = arg.type.from_py_function
3430 if func:
3431 if arg.default:
3432 # C-typed default arguments must be handled here
3433 code.putln('if (%s) {' % item)
3434 rhs = "%s(%s)" % (func, item)
3435 if arg.type.is_enum:
3436 rhs = arg.type.cast_code(rhs)
3437 code.putln("%s = %s; %s" % (
3438 arg.entry.cname,
3439 rhs,
3440 code.error_goto_if(arg.type.error_condition(arg.entry.cname), arg.pos)))
3441 if arg.default:
3442 code.putln('} else {')
3443 code.putln(
3444 "%s = %s;" % (
3445 arg.entry.cname,
3446 arg.calculate_default_value_code(code)))
3447 if arg.type.is_memoryviewslice:
3448 code.put_incref_memoryviewslice(arg.entry.cname,
3449 have_gil=True)
3450 code.putln('}')
3451 else:
3452 error(arg.pos, "Cannot convert Python object argument to type '%s'" % arg.type)
3453
3454 def generate_stararg_init_code(self, max_positional_args, code):
3455 if self.starstar_arg:
3456 self.starstar_arg.entry.xdecref_cleanup = 0
3457 code.putln('%s = PyDict_New(); if (unlikely(!%s)) return %s;' % (
3458 self.starstar_arg.entry.cname,
3459 self.starstar_arg.entry.cname,
3460 self.error_value()))
3461 code.put_gotref(self.starstar_arg.entry.cname)
3462 if self.star_arg:
3463 self.star_arg.entry.xdecref_cleanup = 0
3464 code.putln('if (PyTuple_GET_SIZE(%s) > %d) {' % (
3465 Naming.args_cname,
3466 max_positional_args))
3467 code.putln('%s = PyTuple_GetSlice(%s, %d, PyTuple_GET_SIZE(%s));' % (
3468 self.star_arg.entry.cname, Naming.args_cname,
3469 max_positional_args, Naming.args_cname))
3470 code.putln("if (unlikely(!%s)) {" % self.star_arg.entry.cname)
3471 if self.starstar_arg:
3472 code.put_decref_clear(self.starstar_arg.entry.cname, py_object_type)
3473 code.put_finish_refcount_context()
3474 code.putln('return %s;' % self.error_value())
3475 code.putln('}')
3476 code.put_gotref(self.star_arg.entry.cname)
3477 code.putln('} else {')
3478 code.put("%s = %s; " % (self.star_arg.entry.cname, Naming.empty_tuple))
3479 code.put_incref(Naming.empty_tuple, py_object_type)
3480 code.putln('}')
3481
3482 def generate_argument_values_setup_code(self, args, code):
3483 max_args = len(args)
3484 # the 'values' array collects borrowed references to arguments
3485 # before doing any type coercion etc.
3486 code.putln("PyObject* values[%d] = {%s};" % (
3487 max_args, ','.join('0'*max_args)))
3488
3489 if self.target.defaults_struct:
3490 code.putln('%s *%s = __Pyx_CyFunction_Defaults(%s, %s);' % (
3491 self.target.defaults_struct, Naming.dynamic_args_cname,
3492 self.target.defaults_struct, Naming.self_cname))
3493
3494 # assign borrowed Python default values to the values array,
3495 # so that they can be overwritten by received arguments below
3496 for i, arg in enumerate(args):
3497 if arg.default and arg.type.is_pyobject:
3498 default_value = arg.calculate_default_value_code(code)
3499 code.putln('values[%d] = %s;' % (i, arg.type.as_pyobject(default_value)))
3500
3501 def generate_keyword_unpacking_code(self, min_positional_args, max_positional_args,
3502 has_fixed_positional_count, has_kw_only_args,
3503 all_args, argtuple_error_label, code):
3504 code.putln('Py_ssize_t kw_args;')
3505 code.putln('const Py_ssize_t pos_args = PyTuple_GET_SIZE(%s);' % Naming.args_cname)
3506 # copy the values from the args tuple and check that it's not too long
3507 code.putln('switch (pos_args) {')
3508 if self.star_arg:
3509 code.putln('default:')
3510 for i in range(max_positional_args-1, -1, -1):
3511 code.put('case %2d: ' % (i+1))
3512 code.putln("values[%d] = PyTuple_GET_ITEM(%s, %d);" % (
3513 i, Naming.args_cname, i))
3514 code.putln('case 0: break;')
3515 if not self.star_arg:
3516 code.put('default: ') # more arguments than allowed
3517 code.put_goto(argtuple_error_label)
3518 code.putln('}')
3519
3520 # The code above is very often (but not always) the same as
3521 # the optimised non-kwargs tuple unpacking code, so we keep
3522 # the code block above at the very top, before the following
3523 # 'external' PyDict_Size() call, to make it easy for the C
3524 # compiler to merge the two separate tuple unpacking
3525 # implementations into one when they turn out to be identical.
3526
3527 # If we received kwargs, fill up the positional/required
3528 # arguments with values from the kw dict
3529 code.putln('kw_args = PyDict_Size(%s);' % Naming.kwds_cname)
3530 if self.num_required_args or max_positional_args > 0:
3531 last_required_arg = -1
3532 for i, arg in enumerate(all_args):
3533 if not arg.default:
3534 last_required_arg = i
3535 if last_required_arg < max_positional_args:
3536 last_required_arg = max_positional_args-1
3537 if max_positional_args > 0:
3538 code.putln('switch (pos_args) {')
3539 for i, arg in enumerate(all_args[:last_required_arg+1]):
3540 if max_positional_args > 0 and i <= max_positional_args:
3541 if self.star_arg and i == max_positional_args:
3542 code.putln('default:')
3543 else:
3544 code.putln('case %2d:' % i)
3545 pystring_cname = code.intern_identifier(arg.name)
3546 if arg.default:
3547 if arg.kw_only:
3548 # optional kw-only args are handled separately below
3549 continue
3550 code.putln('if (kw_args > 0) {')
3551 # don't overwrite default argument
3552 code.putln('PyObject* value = PyDict_GetItem(%s, %s);' % (
3553 Naming.kwds_cname, pystring_cname))
3554 code.putln('if (value) { values[%d] = value; kw_args--; }' % i)
3555 code.putln('}')
3556 else:
3557 code.putln('if (likely((values[%d] = PyDict_GetItem(%s, %s)) != 0)) kw_args--;' % (
3558 i, Naming.kwds_cname, pystring_cname))
3559 if i < min_positional_args:
3560 if i == 0:
3561 # special case: we know arg 0 is missing
3562 code.put('else ')
3563 code.put_goto(argtuple_error_label)
3564 else:
3565 # print the correct number of values (args or
3566 # kwargs) that were passed into positional
3567 # arguments up to this point
3568 code.putln('else {')
3569 code.globalstate.use_utility_code(
3570 UtilityCode.load_cached("RaiseArgTupleInvalid", "FunctionArguments.c"))
3571 code.put('__Pyx_RaiseArgtupleInvalid("%s", %d, %d, %d, %d); ' % (
3572 self.name, has_fixed_positional_count,
3573 min_positional_args, max_positional_args, i))
3574 code.putln(code.error_goto(self.pos))
3575 code.putln('}')
3576 elif arg.kw_only:
3577 code.putln('else {')
3578 code.put('__Pyx_RaiseKeywordRequired("%s", %s); ' %(
3579 self.name, pystring_cname))
3580 code.putln(code.error_goto(self.pos))
3581 code.putln('}')
3582 if max_positional_args > 0:
3583 code.putln('}')
3584
3585 if has_kw_only_args:
3586 # unpack optional keyword-only arguments separately because
3587 # checking for interned strings in a dict is faster than iterating
3588 self.generate_optional_kwonly_args_unpacking_code(all_args, code)
3589
3590 code.putln('if (unlikely(kw_args > 0)) {')
3591 # non-positional/-required kw args left in dict: default args,
3592 # kw-only args, **kwargs or error
3593 #
3594 # This is sort of a catch-all: except for checking required
3595 # arguments, this will always do the right thing for unpacking
3596 # keyword arguments, so that we can concentrate on optimising
3597 # common cases above.
3598 if max_positional_args == 0:
3599 pos_arg_count = "0"
3600 elif self.star_arg:
3601 code.putln("const Py_ssize_t used_pos_args = (pos_args < %d) ? pos_args : %d;" % (
3602 max_positional_args, max_positional_args))
3603 pos_arg_count = "used_pos_args"
3604 else:
3605 pos_arg_count = "pos_args"
3606 code.globalstate.use_utility_code(
3607 UtilityCode.load_cached("ParseKeywords", "FunctionArguments.c"))
3608 code.putln(
3609 'if (unlikely(__Pyx_ParseOptionalKeywords(%s, %s, %s, values, %s, "%s") < 0)) %s' % (
3610 Naming.kwds_cname,
3611 Naming.pykwdlist_cname,
3612 self.starstar_arg and self.starstar_arg.entry.cname or '0',
3613 pos_arg_count,
3614 self.name,
3615 code.error_goto(self.pos)))
3616 code.putln('}')
3617
3618 def generate_optional_kwonly_args_unpacking_code(self, all_args, code):
3619 optional_args = []
3620 first_optional_arg = -1
3621 for i, arg in enumerate(all_args):
3622 if not arg.kw_only or not arg.default:
3623 continue
3624 if not optional_args:
3625 first_optional_arg = i
3626 optional_args.append(arg.name)
3627 if optional_args:
3628 if len(optional_args) > 1:
3629 # if we receive more than the named kwargs, we either have **kwargs
3630 # (in which case we must iterate anyway) or it's an error (which we
3631 # also handle during iteration) => skip this part if there are more
3632 code.putln('if (kw_args > 0 && %s(kw_args <= %d)) {' % (
3633 not self.starstar_arg and 'likely' or '',
3634 len(optional_args)))
3635 code.putln('Py_ssize_t index;')
3636 # not unrolling the loop here reduces the C code overhead
3637 code.putln('for (index = %d; index < %d && kw_args > 0; index++) {' % (
3638 first_optional_arg, first_optional_arg + len(optional_args)))
3639 else:
3640 code.putln('if (kw_args == 1) {')
3641 code.putln('const Py_ssize_t index = %d;' % first_optional_arg)
3642 code.putln('PyObject* value = PyDict_GetItem(%s, *%s[index]);' % (
3643 Naming.kwds_cname, Naming.pykwdlist_cname))
3644 code.putln('if (value) { values[index] = value; kw_args--; }')
3645 if len(optional_args) > 1:
3646 code.putln('}')
3647 code.putln('}')
3648
3649 def generate_argument_conversion_code(self, code):
3650 # Generate code to convert arguments from signature type to
3651 # declared type, if needed. Also copies signature arguments
3652 # into closure fields.
3653 for arg in self.args:
3654 if arg.needs_conversion:
3655 self.generate_arg_conversion(arg, code)
3656
3657 def generate_arg_conversion(self, arg, code):
3658 # Generate conversion code for one argument.
3659 old_type = arg.hdr_type
3660 new_type = arg.type
3661 if old_type.is_pyobject:
3662 if arg.default:
3663 code.putln("if (%s) {" % arg.hdr_cname)
3664 else:
3665 code.putln("assert(%s); {" % arg.hdr_cname)
3666 self.generate_arg_conversion_from_pyobject(arg, code)
3667 code.putln("}")
3668 elif new_type.is_pyobject:
3669 self.generate_arg_conversion_to_pyobject(arg, code)
3670 else:
3671 if new_type.assignable_from(old_type):
3672 code.putln(
3673 "%s = %s;" % (arg.entry.cname, arg.hdr_cname))
3674 else:
3675 error(arg.pos,
3676 "Cannot convert 1 argument from '%s' to '%s'" %
3677 (old_type, new_type))
3678
3679 def generate_arg_conversion_from_pyobject(self, arg, code):
3680 new_type = arg.type
3681 func = new_type.from_py_function
3682 # copied from CoerceFromPyTypeNode
3683 if func:
3684 lhs = arg.entry.cname
3685 rhs = "%s(%s)" % (func, arg.hdr_cname)
3686 if new_type.is_enum:
3687 rhs = PyrexTypes.typecast(new_type, PyrexTypes.c_long_type, rhs)
3688 code.putln("%s = %s; %s" % (
3689 lhs,
3690 rhs,
3691 code.error_goto_if(new_type.error_condition(arg.entry.cname), arg.pos)))
3692 else:
3693 error(arg.pos,
3694 "Cannot convert Python object argument to type '%s'"
3695 % new_type)
3696
3697 def generate_arg_conversion_to_pyobject(self, arg, code):
3698 old_type = arg.hdr_type
3699 func = old_type.to_py_function
3700 if func:
3701 code.putln("%s = %s(%s); %s" % (
3702 arg.entry.cname,
3703 func,
3704 arg.hdr_cname,
3705 code.error_goto_if_null(arg.entry.cname, arg.pos)))
3706 code.put_var_gotref(arg.entry)
3707 else:
3708 error(arg.pos,
3709 "Cannot convert argument of type '%s' to Python object"
3710 % old_type)
3711
3712 def generate_argument_type_tests(self, code):
3713 # Generate type tests for args whose signature
3714 # type is PyObject * and whose declared type is
3715 # a subtype thereof.
3716 for arg in self.args:
3717 if arg.needs_type_test:
3718 self.generate_arg_type_test(arg, code)
3719 elif not arg.accept_none and (arg.type.is_pyobject or
3720 arg.type.is_buffer or
3721 arg.type.is_memoryviewslice):
3722 self.generate_arg_none_check(arg, code)
3723
3724 def error_value(self):
3725 return self.signature.error_value
3726
3727
3728 class GeneratorDefNode(DefNode):
3729 # Generator function node that creates a new generator instance when called.
3730 #
3731 # gbody GeneratorBodyDefNode the function implementing the generator
3732 #
3733
3734 is_generator = True
3735 needs_closure = True
3736
3737 child_attrs = DefNode.child_attrs + ["gbody"]
3738
3739 def __init__(self, **kwargs):
3740 # XXX: don't actually needs a body
3741 kwargs['body'] = StatListNode(kwargs['pos'], stats=[])
3742 super(GeneratorDefNode, self).__init__(**kwargs)
3743
3744 def analyse_declarations(self, env):
3745 super(GeneratorDefNode, self).analyse_declarations(env)
3746 self.gbody.local_scope = self.local_scope
3747 self.gbody.analyse_declarations(env)
3748
3749 def generate_function_body(self, env, code):
3750 body_cname = self.gbody.entry.func_cname
3751
3752 code.putln('{')
3753 code.putln('__pyx_GeneratorObject *gen = __Pyx_Generator_New('
3754 '(__pyx_generator_body_t) %s, (PyObject *) %s); %s' % (
3755 body_cname, Naming.cur_scope_cname,
3756 code.error_goto_if_null('gen', self.pos)))
3757 code.put_decref(Naming.cur_scope_cname, py_object_type)
3758 if self.requires_classobj:
3759 classobj_cname = 'gen->classobj'
3760 code.putln('%s = __Pyx_CyFunction_GetClassObj(%s);' % (
3761 classobj_cname, Naming.self_cname))
3762 code.put_incref(classobj_cname, py_object_type)
3763 code.put_giveref(classobj_cname)
3764 code.put_finish_refcount_context()
3765 code.putln('return (PyObject *) gen;')
3766 code.putln('}')
3767
3768 def generate_function_definitions(self, env, code):
3769 env.use_utility_code(UtilityCode.load_cached("Generator", "Generator.c"))
3770
3771 self.gbody.generate_function_header(code, proto=True)
3772 super(GeneratorDefNode, self).generate_function_definitions(env, code)
3773 self.gbody.generate_function_definitions(env, code)
3774
3775
3776 class GeneratorBodyDefNode(DefNode):
3777 # Main code body of a generator implemented as a DefNode.
3778 #
3779
3780 is_generator_body = True
3781
3782 def __init__(self, pos=None, name=None, body=None):
3783 super(GeneratorBodyDefNode, self).__init__(
3784 pos=pos, body=body, name=name, doc=None,
3785 args=[], star_arg=None, starstar_arg=None)
3786
3787 def declare_generator_body(self, env):
3788 prefix = env.next_id(env.scope_prefix)
3789 name = env.next_id('generator')
3790 cname = Naming.genbody_prefix + prefix + name
3791 entry = env.declare_var(None, py_object_type, self.pos,
3792 cname=cname, visibility='private')
3793 entry.func_cname = cname
3794 entry.qualified_name = EncodedString(self.name)
3795 self.entry = entry
3796
3797 def analyse_declarations(self, env):
3798 self.analyse_argument_types(env)
3799 self.declare_generator_body(env)
3800
3801 def generate_function_header(self, code, proto=False):
3802 header = "static PyObject *%s(__pyx_GeneratorObject *%s, PyObject *%s)" % (
3803 self.entry.func_cname,
3804 Naming.generator_cname,
3805 Naming.sent_value_cname)
3806 if proto:
3807 code.putln('%s; /* proto */' % header)
3808 else:
3809 code.putln('%s /* generator body */\n{' % header)
3810
3811 def generate_function_definitions(self, env, code):
3812 lenv = self.local_scope
3813
3814 # Generate closure function definitions
3815 self.body.generate_function_definitions(lenv, code)
3816
3817 # Generate C code for header and body of function
3818 code.enter_cfunc_scope()
3819 code.return_from_error_cleanup_label = code.new_label()
3820
3821 # ----- Top-level constants used by this function
3822 code.mark_pos(self.pos)
3823 self.generate_cached_builtins_decls(lenv, code)
3824 # ----- Function header
3825 code.putln("")
3826 self.generate_function_header(code)
3827 closure_init_code = code.insertion_point()
3828 # ----- Local variables
3829 code.putln("PyObject *%s = NULL;" % Naming.retval_cname)
3830 tempvardecl_code = code.insertion_point()
3831 code.put_declare_refcount_context()
3832 code.put_setup_refcount_context(self.entry.name)
3833
3834 # ----- Resume switch point.
3835 code.funcstate.init_closure_temps(lenv.scope_class.type.scope)
3836 resume_code = code.insertion_point()
3837 first_run_label = code.new_label('first_run')
3838 code.use_label(first_run_label)
3839 code.put_label(first_run_label)
3840 code.putln('%s' %
3841 (code.error_goto_if_null(Naming.sent_value_cname, self.pos)))
3842
3843 # ----- Function body
3844 self.generate_function_body(env, code)
3845 # ----- Closure initialization
3846 if lenv.scope_class.type.scope.entries:
3847 closure_init_code.putln('%s = %s;' % (
3848 lenv.scope_class.type.declaration_code(Naming.cur_scope_cname),
3849 lenv.scope_class.type.cast_code('%s->closure' %
3850 Naming.generator_cname)))
3851
3852 code.mark_pos(self.pos)
3853 code.putln("")
3854 code.putln("/* function exit code */")
3855
3856 # on normal generator termination, we do not take the exception propagation
3857 # path: no traceback info is required and not creating it is much faster
3858 if not self.body.is_terminator:
3859 code.putln('PyErr_SetNone(PyExc_StopIteration);')
3860 # ----- Error cleanup
3861 if code.error_label in code.labels_used:
3862 if not self.body.is_terminator:
3863 code.put_goto(code.return_label)
3864 code.put_label(code.error_label)
3865 for cname, type in code.funcstate.all_managed_temps():
3866 code.put_xdecref(cname, type)
3867 code.put_add_traceback(self.entry.qualified_name)
3868
3869 # ----- Non-error return cleanup
3870 code.put_label(code.return_label)
3871 code.put_xdecref(Naming.retval_cname, py_object_type)
3872 code.putln('%s->resume_label = -1;' % Naming.generator_cname)
3873 # clean up as early as possible to help breaking any reference cycles
3874 code.putln('__Pyx_Generator_clear((PyObject*)%s);' % Naming.generator_cname)
3875 code.put_finish_refcount_context()
3876 code.putln('return NULL;')
3877 code.putln("}")
3878
3879 # ----- Go back and insert temp variable declarations
3880 tempvardecl_code.put_temp_declarations(code.funcstate)
3881 # ----- Generator resume code
3882 resume_code.putln("switch (%s->resume_label) {" % (
3883 Naming.generator_cname))
3884 resume_code.putln("case 0: goto %s;" % first_run_label)
3885
3886 for i, label in code.yield_labels:
3887 resume_code.putln("case %d: goto %s;" % (i, label))
3888 resume_code.putln("default: /* CPython raises the right error here */")
3889 resume_code.put_finish_refcount_context()
3890 resume_code.putln("return NULL;")
3891 resume_code.putln("}")
3892
3893 code.exit_cfunc_scope()
3894
3895
3896 class OverrideCheckNode(StatNode):
3897 # A Node for dispatching to the def method if it
3898 # is overriden.
3899 #
3900 # py_func
3901 #
3902 # args
3903 # func_temp
3904 # body
3905
3906 child_attrs = ['body']
3907
3908 body = None
3909
3910 def analyse_expressions(self, env):
3911 self.args = env.arg_entries
3912 if self.py_func.is_module_scope:
3913 first_arg = 0
3914 else:
3915 first_arg = 1
3916 import ExprNodes
3917 self.func_node = ExprNodes.RawCNameExprNode(self.pos, py_object_type)
3918 call_node = ExprNodes.SimpleCallNode(
3919 self.pos, function=self.func_node,
3920 args=[ ExprNodes.NameNode(self.pos, name=arg.name)
3921 for arg in self.args[first_arg:] ])
3922 self.body = ReturnStatNode(self.pos, value=call_node)
3923 self.body = self.body.analyse_expressions(env)
3924 return self
3925
3926 def generate_execution_code(self, code):
3927 interned_attr_cname = code.intern_identifier(self.py_func.entry.name)
3928 # Check to see if we are an extension type
3929 if self.py_func.is_module_scope:
3930 self_arg = "((PyObject *)%s)" % Naming.module_cname
3931 else:
3932 self_arg = "((PyObject *)%s)" % self.args[0].cname
3933 code.putln("/* Check if called by wrapper */")
3934 code.putln("if (unlikely(%s)) ;" % Naming.skip_dispatch_cname)
3935 code.putln("/* Check if overridden in Python */")
3936 if self.py_func.is_module_scope:
3937 code.putln("else {")
3938 else:
3939 code.putln("else if (unlikely(Py_TYPE(%s)->tp_dictoffset != 0)) {" % self_arg)
3940 func_node_temp = code.funcstate.allocate_temp(py_object_type, manage_ref=True)
3941 self.func_node.set_cname(func_node_temp)
3942 # need to get attribute manually--scope would return cdef method
3943 code.globalstate.use_utility_code(
3944 UtilityCode.load_cached("PyObjectGetAttrStr", "ObjectHandling.c"))
3945 err = code.error_goto_if_null(func_node_temp, self.pos)
3946 code.putln("%s = __Pyx_PyObject_GetAttrStr(%s, %s); %s" % (
3947 func_node_temp, self_arg, interned_attr_cname, err))
3948 code.put_gotref(func_node_temp)
3949 is_builtin_function_or_method = "PyCFunction_Check(%s)" % func_node_temp
3950 is_overridden = "(PyCFunction_GET_FUNCTION(%s) != (PyCFunction)%s)" % (
3951 func_node_temp, self.py_func.entry.func_cname)
3952 code.putln("if (!%s || %s) {" % (is_builtin_function_or_method, is_overridden))
3953 self.body.generate_execution_code(code)
3954 code.putln("}")
3955 code.put_decref_clear(func_node_temp, PyrexTypes.py_object_type)
3956 code.funcstate.release_temp(func_node_temp)
3957 code.putln("}")
3958
3959 class ClassDefNode(StatNode, BlockNode):
3960 pass
3961
3962 class PyClassDefNode(ClassDefNode):
3963 # A Python class definition.
3964 #
3965 # name EncodedString Name of the class
3966 # doc string or None
3967 # body StatNode Attribute definition code
3968 # entry Symtab.Entry
3969 # scope PyClassScope
3970 # decorators [DecoratorNode] list of decorators or None
3971 #
3972 # The following subnodes are constructed internally:
3973 #
3974 # dict DictNode Class dictionary or Py3 namespace
3975 # classobj ClassNode Class object
3976 # target NameNode Variable to assign class object to
3977
3978 child_attrs = ["body", "dict", "metaclass", "mkw", "bases", "class_result",
3979 "target", "class_cell", "decorators"]
3980 decorators = None
3981 class_result = None
3982 is_py3_style_class = False # Python3 style class (kwargs)
3983 metaclass = None
3984 mkw = None
3985
3986 def __init__(self, pos, name, bases, doc, body, decorators=None,
3987 keyword_args=None, starstar_arg=None, force_py3_semantics=False):
3988 StatNode.__init__(self, pos)
3989 self.name = name
3990 self.doc = doc
3991 self.body = body
3992 self.decorators = decorators
3993 self.bases = bases
3994 import ExprNodes
3995 if self.doc and Options.docstrings:
3996 doc = embed_position(self.pos, self.doc)
3997 doc_node = ExprNodes.StringNode(pos, value=doc)
3998 else:
3999 doc_node = None
4000
4001 allow_py2_metaclass = not force_py3_semantics
4002 if keyword_args or starstar_arg:
4003 allow_py2_metaclass = False
4004 self.is_py3_style_class = True
4005 if keyword_args and not starstar_arg:
4006 for i, item in list(enumerate(keyword_args.key_value_pairs))[::-1]:
4007 if item.key.value == 'metaclass':
4008 if self.metaclass is not None:
4009 error(item.pos, "keyword argument 'metaclass' passed multiple times")
4010 # special case: we already know the metaclass,
4011 # so we don't need to do the "build kwargs,
4012 # find metaclass" dance at runtime
4013 self.metaclass = item.value
4014 del keyword_args.key_value_pairs[i]
4015 if starstar_arg:
4016 self.mkw = ExprNodes.KeywordArgsNode(
4017 pos, keyword_args=keyword_args and keyword_args.key_value_pairs or [],
4018 starstar_arg=starstar_arg)
4019 elif keyword_args.key_value_pairs:
4020 self.mkw = keyword_args
4021 else:
4022 assert self.metaclass is not None
4023
4024 if force_py3_semantics or self.bases or self.mkw or self.metaclass:
4025 if self.metaclass is None:
4026 if starstar_arg:
4027 # **kwargs may contain 'metaclass' arg
4028 mkdict = self.mkw
4029 else:
4030 mkdict = None
4031 if (not mkdict and
4032 self.bases.is_sequence_constructor and
4033 not self.bases.args):
4034 pass # no base classes => no inherited metaclass
4035 else:
4036 self.metaclass = ExprNodes.PyClassMetaclassNode(
4037 pos, mkw=mkdict, bases=self.bases)
4038 needs_metaclass_calculation = False
4039 else:
4040 needs_metaclass_calculation = True
4041
4042 self.dict = ExprNodes.PyClassNamespaceNode(
4043 pos, name=name, doc=doc_node,
4044 metaclass=self.metaclass, bases=self.bases, mkw=self.mkw)
4045 self.classobj = ExprNodes.Py3ClassNode(
4046 pos, name=name,
4047 bases=self.bases, dict=self.dict, doc=doc_node,
4048 metaclass=self.metaclass, mkw=self.mkw,
4049 calculate_metaclass=needs_metaclass_calculation,
4050 allow_py2_metaclass=allow_py2_metaclass)
4051 else:
4052 # no bases, no metaclass => old style class creation
4053 self.dict = ExprNodes.DictNode(pos, key_value_pairs=[])
4054 self.classobj = ExprNodes.ClassNode(
4055 pos, name=name,
4056 bases=bases, dict=self.dict, doc=doc_node)
4057
4058 self.target = ExprNodes.NameNode(pos, name=name)
4059 self.class_cell = ExprNodes.ClassCellInjectorNode(self.pos)
4060
4061 def as_cclass(self):
4062 """
4063 Return this node as if it were declared as an extension class
4064 """
4065 if self.is_py3_style_class:
4066 error(self.classobj.pos, "Python3 style class could not be represented as C class")
4067 return
4068 bases = self.classobj.bases.args
4069 if len(bases) == 0:
4070 base_class_name = None
4071 base_class_module = None
4072 elif len(bases) == 1:
4073 base = bases[0]
4074 path = []
4075 from ExprNodes import AttributeNode, NameNode
4076 while isinstance(base, AttributeNode):
4077 path.insert(0, base.attribute)
4078 base = base.obj
4079 if isinstance(base, NameNode):
4080 path.insert(0, base.name)
4081 base_class_name = path[-1]
4082 if len(path) > 1:
4083 base_class_module = u'.'.join(path[:-1])
4084 else:
4085 base_class_module = None
4086 else:
4087 error(self.classobj.bases.args.pos, "Invalid base class")
4088 else:
4089 error(self.classobj.bases.args.pos, "C class may only have one base class")
4090 return None
4091
4092 return CClassDefNode(self.pos,
4093 visibility = 'private',
4094 module_name = None,
4095 class_name = self.name,
4096 base_class_module = base_class_module,
4097 base_class_name = base_class_name,
4098 decorators = self.decorators,
4099 body = self.body,
4100 in_pxd = False,
4101 doc = self.doc)
4102
4103 def create_scope(self, env):
4104 genv = env
4105 while genv.is_py_class_scope or genv.is_c_class_scope:
4106 genv = genv.outer_scope
4107 cenv = self.scope = PyClassScope(name = self.name, outer_scope = genv)
4108 return cenv
4109
4110 def analyse_declarations(self, env):
4111 class_result = self.classobj
4112 if self.decorators:
4113 from ExprNodes import SimpleCallNode
4114 for decorator in self.decorators[::-1]:
4115 class_result = SimpleCallNode(
4116 decorator.pos,
4117 function = decorator.decorator,
4118 args = [class_result])
4119 self.decorators = None
4120 self.class_result = class_result
4121 self.class_result.analyse_declarations(env)
4122 self.target.analyse_target_declaration(env)
4123 cenv = self.create_scope(env)
4124 cenv.directives = env.directives
4125 cenv.class_obj_cname = self.target.entry.cname
4126 self.body.analyse_declarations(cenv)
4127
4128 def analyse_expressions(self, env):
4129 if self.bases:
4130 self.bases = self.bases.analyse_expressions(env)
4131 if self.metaclass:
4132 self.metaclass = self.metaclass.analyse_expressions(env)
4133 if self.mkw:
4134 self.mkw = self.mkw.analyse_expressions(env)
4135 self.dict = self.dict.analyse_expressions(env)
4136 self.class_result = self.class_result.analyse_expressions(env)
4137 genv = env.global_scope()
4138 cenv = self.scope
4139 self.body = self.body.analyse_expressions(cenv)
4140 self.target.analyse_target_expression(env, self.classobj)
4141 self.class_cell = self.class_cell.analyse_expressions(cenv)
4142 return self
4143
4144 def generate_function_definitions(self, env, code):
4145 self.generate_lambda_definitions(self.scope, code)
4146 self.body.generate_function_definitions(self.scope, code)
4147
4148 def generate_execution_code(self, code):
4149 code.pyclass_stack.append(self)
4150 cenv = self.scope
4151 if self.bases:
4152 self.bases.generate_evaluation_code(code)
4153 if self.mkw:
4154 self.mkw.generate_evaluation_code(code)
4155 if self.metaclass:
4156 self.metaclass.generate_evaluation_code(code)
4157 self.dict.generate_evaluation_code(code)
4158 cenv.namespace_cname = cenv.class_obj_cname = self.dict.result()
4159 self.class_cell.generate_evaluation_code(code)
4160 self.body.generate_execution_code(code)
4161 self.class_result.generate_evaluation_code(code)
4162 self.class_cell.generate_injection_code(
4163 code, self.class_result.result())
4164 self.class_cell.generate_disposal_code(code)
4165 cenv.namespace_cname = cenv.class_obj_cname = self.classobj.result()
4166 self.target.generate_assignment_code(self.class_result, code)
4167 self.dict.generate_disposal_code(code)
4168 self.dict.free_temps(code)
4169 if self.metaclass:
4170 self.metaclass.generate_disposal_code(code)
4171 self.metaclass.free_temps(code)
4172 if self.mkw:
4173 self.mkw.generate_disposal_code(code)
4174 self.mkw.free_temps(code)
4175 if self.bases:
4176 self.bases.generate_disposal_code(code)
4177 self.bases.free_temps(code)
4178 code.pyclass_stack.pop()
4179
4180 class CClassDefNode(ClassDefNode):
4181 # An extension type definition.
4182 #
4183 # visibility 'private' or 'public' or 'extern'
4184 # typedef_flag boolean
4185 # api boolean
4186 # module_name string or None For import of extern type objects
4187 # class_name string Unqualified name of class
4188 # as_name string or None Name to declare as in this scope
4189 # base_class_module string or None Module containing the base class
4190 # base_class_name string or None Name of the base class
4191 # objstruct_name string or None Specified C name of object struct
4192 # typeobj_name string or None Specified C name of type object
4193 # in_pxd boolean Is in a .pxd file
4194 # decorators [DecoratorNode] list of decorators or None
4195 # doc string or None
4196 # body StatNode or None
4197 # entry Symtab.Entry
4198 # base_type PyExtensionType or None
4199 # buffer_defaults_node DictNode or None Declares defaults for a buffer
4200 # buffer_defaults_pos
4201
4202 child_attrs = ["body"]
4203 buffer_defaults_node = None
4204 buffer_defaults_pos = None
4205 typedef_flag = False
4206 api = False
4207 objstruct_name = None
4208 typeobj_name = None
4209 decorators = None
4210 shadow = False
4211
4212 def buffer_defaults(self, env):
4213 if not hasattr(self, '_buffer_defaults'):
4214 import Buffer
4215 if self.buffer_defaults_node:
4216 self._buffer_defaults = Buffer.analyse_buffer_options(
4217 self.buffer_defaults_pos,
4218 env, [], self.buffer_defaults_node,
4219 need_complete=False)
4220 else:
4221 self._buffer_defaults = None
4222 return self._buffer_defaults
4223
4224 def declare(self, env):
4225 if self.module_name and self.visibility != 'extern':
4226 module_path = self.module_name.split(".")
4227 home_scope = env.find_imported_module(module_path, self.pos)
4228 if not home_scope:
4229 return None
4230 else:
4231 home_scope = env
4232
4233 self.entry = home_scope.declare_c_class(
4234 name = self.class_name,
4235 pos = self.pos,
4236 defining = 0,
4237 implementing = 0,
4238 module_name = self.module_name,
4239 base_type = None,
4240 objstruct_cname = self.objstruct_name,
4241 typeobj_cname = self.typeobj_name,
4242 visibility = self.visibility,
4243 typedef_flag = self.typedef_flag,
4244 api = self.api,
4245 buffer_defaults = self.buffer_defaults(env),
4246 shadow = self.shadow)
4247
4248 def analyse_declarations(self, env):
4249 #print "CClassDefNode.analyse_declarations:", self.class_name
4250 #print "...visibility =", self.visibility
4251 #print "...module_name =", self.module_name
4252
4253 if env.in_cinclude and not self.objstruct_name:
4254 error(self.pos, "Object struct name specification required for "
4255 "C class defined in 'extern from' block")
4256 if self.decorators:
4257 error(self.pos,
4258 "Decorators not allowed on cdef classes (used on type '%s')" % self.class_name)
4259 self.base_type = None
4260 # Now that module imports are cached, we need to
4261 # import the modules for extern classes.
4262 if self.module_name:
4263 self.module = None
4264 for module in env.cimported_modules:
4265 if module.name == self.module_name:
4266 self.module = module
4267 if self.module is None:
4268 self.module = ModuleScope(self.module_name, None, env.context)
4269 self.module.has_extern_class = 1
4270 env.add_imported_module(self.module)
4271
4272 if self.base_class_name:
4273 if self.base_class_module:
4274 base_class_scope = env.find_module(self.base_class_module, self.pos)
4275 else:
4276 base_class_scope = env
4277 if self.base_class_name == 'object':
4278 # extension classes are special and don't need to inherit from object
4279 if base_class_scope is None or base_class_scope.lookup('object') is None:
4280 self.base_class_name = None
4281 self.base_class_module = None
4282 base_class_scope = None
4283 if base_class_scope:
4284 base_class_entry = base_class_scope.find(self.base_class_name, self.pos)
4285 if base_class_entry:
4286 if not base_class_entry.is_type:
4287 error(self.pos, "'%s' is not a type name" % self.base_class_name)
4288 elif not base_class_entry.type.is_extension_type and \
4289 not (base_class_entry.type.is_builtin_type and
4290 base_class_entry.type.objstruct_cname):
4291 error(self.pos, "'%s' is not an extension type" % self.base_class_name)
4292 elif not base_class_entry.type.is_complete():
4293 error(self.pos, "Base class '%s' of type '%s' is incomplete" % (
4294 self.base_class_name, self.class_name))
4295 elif base_class_entry.type.scope and base_class_entry.type.scope.directives and \
4296 base_class_entry.type.is_final_type:
4297 error(self.pos, "Base class '%s' of type '%s' is final" % (
4298 self.base_class_name, self.class_name))
4299 elif base_class_entry.type.is_builtin_type and \
4300 base_class_entry.type.name in ('tuple', 'str', 'bytes'):
4301 error(self.pos, "inheritance from PyVarObject types like '%s' is not currently supported"
4302 % base_class_entry.type.name)
4303 else:
4304 self.base_type = base_class_entry.type
4305 if env.directives.get('freelist', 0) > 0:
4306 warning(self.pos, "freelists cannot be used on subtypes, only the base class can manage them", 1)
4307
4308 has_body = self.body is not None
4309 if has_body and self.base_type and not self.base_type.scope:
4310 # To properly initialize inherited attributes, the base type must
4311 # be analysed before this type.
4312 self.base_type.defered_declarations.append(lambda : self.analyse_declarations(env))
4313 return
4314
4315 if self.module_name and self.visibility != 'extern':
4316 module_path = self.module_name.split(".")
4317 home_scope = env.find_imported_module(module_path, self.pos)
4318 if not home_scope:
4319 return
4320 else:
4321 home_scope = env
4322
4323 if self.visibility == 'extern':
4324 if (self.module_name == '__builtin__' and
4325 self.class_name in Builtin.builtin_types and
4326 env.qualified_name[:8] != 'cpython.'): # allow overloaded names for cimporting from cpython
4327 warning(self.pos, "%s already a builtin Cython type" % self.class_name, 1)
4328
4329 self.entry = home_scope.declare_c_class(
4330 name = self.class_name,
4331 pos = self.pos,
4332 defining = has_body and self.in_pxd,
4333 implementing = has_body and not self.in_pxd,
4334 module_name = self.module_name,
4335 base_type = self.base_type,
4336 objstruct_cname = self.objstruct_name,
4337 typeobj_cname = self.typeobj_name,
4338 visibility = self.visibility,
4339 typedef_flag = self.typedef_flag,
4340 api = self.api,
4341 buffer_defaults = self.buffer_defaults(env),
4342 shadow = self.shadow)
4343
4344 if self.shadow:
4345 home_scope.lookup(self.class_name).as_variable = self.entry
4346 if home_scope is not env and self.visibility == 'extern':
4347 env.add_imported_entry(self.class_name, self.entry, self.pos)
4348 self.scope = scope = self.entry.type.scope
4349 if scope is not None:
4350 scope.directives = env.directives
4351
4352 if self.doc and Options.docstrings:
4353 scope.doc = embed_position(self.pos, self.doc)
4354
4355 if has_body:
4356 self.body.analyse_declarations(scope)
4357 if self.in_pxd:
4358 scope.defined = 1
4359 else:
4360 scope.implemented = 1
4361 env.allocate_vtable_names(self.entry)
4362
4363 for thunk in self.entry.type.defered_declarations:
4364 thunk()
4365
4366 def analyse_expressions(self, env):
4367 if self.body:
4368 scope = self.entry.type.scope
4369 self.body = self.body.analyse_expressions(scope)
4370 return self
4371
4372 def generate_function_definitions(self, env, code):
4373 if self.body:
4374 self.generate_lambda_definitions(self.scope, code)
4375 self.body.generate_function_definitions(self.scope, code)
4376
4377 def generate_execution_code(self, code):
4378 # This is needed to generate evaluation code for
4379 # default values of method arguments.
4380 if self.body:
4381 self.body.generate_execution_code(code)
4382
4383 def annotate(self, code):
4384 if self.body:
4385 self.body.annotate(code)
4386
4387
4388 class PropertyNode(StatNode):
4389 # Definition of a property in an extension type.
4390 #
4391 # name string
4392 # doc EncodedString or None Doc string
4393 # entry Symtab.Entry
4394 # body StatListNode
4395
4396 child_attrs = ["body"]
4397
4398 def analyse_declarations(self, env):
4399 self.entry = env.declare_property(self.name, self.doc, self.pos)
4400 self.entry.scope.directives = env.directives
4401 self.body.analyse_declarations(self.entry.scope)
4402
4403 def analyse_expressions(self, env):
4404 self.body = self.body.analyse_expressions(env)
4405 return self
4406
4407 def generate_function_definitions(self, env, code):
4408 self.body.generate_function_definitions(env, code)
4409
4410 def generate_execution_code(self, code):
4411 pass
4412
4413 def annotate(self, code):
4414 self.body.annotate(code)
4415
4416
4417 class GlobalNode(StatNode):
4418 # Global variable declaration.
4419 #
4420 # names [string]
4421
4422 child_attrs = []
4423
4424 def analyse_declarations(self, env):
4425 for name in self.names:
4426 env.declare_global(name, self.pos)
4427
4428 def analyse_expressions(self, env):
4429 return self
4430
4431 def generate_execution_code(self, code):
4432 pass
4433
4434
4435 class NonlocalNode(StatNode):
4436 # Nonlocal variable declaration via the 'nonlocal' keyword.
4437 #
4438 # names [string]
4439
4440 child_attrs = []
4441
4442 def analyse_declarations(self, env):
4443 for name in self.names:
4444 env.declare_nonlocal(name, self.pos)
4445
4446 def analyse_expressions(self, env):
4447 return self
4448
4449 def generate_execution_code(self, code):
4450 pass
4451
4452
4453 class ExprStatNode(StatNode):
4454 # Expression used as a statement.
4455 #
4456 # expr ExprNode
4457
4458 child_attrs = ["expr"]
4459
4460 def analyse_declarations(self, env):
4461 import ExprNodes
4462 if isinstance(self.expr, ExprNodes.GeneralCallNode):
4463 func = self.expr.function.as_cython_attribute()
4464 if func == u'declare':
4465 args, kwds = self.expr.explicit_args_kwds()
4466 if len(args):
4467 error(self.expr.pos, "Variable names must be specified.")
4468 for var, type_node in kwds.key_value_pairs:
4469 type = type_node.analyse_as_type(env)
4470 if type is None:
4471 error(type_node.pos, "Unknown type")
4472 else:
4473 env.declare_var(var.value, type, var.pos, is_cdef = True)
4474 self.__class__ = PassStatNode
4475
4476 def analyse_expressions(self, env):
4477 self.expr.result_is_used = False # hint that .result() may safely be left empty
4478 self.expr = self.expr.analyse_expressions(env)
4479 return self
4480
4481 def nogil_check(self, env):
4482 if self.expr.type.is_pyobject and self.expr.is_temp:
4483 self.gil_error()
4484
4485 gil_message = "Discarding owned Python object"
4486
4487 def generate_execution_code(self, code):
4488 self.expr.generate_evaluation_code(code)
4489 if not self.expr.is_temp and self.expr.result():
4490 code.putln("%s;" % self.expr.result())
4491 self.expr.generate_disposal_code(code)
4492 self.expr.free_temps(code)
4493
4494 def generate_function_definitions(self, env, code):
4495 self.expr.generate_function_definitions(env, code)
4496
4497 def annotate(self, code):
4498 self.expr.annotate(code)
4499
4500
4501 class AssignmentNode(StatNode):
4502 # Abstract base class for assignment nodes.
4503 #
4504 # The analyse_expressions and generate_execution_code
4505 # phases of assignments are split into two sub-phases
4506 # each, to enable all the right hand sides of a
4507 # parallel assignment to be evaluated before assigning
4508 # to any of the left hand sides.
4509
4510 def analyse_expressions(self, env):
4511 return self.analyse_types(env)
4512
4513 # def analyse_expressions(self, env):
4514 # self.analyse_expressions_1(env)
4515 # self.analyse_expressions_2(env)
4516
4517 def generate_execution_code(self, code):
4518 self.generate_rhs_evaluation_code(code)
4519 self.generate_assignment_code(code)
4520
4521
4522 class SingleAssignmentNode(AssignmentNode):
4523 # The simplest case:
4524 #
4525 # a = b
4526 #
4527 # lhs ExprNode Left hand side
4528 # rhs ExprNode Right hand side
4529 # first bool Is this guaranteed the first assignment to lhs?
4530
4531 child_attrs = ["lhs", "rhs"]
4532 first = False
4533 declaration_only = False
4534
4535 def analyse_declarations(self, env):
4536 import ExprNodes
4537
4538 # handle declarations of the form x = cython.foo()
4539 if isinstance(self.rhs, ExprNodes.CallNode):
4540 func_name = self.rhs.function.as_cython_attribute()
4541 if func_name:
4542 args, kwds = self.rhs.explicit_args_kwds()
4543
4544 if func_name in ['declare', 'typedef']:
4545 if len(args) > 2 or kwds is not None:
4546 error(self.rhs.pos, "Can only declare one type at a time.")
4547 return
4548
4549 type = args[0].analyse_as_type(env)
4550 if type is None:
4551 error(args[0].pos, "Unknown type")
4552 return
4553 lhs = self.lhs
4554 if func_name == 'declare':
4555 if isinstance(lhs, ExprNodes.NameNode):
4556 vars = [(lhs.name, lhs.pos)]
4557 elif isinstance(lhs, ExprNodes.TupleNode):
4558 vars = [(var.name, var.pos) for var in lhs.args]
4559 else:
4560 error(lhs.pos, "Invalid declaration")
4561 return
4562 for var, pos in vars:
4563 env.declare_var(var, type, pos, is_cdef = True)
4564 if len(args) == 2:
4565 # we have a value
4566 self.rhs = args[1]
4567 else:
4568 self.declaration_only = True
4569 else:
4570 self.declaration_only = True
4571 if not isinstance(lhs, ExprNodes.NameNode):
4572 error(lhs.pos, "Invalid declaration.")
4573 env.declare_typedef(lhs.name, type, self.pos, visibility='private')
4574
4575 elif func_name in ['struct', 'union']:
4576 self.declaration_only = True
4577 if len(args) > 0 or kwds is None:
4578 error(self.rhs.pos, "Struct or union members must be given by name.")
4579 return
4580 members = []
4581 for member, type_node in kwds.key_value_pairs:
4582 type = type_node.analyse_as_type(env)
4583 if type is None:
4584 error(type_node.pos, "Unknown type")
4585 else:
4586 members.append((member.value, type, member.pos))
4587 if len(members) < len(kwds.key_value_pairs):
4588 return
4589 if not isinstance(self.lhs, ExprNodes.NameNode):
4590 error(self.lhs.pos, "Invalid declaration.")
4591 name = self.lhs.name
4592 scope = StructOrUnionScope(name)
4593 env.declare_struct_or_union(name, func_name, scope, False, self.rhs.pos)
4594 for member, type, pos in members:
4595 scope.declare_var(member, type, pos)
4596
4597 elif func_name == 'fused_type':
4598 # dtype = cython.fused_type(...)
4599 self.declaration_only = True
4600 if kwds:
4601 error(self.rhs.function.pos,
4602 "fused_type does not take keyword arguments")
4603
4604 fusednode = FusedTypeNode(self.rhs.pos,
4605 name = self.lhs.name, types=args)
4606 fusednode.analyse_declarations(env)
4607
4608 if self.declaration_only:
4609 return
4610 else:
4611 self.lhs.analyse_target_declaration(env)
4612
4613 def analyse_types(self, env, use_temp = 0):
4614 import ExprNodes
4615
4616 self.rhs = self.rhs.analyse_types(env)
4617 self.lhs = self.lhs.analyse_target_types(env)
4618 self.lhs.gil_assignment_check(env)
4619
4620 if self.lhs.memslice_broadcast or self.rhs.memslice_broadcast:
4621 self.lhs.memslice_broadcast = True
4622 self.rhs.memslice_broadcast = True
4623
4624 is_index_node = isinstance(self.lhs, ExprNodes.IndexNode)
4625 if (is_index_node and not self.rhs.type.is_memoryviewslice and
4626 (self.lhs.memslice_slice or self.lhs.is_memslice_copy) and
4627 (self.lhs.type.dtype.assignable_from(self.rhs.type) or
4628 self.rhs.type.is_pyobject)):
4629 # scalar slice assignment
4630 self.lhs.is_memslice_scalar_assignment = True
4631 dtype = self.lhs.type.dtype
4632 else:
4633 dtype = self.lhs.type
4634
4635 rhs = self.rhs.coerce_to(dtype, env)
4636 if use_temp or rhs.is_attribute or (
4637 not rhs.is_name and not rhs.is_literal and
4638 rhs.type.is_pyobject):
4639 # things like (cdef) attribute access are not safe (traverses pointers)
4640 rhs = rhs.coerce_to_temp(env)
4641 elif rhs.type.is_pyobject:
4642 rhs = rhs.coerce_to_simple(env)
4643 self.rhs = rhs
4644 return self
4645
4646 def generate_rhs_evaluation_code(self, code):
4647 self.rhs.generate_evaluation_code(code)
4648
4649 def generate_assignment_code(self, code):
4650 self.lhs.generate_assignment_code(self.rhs, code)
4651
4652 def generate_function_definitions(self, env, code):
4653 self.rhs.generate_function_definitions(env, code)
4654
4655 def annotate(self, code):
4656 self.lhs.annotate(code)
4657 self.rhs.annotate(code)
4658
4659
4660 class CascadedAssignmentNode(AssignmentNode):
4661 # An assignment with multiple left hand sides:
4662 #
4663 # a = b = c
4664 #
4665 # lhs_list [ExprNode] Left hand sides
4666 # rhs ExprNode Right hand sides
4667 #
4668 # Used internally:
4669 #
4670 # coerced_rhs_list [ExprNode] RHS coerced to type of each LHS
4671
4672 child_attrs = ["lhs_list", "rhs", "coerced_rhs_list"]
4673 coerced_rhs_list = None
4674
4675 def analyse_declarations(self, env):
4676 for lhs in self.lhs_list:
4677 lhs.analyse_target_declaration(env)
4678
4679 def analyse_types(self, env, use_temp = 0):
4680 from ExprNodes import CloneNode, ProxyNode
4681
4682 rhs = self.rhs.analyse_types(env)
4683 if use_temp or rhs.is_attribute or (
4684 not rhs.is_name and not rhs.is_literal and
4685 rhs.type.is_pyobject):
4686 rhs = rhs.coerce_to_temp(env)
4687 else:
4688 rhs = rhs.coerce_to_simple(env)
4689 self.rhs = ProxyNode(rhs)
4690
4691 self.coerced_rhs_list = []
4692 for lhs in self.lhs_list:
4693 lhs.analyse_target_types(env)
4694 lhs.gil_assignment_check(env)
4695 rhs = CloneNode(self.rhs)
4696 rhs = rhs.coerce_to(lhs.type, env)
4697 self.coerced_rhs_list.append(rhs)
4698 return self
4699
4700 def generate_rhs_evaluation_code(self, code):
4701 self.rhs.generate_evaluation_code(code)
4702
4703 def generate_assignment_code(self, code):
4704 for i in range(len(self.lhs_list)):
4705 lhs = self.lhs_list[i]
4706 rhs = self.coerced_rhs_list[i]
4707 rhs.generate_evaluation_code(code)
4708 lhs.generate_assignment_code(rhs, code)
4709 # Assignment has disposed of the cloned RHS
4710 self.rhs.generate_disposal_code(code)
4711 self.rhs.free_temps(code)
4712
4713 def generate_function_definitions(self, env, code):
4714 self.rhs.generate_function_definitions(env, code)
4715
4716 def annotate(self, code):
4717 for i in range(len(self.lhs_list)):
4718 self.lhs_list[i].annotate(code)
4719 self.coerced_rhs_list[i].annotate(code)
4720 self.rhs.annotate(code)
4721
4722
4723 class ParallelAssignmentNode(AssignmentNode):
4724 # A combined packing/unpacking assignment:
4725 #
4726 # a, b, c = d, e, f
4727 #
4728 # This has been rearranged by the parser into
4729 #
4730 # a = d ; b = e ; c = f
4731 #
4732 # but we must evaluate all the right hand sides
4733 # before assigning to any of the left hand sides.
4734 #
4735 # stats [AssignmentNode] The constituent assignments
4736
4737 child_attrs = ["stats"]
4738
4739 def analyse_declarations(self, env):
4740 for stat in self.stats:
4741 stat.analyse_declarations(env)
4742
4743 def analyse_expressions(self, env):
4744 self.stats = [ stat.analyse_types(env, use_temp = 1)
4745 for stat in self.stats ]
4746 return self
4747
4748 # def analyse_expressions(self, env):
4749 # for stat in self.stats:
4750 # stat.analyse_expressions_1(env, use_temp = 1)
4751 # for stat in self.stats:
4752 # stat.analyse_expressions_2(env)
4753
4754 def generate_execution_code(self, code):
4755 for stat in self.stats:
4756 stat.generate_rhs_evaluation_code(code)
4757 for stat in self.stats:
4758 stat.generate_assignment_code(code)
4759
4760 def generate_function_definitions(self, env, code):
4761 for stat in self.stats:
4762 stat.generate_function_definitions(env, code)
4763
4764 def annotate(self, code):
4765 for stat in self.stats:
4766 stat.annotate(code)
4767
4768
4769 class InPlaceAssignmentNode(AssignmentNode):
4770 # An in place arithmetic operand:
4771 #
4772 # a += b
4773 # a -= b
4774 # ...
4775 #
4776 # lhs ExprNode Left hand side
4777 # rhs ExprNode Right hand side
4778 # operator char one of "+-*/%^&|"
4779 #
4780 # This code is a bit tricky because in order to obey Python
4781 # semantics the sub-expressions (e.g. indices) of the lhs must
4782 # not be evaluated twice. So we must re-use the values calculated
4783 # in evaluation phase for the assignment phase as well.
4784 # Fortunately, the type of the lhs node is fairly constrained
4785 # (it must be a NameNode, AttributeNode, or IndexNode).
4786
4787 child_attrs = ["lhs", "rhs"]
4788
4789 def analyse_declarations(self, env):
4790 self.lhs.analyse_target_declaration(env)
4791
4792 def analyse_types(self, env):
4793 self.rhs = self.rhs.analyse_types(env)
4794 self.lhs = self.lhs.analyse_target_types(env)
4795
4796 # When assigning to a fully indexed buffer or memoryview, coerce the rhs
4797 if (self.lhs.is_subscript and
4798 (self.lhs.memslice_index or self.lhs.is_buffer_access)):
4799 self.rhs = self.rhs.coerce_to(self.lhs.type, env)
4800 elif self.lhs.type.is_string and self.operator in '+-':
4801 # use pointer arithmetic for char* LHS instead of string concat
4802 self.rhs = self.rhs.coerce_to(PyrexTypes.c_py_ssize_t_type, env)
4803 return self
4804
4805 def generate_execution_code(self, code):
4806 self.rhs.generate_evaluation_code(code)
4807 self.lhs.generate_subexpr_evaluation_code(code)
4808 c_op = self.operator
4809 if c_op == "//":
4810 c_op = "/"
4811 elif c_op == "**":
4812 error(self.pos, "No C inplace power operator")
4813 if self.lhs.is_subscript and self.lhs.is_buffer_access:
4814 if self.lhs.type.is_pyobject:
4815 error(self.pos, "In-place operators not allowed on object buffers in this release.")
4816 if (c_op in ('/', '%') and self.lhs.type.is_int
4817 and not code.globalstate.directives['cdivision']):
4818 error(self.pos, "In-place non-c divide operators not allowed on int buffers.")
4819 self.lhs.generate_buffer_setitem_code(self.rhs, code, c_op)
4820 else:
4821 # C++
4822 # TODO: make sure overload is declared
4823 code.putln("%s %s= %s;" % (self.lhs.result(), c_op, self.rhs.result()))
4824 self.lhs.generate_subexpr_disposal_code(code)
4825 self.lhs.free_subexpr_temps(code)
4826 self.rhs.generate_disposal_code(code)
4827 self.rhs.free_temps(code)
4828
4829 def annotate(self, code):
4830 self.lhs.annotate(code)
4831 self.rhs.annotate(code)
4832
4833 def create_binop_node(self):
4834 import ExprNodes
4835 return ExprNodes.binop_node(self.pos, self.operator, self.lhs, self.rhs)
4836
4837
4838 class PrintStatNode(StatNode):
4839 # print statement
4840 #
4841 # arg_tuple TupleNode
4842 # stream ExprNode or None (stdout)
4843 # append_newline boolean
4844
4845 child_attrs = ["arg_tuple", "stream"]
4846
4847 def analyse_expressions(self, env):
4848 if self.stream:
4849 stream = self.stream.analyse_expressions(env)
4850 self.stream = stream.coerce_to_pyobject(env)
4851 arg_tuple = self.arg_tuple.analyse_expressions(env)
4852 self.arg_tuple = arg_tuple.coerce_to_pyobject(env)
4853 env.use_utility_code(printing_utility_code)
4854 if len(self.arg_tuple.args) == 1 and self.append_newline:
4855 env.use_utility_code(printing_one_utility_code)
4856 return self
4857
4858 nogil_check = Node.gil_error
4859 gil_message = "Python print statement"
4860
4861 def generate_execution_code(self, code):
4862 if self.stream:
4863 self.stream.generate_evaluation_code(code)
4864 stream_result = self.stream.py_result()
4865 else:
4866 stream_result = '0'
4867 if len(self.arg_tuple.args) == 1 and self.append_newline:
4868 arg = self.arg_tuple.args[0]
4869 arg.generate_evaluation_code(code)
4870
4871 code.putln(
4872 "if (__Pyx_PrintOne(%s, %s) < 0) %s" % (
4873 stream_result,
4874 arg.py_result(),
4875 code.error_goto(self.pos)))
4876 arg.generate_disposal_code(code)
4877 arg.free_temps(code)
4878 else:
4879 self.arg_tuple.generate_evaluation_code(code)
4880 code.putln(
4881 "if (__Pyx_Print(%s, %s, %d) < 0) %s" % (
4882 stream_result,
4883 self.arg_tuple.py_result(),
4884 self.append_newline,
4885 code.error_goto(self.pos)))
4886 self.arg_tuple.generate_disposal_code(code)
4887 self.arg_tuple.free_temps(code)
4888
4889 if self.stream:
4890 self.stream.generate_disposal_code(code)
4891 self.stream.free_temps(code)
4892
4893 def generate_function_definitions(self, env, code):
4894 if self.stream:
4895 self.stream.generate_function_definitions(env, code)
4896 self.arg_tuple.generate_function_definitions(env, code)
4897
4898 def annotate(self, code):
4899 if self.stream:
4900 self.stream.annotate(code)
4901 self.arg_tuple.annotate(code)
4902
4903
4904 class ExecStatNode(StatNode):
4905 # exec statement
4906 #
4907 # args [ExprNode]
4908
4909 child_attrs = ["args"]
4910
4911 def analyse_expressions(self, env):
4912 for i, arg in enumerate(self.args):
4913 arg = arg.analyse_expressions(env)
4914 arg = arg.coerce_to_pyobject(env)
4915 self.args[i] = arg
4916 env.use_utility_code(Builtin.pyexec_utility_code)
4917 return self
4918
4919 nogil_check = Node.gil_error
4920 gil_message = "Python exec statement"
4921
4922 def generate_execution_code(self, code):
4923 args = []
4924 for arg in self.args:
4925 arg.generate_evaluation_code(code)
4926 args.append( arg.py_result() )
4927 args = tuple(args + ['0', '0'][:3-len(args)])
4928 temp_result = code.funcstate.allocate_temp(PyrexTypes.py_object_type, manage_ref=True)
4929 code.putln("%s = __Pyx_PyExec3(%s, %s, %s);" % (
4930 (temp_result,) + args))
4931 for arg in self.args:
4932 arg.generate_disposal_code(code)
4933 arg.free_temps(code)
4934 code.putln(
4935 code.error_goto_if_null(temp_result, self.pos))
4936 code.put_gotref(temp_result)
4937 code.put_decref_clear(temp_result, py_object_type)
4938 code.funcstate.release_temp(temp_result)
4939
4940 def annotate(self, code):
4941 for arg in self.args:
4942 arg.annotate(code)
4943
4944
4945 class DelStatNode(StatNode):
4946 # del statement
4947 #
4948 # args [ExprNode]
4949
4950 child_attrs = ["args"]
4951 ignore_nonexisting = False
4952
4953 def analyse_declarations(self, env):
4954 for arg in self.args:
4955 arg.analyse_target_declaration(env)
4956
4957 def analyse_expressions(self, env):
4958 for i, arg in enumerate(self.args):
4959 arg = self.args[i] = arg.analyse_target_expression(env, None)
4960 if arg.type.is_pyobject or (arg.is_name and
4961 arg.type.is_memoryviewslice):
4962 if arg.is_name and arg.entry.is_cglobal:
4963 error(arg.pos, "Deletion of global C variable")
4964 elif arg.type.is_ptr and arg.type.base_type.is_cpp_class:
4965 self.cpp_check(env)
4966 elif arg.type.is_cpp_class:
4967 error(arg.pos, "Deletion of non-heap C++ object")
4968 elif arg.is_subscript and arg.base.type is Builtin.bytearray_type:
4969 pass # del ba[i]
4970 else:
4971 error(arg.pos, "Deletion of non-Python, non-C++ object")
4972 #arg.release_target_temp(env)
4973 return self
4974
4975 def nogil_check(self, env):
4976 for arg in self.args:
4977 if arg.type.is_pyobject:
4978 self.gil_error()
4979
4980 gil_message = "Deleting Python object"
4981
4982 def generate_execution_code(self, code):
4983 for arg in self.args:
4984 if (arg.type.is_pyobject or
4985 arg.type.is_memoryviewslice or
4986 arg.is_subscript and arg.base.type is Builtin.bytearray_type):
4987 arg.generate_deletion_code(
4988 code, ignore_nonexisting=self.ignore_nonexisting)
4989 elif arg.type.is_ptr and arg.type.base_type.is_cpp_class:
4990 arg.generate_result_code(code)
4991 code.putln("delete %s;" % arg.result())
4992 # else error reported earlier
4993
4994 def annotate(self, code):
4995 for arg in self.args:
4996 arg.annotate(code)
4997
4998
4999 class PassStatNode(StatNode):
5000 # pass statement
5001
5002 child_attrs = []
5003
5004 def analyse_expressions(self, env):
5005 return self
5006
5007 def generate_execution_code(self, code):
5008 pass
5009
5010
5011 class IndirectionNode(StatListNode):
5012 """
5013 This adds an indirection so that the node can be shared and a subtree can
5014 be removed at any time by clearing self.stats.
5015 """
5016
5017 def __init__(self, stats):
5018 super(IndirectionNode, self).__init__(stats[0].pos, stats=stats)
5019
5020 class BreakStatNode(StatNode):
5021
5022 child_attrs = []
5023 is_terminator = True
5024
5025 def analyse_expressions(self, env):
5026 return self
5027
5028 def generate_execution_code(self, code):
5029 if not code.break_label:
5030 error(self.pos, "break statement not inside loop")
5031 else:
5032 code.put_goto(code.break_label)
5033
5034
5035 class ContinueStatNode(StatNode):
5036
5037 child_attrs = []
5038 is_terminator = True
5039
5040 def analyse_expressions(self, env):
5041 return self
5042
5043 def generate_execution_code(self, code):
5044 if code.funcstate.in_try_finally:
5045 error(self.pos, "continue statement inside try of try...finally")
5046 elif not code.continue_label:
5047 error(self.pos, "continue statement not inside loop")
5048 else:
5049 code.put_goto(code.continue_label)
5050
5051
5052 class ReturnStatNode(StatNode):
5053 # return statement
5054 #
5055 # value ExprNode or None
5056 # return_type PyrexType
5057 # in_generator return inside of generator => raise StopIteration
5058
5059 child_attrs = ["value"]
5060 is_terminator = True
5061 in_generator = False
5062
5063 # Whether we are in a parallel section
5064 in_parallel = False
5065
5066 def analyse_expressions(self, env):
5067 return_type = env.return_type
5068 self.return_type = return_type
5069 if not return_type:
5070 error(self.pos, "Return not inside a function body")
5071 return self
5072 if self.value:
5073 self.value = self.value.analyse_types(env)
5074 if return_type.is_void or return_type.is_returncode:
5075 error(self.value.pos,
5076 "Return with value in void function")
5077 else:
5078 self.value = self.value.coerce_to(env.return_type, env)
5079 else:
5080 if (not return_type.is_void
5081 and not return_type.is_pyobject
5082 and not return_type.is_returncode):
5083 error(self.pos, "Return value required")
5084 return self
5085
5086 def nogil_check(self, env):
5087 if self.return_type.is_pyobject:
5088 self.gil_error()
5089
5090 gil_message = "Returning Python object"
5091
5092 def generate_execution_code(self, code):
5093 code.mark_pos(self.pos)
5094 if not self.return_type:
5095 # error reported earlier
5096 return
5097 if self.return_type.is_pyobject:
5098 code.put_xdecref(Naming.retval_cname,
5099 self.return_type)
5100
5101 if self.value:
5102 self.value.generate_evaluation_code(code)
5103 if self.return_type.is_memoryviewslice:
5104 import MemoryView
5105 MemoryView.put_acquire_memoryviewslice(
5106 lhs_cname=Naming.retval_cname,
5107 lhs_type=self.return_type,
5108 lhs_pos=self.value.pos,
5109 rhs=self.value,
5110 code=code,
5111 have_gil=self.in_nogil_context)
5112 elif self.in_generator:
5113 # return value == raise StopIteration(value), but uncatchable
5114 code.putln(
5115 "%s = NULL; PyErr_SetObject(PyExc_StopIteration, %s);" % (
5116 Naming.retval_cname,
5117 self.value.result_as(self.return_type)))
5118 self.value.generate_disposal_code(code)
5119 else:
5120 self.value.make_owned_reference(code)
5121 code.putln(
5122 "%s = %s;" % (
5123 Naming.retval_cname,
5124 self.value.result_as(self.return_type)))
5125 self.value.generate_post_assignment_code(code)
5126 self.value.free_temps(code)
5127 else:
5128 if self.return_type.is_pyobject:
5129 code.put_init_to_py_none(Naming.retval_cname, self.return_type)
5130 elif self.return_type.is_returncode:
5131 self.put_return(code, self.return_type.default_value)
5132
5133 for cname, type in code.funcstate.temps_holding_reference():
5134 code.put_decref_clear(cname, type)
5135
5136 code.put_goto(code.return_label)
5137
5138 def put_return(self, code, value):
5139 if self.in_parallel:
5140 code.putln_openmp("#pragma omp critical(__pyx_returning)")
5141 code.putln("%s = %s;" % (Naming.retval_cname, value))
5142
5143 def generate_function_definitions(self, env, code):
5144 if self.value is not None:
5145 self.value.generate_function_definitions(env, code)
5146
5147 def annotate(self, code):
5148 if self.value:
5149 self.value.annotate(code)
5150
5151
5152 class RaiseStatNode(StatNode):
5153 # raise statement
5154 #
5155 # exc_type ExprNode or None
5156 # exc_value ExprNode or None
5157 # exc_tb ExprNode or None
5158 # cause ExprNode or None
5159
5160 child_attrs = ["exc_type", "exc_value", "exc_tb", "cause"]
5161 is_terminator = True
5162
5163 def analyse_expressions(self, env):
5164 if self.exc_type:
5165 exc_type = self.exc_type.analyse_types(env)
5166 self.exc_type = exc_type.coerce_to_pyobject(env)
5167 if self.exc_value:
5168 exc_value = self.exc_value.analyse_types(env)
5169 self.exc_value = exc_value.coerce_to_pyobject(env)
5170 if self.exc_tb:
5171 exc_tb = self.exc_tb.analyse_types(env)
5172 self.exc_tb = exc_tb.coerce_to_pyobject(env)
5173 if self.cause:
5174 cause = self.cause.analyse_types(env)
5175 self.cause = cause.coerce_to_pyobject(env)
5176 # special cases for builtin exceptions
5177 self.builtin_exc_name = None
5178 if self.exc_type and not self.exc_value and not self.exc_tb:
5179 exc = self.exc_type
5180 import ExprNodes
5181 if (isinstance(exc, ExprNodes.SimpleCallNode) and
5182 not (exc.args or (exc.arg_tuple is not None and
5183 exc.arg_tuple.args))):
5184 exc = exc.function # extract the exception type
5185 if exc.is_name and exc.entry.is_builtin:
5186 self.builtin_exc_name = exc.name
5187 if self.builtin_exc_name == 'MemoryError':
5188 self.exc_type = None # has a separate implementation
5189 return self
5190
5191 nogil_check = Node.gil_error
5192 gil_message = "Raising exception"
5193
5194 def generate_execution_code(self, code):
5195 if self.builtin_exc_name == 'MemoryError':
5196 code.putln('PyErr_NoMemory(); %s' % code.error_goto(self.pos))
5197 return
5198
5199 if self.exc_type:
5200 self.exc_type.generate_evaluation_code(code)
5201 type_code = self.exc_type.py_result()
5202 else:
5203 type_code = "0"
5204 if self.exc_value:
5205 self.exc_value.generate_evaluation_code(code)
5206 value_code = self.exc_value.py_result()
5207 else:
5208 value_code = "0"
5209 if self.exc_tb:
5210 self.exc_tb.generate_evaluation_code(code)
5211 tb_code = self.exc_tb.py_result()
5212 else:
5213 tb_code = "0"
5214 if self.cause:
5215 self.cause.generate_evaluation_code(code)
5216 cause_code = self.cause.py_result()
5217 else:
5218 cause_code = "0"
5219 code.globalstate.use_utility_code(raise_utility_code)
5220 code.putln(
5221 "__Pyx_Raise(%s, %s, %s, %s);" % (
5222 type_code,
5223 value_code,
5224 tb_code,
5225 cause_code))
5226 for obj in (self.exc_type, self.exc_value, self.exc_tb, self.cause):
5227 if obj:
5228 obj.generate_disposal_code(code)
5229 obj.free_temps(code)
5230 code.putln(
5231 code.error_goto(self.pos))
5232
5233 def generate_function_definitions(self, env, code):
5234 if self.exc_type is not None:
5235 self.exc_type.generate_function_definitions(env, code)
5236 if self.exc_value is not None:
5237 self.exc_value.generate_function_definitions(env, code)
5238 if self.exc_tb is not None:
5239 self.exc_tb.generate_function_definitions(env, code)
5240 if self.cause is not None:
5241 self.cause.generate_function_definitions(env, code)
5242
5243 def annotate(self, code):
5244 if self.exc_type:
5245 self.exc_type.annotate(code)
5246 if self.exc_value:
5247 self.exc_value.annotate(code)
5248 if self.exc_tb:
5249 self.exc_tb.annotate(code)
5250 if self.cause:
5251 self.cause.annotate(code)
5252
5253
5254 class ReraiseStatNode(StatNode):
5255
5256 child_attrs = []
5257 is_terminator = True
5258
5259 def analyse_expressions(self, env):
5260 return self
5261
5262 nogil_check = Node.gil_error
5263 gil_message = "Raising exception"
5264
5265 def generate_execution_code(self, code):
5266 vars = code.funcstate.exc_vars
5267 if vars:
5268 code.globalstate.use_utility_code(restore_exception_utility_code)
5269 code.put_giveref(vars[0])
5270 code.put_giveref(vars[1])
5271 # fresh exceptions may not have a traceback yet (-> finally!)
5272 code.put_xgiveref(vars[2])
5273 code.putln("__Pyx_ErrRestore(%s, %s, %s);" % tuple(vars))
5274 for varname in vars:
5275 code.put("%s = 0; " % varname)
5276 code.putln()
5277 code.putln(code.error_goto(self.pos))
5278 else:
5279 code.globalstate.use_utility_code(
5280 UtilityCode.load_cached("ReRaiseException", "Exceptions.c"))
5281 code.putln("__Pyx_ReraiseException(); %s" % code.error_goto(self.pos))
5282
5283 class AssertStatNode(StatNode):
5284 # assert statement
5285 #
5286 # cond ExprNode
5287 # value ExprNode or None
5288
5289 child_attrs = ["cond", "value"]
5290
5291 def analyse_expressions(self, env):
5292 self.cond = self.cond.analyse_boolean_expression(env)
5293 if self.value:
5294 value = self.value.analyse_types(env)
5295 if value.type is Builtin.tuple_type or not value.type.is_builtin_type:
5296 # prevent tuple values from being interpreted as argument value tuples
5297 from ExprNodes import TupleNode
5298 value = TupleNode(value.pos, args=[value], slow=True)
5299 self.value = value.analyse_types(env, skip_children=True)
5300 else:
5301 self.value = value.coerce_to_pyobject(env)
5302 return self
5303
5304 nogil_check = Node.gil_error
5305 gil_message = "Raising exception"
5306
5307 def generate_execution_code(self, code):
5308 code.putln("#ifndef CYTHON_WITHOUT_ASSERTIONS")
5309 code.putln("if (unlikely(!Py_OptimizeFlag)) {")
5310 self.cond.generate_evaluation_code(code)
5311 code.putln(
5312 "if (unlikely(!%s)) {" %
5313 self.cond.result())
5314 if self.value:
5315 self.value.generate_evaluation_code(code)
5316 code.putln(
5317 "PyErr_SetObject(PyExc_AssertionError, %s);" %
5318 self.value.py_result())
5319 self.value.generate_disposal_code(code)
5320 self.value.free_temps(code)
5321 else:
5322 code.putln(
5323 "PyErr_SetNone(PyExc_AssertionError);")
5324 code.putln(
5325 code.error_goto(self.pos))
5326 code.putln(
5327 "}")
5328 self.cond.generate_disposal_code(code)
5329 self.cond.free_temps(code)
5330 code.putln(
5331 "}")
5332 code.putln("#endif")
5333
5334 def generate_function_definitions(self, env, code):
5335 self.cond.generate_function_definitions(env, code)
5336 if self.value is not None:
5337 self.value.generate_function_definitions(env, code)
5338
5339 def annotate(self, code):
5340 self.cond.annotate(code)
5341 if self.value:
5342 self.value.annotate(code)
5343
5344
5345 class IfStatNode(StatNode):
5346 # if statement
5347 #
5348 # if_clauses [IfClauseNode]
5349 # else_clause StatNode or None
5350
5351 child_attrs = ["if_clauses", "else_clause"]
5352
5353 def analyse_declarations(self, env):
5354 for if_clause in self.if_clauses:
5355 if_clause.analyse_declarations(env)
5356 if self.else_clause:
5357 self.else_clause.analyse_declarations(env)
5358
5359 def analyse_expressions(self, env):
5360 self.if_clauses = [ if_clause.analyse_expressions(env)
5361 for if_clause in self.if_clauses ]
5362 if self.else_clause:
5363 self.else_clause = self.else_clause.analyse_expressions(env)
5364 return self
5365
5366 def generate_execution_code(self, code):
5367 code.mark_pos(self.pos)
5368 end_label = code.new_label()
5369 for if_clause in self.if_clauses:
5370 if_clause.generate_execution_code(code, end_label)
5371 if self.else_clause:
5372 code.putln("/*else*/ {")
5373 self.else_clause.generate_execution_code(code)
5374 code.putln("}")
5375 code.put_label(end_label)
5376
5377 def generate_function_definitions(self, env, code):
5378 for clause in self.if_clauses:
5379 clause.generate_function_definitions(env, code)
5380 if self.else_clause is not None:
5381 self.else_clause.generate_function_definitions(env, code)
5382
5383 def annotate(self, code):
5384 for if_clause in self.if_clauses:
5385 if_clause.annotate(code)
5386 if self.else_clause:
5387 self.else_clause.annotate(code)
5388
5389
5390 class IfClauseNode(Node):
5391 # if or elif clause in an if statement
5392 #
5393 # condition ExprNode
5394 # body StatNode
5395
5396 child_attrs = ["condition", "body"]
5397
5398 def analyse_declarations(self, env):
5399 self.body.analyse_declarations(env)
5400
5401 def analyse_expressions(self, env):
5402 self.condition = \
5403 self.condition.analyse_temp_boolean_expression(env)
5404 self.body = self.body.analyse_expressions(env)
5405 return self
5406
5407 def generate_execution_code(self, code, end_label):
5408 self.condition.generate_evaluation_code(code)
5409 code.putln(
5410 "if (%s) {" %
5411 self.condition.result())
5412 self.condition.generate_disposal_code(code)
5413 self.condition.free_temps(code)
5414 self.body.generate_execution_code(code)
5415 if not self.body.is_terminator:
5416 code.put_goto(end_label)
5417 code.putln("}")
5418
5419 def generate_function_definitions(self, env, code):
5420 self.condition.generate_function_definitions(env, code)
5421 self.body.generate_function_definitions(env, code)
5422
5423 def annotate(self, code):
5424 self.condition.annotate(code)
5425 self.body.annotate(code)
5426
5427
5428 class SwitchCaseNode(StatNode):
5429 # Generated in the optimization of an if-elif-else node
5430 #
5431 # conditions [ExprNode]
5432 # body StatNode
5433
5434 child_attrs = ['conditions', 'body']
5435
5436 def generate_execution_code(self, code):
5437 for cond in self.conditions:
5438 code.mark_pos(cond.pos)
5439 cond.generate_evaluation_code(code)
5440 code.putln("case %s:" % cond.result())
5441 self.body.generate_execution_code(code)
5442 code.putln("break;")
5443
5444 def generate_function_definitions(self, env, code):
5445 for cond in self.conditions:
5446 cond.generate_function_definitions(env, code)
5447 self.body.generate_function_definitions(env, code)
5448
5449 def annotate(self, code):
5450 for cond in self.conditions:
5451 cond.annotate(code)
5452 self.body.annotate(code)
5453
5454 class SwitchStatNode(StatNode):
5455 # Generated in the optimization of an if-elif-else node
5456 #
5457 # test ExprNode
5458 # cases [SwitchCaseNode]
5459 # else_clause StatNode or None
5460
5461 child_attrs = ['test', 'cases', 'else_clause']
5462
5463 def generate_execution_code(self, code):
5464 self.test.generate_evaluation_code(code)
5465 code.putln("switch (%s) {" % self.test.result())
5466 for case in self.cases:
5467 case.generate_execution_code(code)
5468 if self.else_clause is not None:
5469 code.putln("default:")
5470 self.else_clause.generate_execution_code(code)
5471 code.putln("break;")
5472 else:
5473 # Always generate a default clause to prevent C compiler warnings
5474 # about unmatched enum values (it was not the user who decided to
5475 # generate the switch statement, so shouldn't be bothered).
5476 code.putln("default: break;")
5477 code.putln("}")
5478
5479 def generate_function_definitions(self, env, code):
5480 self.test.generate_function_definitions(env, code)
5481 for case in self.cases:
5482 case.generate_function_definitions(env, code)
5483 if self.else_clause is not None:
5484 self.else_clause.generate_function_definitions(env, code)
5485
5486 def annotate(self, code):
5487 self.test.annotate(code)
5488 for case in self.cases:
5489 case.annotate(code)
5490 if self.else_clause is not None:
5491 self.else_clause.annotate(code)
5492
5493 class LoopNode(object):
5494 pass
5495
5496
5497 class WhileStatNode(LoopNode, StatNode):
5498 # while statement
5499 #
5500 # condition ExprNode
5501 # body StatNode
5502 # else_clause StatNode
5503
5504 child_attrs = ["condition", "body", "else_clause"]
5505
5506 def analyse_declarations(self, env):
5507 self.body.analyse_declarations(env)
5508 if self.else_clause:
5509 self.else_clause.analyse_declarations(env)
5510
5511 def analyse_expressions(self, env):
5512 if self.condition:
5513 self.condition = self.condition.analyse_temp_boolean_expression(env)
5514 self.body = self.body.analyse_expressions(env)
5515 if self.else_clause:
5516 self.else_clause = self.else_clause.analyse_expressions(env)
5517 return self
5518
5519 def generate_execution_code(self, code):
5520 old_loop_labels = code.new_loop_labels()
5521 code.putln(
5522 "while (1) {")
5523 if self.condition:
5524 self.condition.generate_evaluation_code(code)
5525 self.condition.generate_disposal_code(code)
5526 code.putln(
5527 "if (!%s) break;" %
5528 self.condition.result())
5529 self.condition.free_temps(code)
5530 self.body.generate_execution_code(code)
5531 code.put_label(code.continue_label)
5532 code.putln("}")
5533 break_label = code.break_label
5534 code.set_loop_labels(old_loop_labels)
5535 if self.else_clause:
5536 code.mark_pos(self.else_clause.pos)
5537 code.putln("/*else*/ {")
5538 self.else_clause.generate_execution_code(code)
5539 code.putln("}")
5540 code.put_label(break_label)
5541
5542 def generate_function_definitions(self, env, code):
5543 if self.condition:
5544 self.condition.generate_function_definitions(env, code)
5545 self.body.generate_function_definitions(env, code)
5546 if self.else_clause is not None:
5547 self.else_clause.generate_function_definitions(env, code)
5548
5549 def annotate(self, code):
5550 if self.condition:
5551 self.condition.annotate(code)
5552 self.body.annotate(code)
5553 if self.else_clause:
5554 self.else_clause.annotate(code)
5555
5556
5557 class DictIterationNextNode(Node):
5558 # Helper node for calling PyDict_Next() inside of a WhileStatNode
5559 # and checking the dictionary size for changes. Created in
5560 # Optimize.py.
5561 child_attrs = ['dict_obj', 'expected_size', 'pos_index_var',
5562 'coerced_key_var', 'coerced_value_var', 'coerced_tuple_var',
5563 'key_target', 'value_target', 'tuple_target', 'is_dict_flag']
5564
5565 coerced_key_var = key_ref = None
5566 coerced_value_var = value_ref = None
5567 coerced_tuple_var = tuple_ref = None
5568
5569 def __init__(self, dict_obj, expected_size, pos_index_var,
5570 key_target, value_target, tuple_target, is_dict_flag):
5571 Node.__init__(
5572 self, dict_obj.pos,
5573 dict_obj = dict_obj,
5574 expected_size = expected_size,
5575 pos_index_var = pos_index_var,
5576 key_target = key_target,
5577 value_target = value_target,
5578 tuple_target = tuple_target,
5579 is_dict_flag = is_dict_flag,
5580 is_temp = True,
5581 type = PyrexTypes.c_bint_type)
5582
5583 def analyse_expressions(self, env):
5584 import ExprNodes
5585 self.dict_obj = self.dict_obj.analyse_types(env)
5586 self.expected_size = self.expected_size.analyse_types(env)
5587 if self.pos_index_var:
5588 self.pos_index_var = self.pos_index_var.analyse_types(env)
5589 if self.key_target:
5590 self.key_target = self.key_target.analyse_target_types(env)
5591 self.key_ref = ExprNodes.TempNode(self.key_target.pos, PyrexTypes.py_object_type)
5592 self.coerced_key_var = self.key_ref.coerce_to(self.key_target.type, env)
5593 if self.value_target:
5594 self.value_target = self.value_target.analyse_target_types(env)
5595 self.value_ref = ExprNodes.TempNode(self.value_target.pos, type=PyrexTypes.py_object_type)
5596 self.coerced_value_var = self.value_ref.coerce_to(self.value_target.type, env)
5597 if self.tuple_target:
5598 self.tuple_target = self.tuple_target.analyse_target_types(env)
5599 self.tuple_ref = ExprNodes.TempNode(self.tuple_target.pos, PyrexTypes.py_object_type)
5600 self.coerced_tuple_var = self.tuple_ref.coerce_to(self.tuple_target.type, env)
5601 self.is_dict_flag = self.is_dict_flag.analyse_types(env)
5602 return self
5603
5604 def generate_function_definitions(self, env, code):
5605 self.dict_obj.generate_function_definitions(env, code)
5606
5607 def generate_execution_code(self, code):
5608 code.globalstate.use_utility_code(UtilityCode.load_cached("dict_iter", "Optimize.c"))
5609 self.dict_obj.generate_evaluation_code(code)
5610
5611 assignments = []
5612 temp_addresses = []
5613 for var, result, target in [(self.key_ref, self.coerced_key_var, self.key_target),
5614 (self.value_ref, self.coerced_value_var, self.value_target),
5615 (self.tuple_ref, self.coerced_tuple_var, self.tuple_target)]:
5616 if target is None:
5617 addr = 'NULL'
5618 else:
5619 assignments.append((var, result, target))
5620 var.allocate(code)
5621 addr = '&%s' % var.result()
5622 temp_addresses.append(addr)
5623
5624 result_temp = code.funcstate.allocate_temp(PyrexTypes.c_int_type, False)
5625 code.putln("%s = __Pyx_dict_iter_next(%s, %s, &%s, %s, %s, %s, %s);" % (
5626 result_temp,
5627 self.dict_obj.py_result(),
5628 self.expected_size.result(),
5629 self.pos_index_var.result(),
5630 temp_addresses[0],
5631 temp_addresses[1],
5632 temp_addresses[2],
5633 self.is_dict_flag.result()
5634 ))
5635 code.putln("if (unlikely(%s == 0)) break;" % result_temp)
5636 code.putln(code.error_goto_if("%s == -1" % result_temp, self.pos))
5637 code.funcstate.release_temp(result_temp)
5638
5639 # evaluate all coercions before the assignments
5640 for var, result, target in assignments:
5641 code.put_gotref(var.result())
5642 for var, result, target in assignments:
5643 result.generate_evaluation_code(code)
5644 for var, result, target in assignments:
5645 target.generate_assignment_code(result, code)
5646 var.release(code)
5647
5648 def ForStatNode(pos, **kw):
5649 if 'iterator' in kw:
5650 return ForInStatNode(pos, **kw)
5651 else:
5652 return ForFromStatNode(pos, **kw)
5653
5654 class ForInStatNode(LoopNode, StatNode):
5655 # for statement
5656 #
5657 # target ExprNode
5658 # iterator IteratorNode
5659 # body StatNode
5660 # else_clause StatNode
5661 # item NextNode used internally
5662
5663 child_attrs = ["target", "iterator", "body", "else_clause"]
5664 item = None
5665
5666 def analyse_declarations(self, env):
5667 import ExprNodes
5668 self.target.analyse_target_declaration(env)
5669 self.body.analyse_declarations(env)
5670 if self.else_clause:
5671 self.else_clause.analyse_declarations(env)
5672 self.item = ExprNodes.NextNode(self.iterator)
5673
5674 def analyse_expressions(self, env):
5675 self.target = self.target.analyse_target_types(env)
5676 self.iterator = self.iterator.analyse_expressions(env)
5677 import ExprNodes
5678 self.item = ExprNodes.NextNode(self.iterator) # must rewrap after analysis
5679 self.item = self.item.analyse_expressions(env)
5680 if (self.iterator.type.is_ptr or self.iterator.type.is_array) and \
5681 self.target.type.assignable_from(self.iterator.type):
5682 # C array slice optimization.
5683 pass
5684 else:
5685 self.item = self.item.coerce_to(self.target.type, env)
5686 self.body = self.body.analyse_expressions(env)
5687 if self.else_clause:
5688 self.else_clause = self.else_clause.analyse_expressions(env)
5689 return self
5690
5691 def generate_execution_code(self, code):
5692 old_loop_labels = code.new_loop_labels()
5693 self.iterator.generate_evaluation_code(code)
5694 code.putln("for (;;) {")
5695 self.item.generate_evaluation_code(code)
5696 self.target.generate_assignment_code(self.item, code)
5697 self.body.generate_execution_code(code)
5698 code.put_label(code.continue_label)
5699 code.putln("}")
5700 break_label = code.break_label
5701 code.set_loop_labels(old_loop_labels)
5702
5703 if self.else_clause:
5704 # in nested loops, the 'else' block can contain a
5705 # 'continue' statement for the outer loop, but we may need
5706 # to generate cleanup code before taking that path, so we
5707 # intercept it here
5708 orig_continue_label = code.continue_label
5709 code.continue_label = code.new_label('outer_continue')
5710
5711 code.putln("/*else*/ {")
5712 self.else_clause.generate_execution_code(code)
5713 code.putln("}")
5714
5715 if code.label_used(code.continue_label):
5716 code.put_goto(break_label)
5717 code.put_label(code.continue_label)
5718 self.iterator.generate_disposal_code(code)
5719 code.put_goto(orig_continue_label)
5720 code.set_loop_labels(old_loop_labels)
5721
5722 if code.label_used(break_label):
5723 code.put_label(break_label)
5724 self.iterator.generate_disposal_code(code)
5725 self.iterator.free_temps(code)
5726
5727 def generate_function_definitions(self, env, code):
5728 self.target.generate_function_definitions(env, code)
5729 self.iterator.generate_function_definitions(env, code)
5730 self.body.generate_function_definitions(env, code)
5731 if self.else_clause is not None:
5732 self.else_clause.generate_function_definitions(env, code)
5733
5734 def annotate(self, code):
5735 self.target.annotate(code)
5736 self.iterator.annotate(code)
5737 self.body.annotate(code)
5738 if self.else_clause:
5739 self.else_clause.annotate(code)
5740 self.item.annotate(code)
5741
5742
5743 class ForFromStatNode(LoopNode, StatNode):
5744 # for name from expr rel name rel expr
5745 #
5746 # target NameNode
5747 # bound1 ExprNode
5748 # relation1 string
5749 # relation2 string
5750 # bound2 ExprNode
5751 # step ExprNode or None
5752 # body StatNode
5753 # else_clause StatNode or None
5754 #
5755 # Used internally:
5756 #
5757 # from_range bool
5758 # is_py_target bool
5759 # loopvar_node ExprNode (usually a NameNode or temp node)
5760 # py_loopvar_node PyTempNode or None
5761 child_attrs = ["target", "bound1", "bound2", "step", "body", "else_clause"]
5762
5763 is_py_target = False
5764 loopvar_node = None
5765 py_loopvar_node = None
5766 from_range = False
5767
5768 gil_message = "For-loop using object bounds or target"
5769
5770 def nogil_check(self, env):
5771 for x in (self.target, self.bound1, self.bound2):
5772 if x.type.is_pyobject:
5773 self.gil_error()
5774
5775 def analyse_declarations(self, env):
5776 self.target.analyse_target_declaration(env)
5777 self.body.analyse_declarations(env)
5778 if self.else_clause:
5779 self.else_clause.analyse_declarations(env)
5780
5781 def analyse_expressions(self, env):
5782 import ExprNodes
5783 self.target = self.target.analyse_target_types(env)
5784 self.bound1 = self.bound1.analyse_types(env)
5785 self.bound2 = self.bound2.analyse_types(env)
5786 if self.step is not None:
5787 if isinstance(self.step, ExprNodes.UnaryMinusNode):
5788 warning(self.step.pos, "Probable infinite loop in for-from-by statement. Consider switching the directions of the relations.", 2)
5789 self.step = self.step.analyse_types(env)
5790
5791 if self.target.type.is_numeric:
5792 loop_type = self.target.type
5793 else:
5794 loop_type = PyrexTypes.c_int_type
5795 if not self.bound1.type.is_pyobject:
5796 loop_type = PyrexTypes.widest_numeric_type(loop_type, self.bound1.type)
5797 if not self.bound2.type.is_pyobject:
5798 loop_type = PyrexTypes.widest_numeric_type(loop_type, self.bound2.type)
5799 if self.step is not None and not self.step.type.is_pyobject:
5800 loop_type = PyrexTypes.widest_numeric_type(loop_type, self.step.type)
5801 self.bound1 = self.bound1.coerce_to(loop_type, env)
5802 self.bound2 = self.bound2.coerce_to(loop_type, env)
5803 if not self.bound2.is_literal:
5804 self.bound2 = self.bound2.coerce_to_temp(env)
5805 if self.step is not None:
5806 self.step = self.step.coerce_to(loop_type, env)
5807 if not self.step.is_literal:
5808 self.step = self.step.coerce_to_temp(env)
5809
5810 target_type = self.target.type
5811 if not (target_type.is_pyobject or target_type.is_numeric):
5812 error(self.target.pos,
5813 "for-from loop variable must be c numeric type or Python object")
5814 if target_type.is_numeric:
5815 self.is_py_target = False
5816 if isinstance(self.target, ExprNodes.IndexNode) and self.target.is_buffer_access:
5817 raise error(self.pos, "Buffer indexing not allowed as for loop target.")
5818 self.loopvar_node = self.target
5819 self.py_loopvar_node = None
5820 else:
5821 self.is_py_target = True
5822 c_loopvar_node = ExprNodes.TempNode(self.pos, loop_type, env)
5823 self.loopvar_node = c_loopvar_node
5824 self.py_loopvar_node = \
5825 ExprNodes.CloneNode(c_loopvar_node).coerce_to_pyobject(env)
5826 self.body = self.body.analyse_expressions(env)
5827 if self.else_clause:
5828 self.else_clause = self.else_clause.analyse_expressions(env)
5829 return self
5830
5831 def generate_execution_code(self, code):
5832 old_loop_labels = code.new_loop_labels()
5833 from_range = self.from_range
5834 self.bound1.generate_evaluation_code(code)
5835 self.bound2.generate_evaluation_code(code)
5836 offset, incop = self.relation_table[self.relation1]
5837 if self.step is not None:
5838 self.step.generate_evaluation_code(code)
5839 step = self.step.result()
5840 incop = "%s=%s" % (incop[0], step)
5841 import ExprNodes
5842 if isinstance(self.loopvar_node, ExprNodes.TempNode):
5843 self.loopvar_node.allocate(code)
5844 if isinstance(self.py_loopvar_node, ExprNodes.TempNode):
5845 self.py_loopvar_node.allocate(code)
5846 if from_range:
5847 loopvar_name = code.funcstate.allocate_temp(self.target.type, False)
5848 else:
5849 loopvar_name = self.loopvar_node.result()
5850 code.putln(
5851 "for (%s = %s%s; %s %s %s; %s%s) {" % (
5852 loopvar_name,
5853 self.bound1.result(), offset,
5854 loopvar_name, self.relation2, self.bound2.result(),
5855 loopvar_name, incop))
5856 if self.py_loopvar_node:
5857 self.py_loopvar_node.generate_evaluation_code(code)
5858 self.target.generate_assignment_code(self.py_loopvar_node, code)
5859 elif from_range:
5860 code.putln("%s = %s;" % (
5861 self.target.result(), loopvar_name))
5862 self.body.generate_execution_code(code)
5863 code.put_label(code.continue_label)
5864 if self.py_loopvar_node:
5865 # This mess is to make for..from loops with python targets behave
5866 # exactly like those with C targets with regards to re-assignment
5867 # of the loop variable.
5868 import ExprNodes
5869 if self.target.entry.is_pyglobal:
5870 # We know target is a NameNode, this is the only ugly case.
5871 target_node = ExprNodes.PyTempNode(self.target.pos, None)
5872 target_node.allocate(code)
5873 interned_cname = code.intern_identifier(self.target.entry.name)
5874 if self.target.entry.scope.is_module_scope:
5875 code.globalstate.use_utility_code(
5876 UtilityCode.load_cached("GetModuleGlobalName", "ObjectHandling.c"))
5877 lookup_func = '__Pyx_GetModuleGlobalName(%s)'
5878 else:
5879 code.globalstate.use_utility_code(
5880 UtilityCode.load_cached("GetNameInClass", "ObjectHandling.c"))
5881 lookup_func = '__Pyx_GetNameInClass(%s, %%s)' % (
5882 self.target.entry.scope.namespace_cname)
5883 code.putln("%s = %s; %s" % (
5884 target_node.result(),
5885 lookup_func % interned_cname,
5886 code.error_goto_if_null(target_node.result(), self.target.pos)))
5887 code.put_gotref(target_node.result())
5888 else:
5889 target_node = self.target
5890 from_py_node = ExprNodes.CoerceFromPyTypeNode(
5891 self.loopvar_node.type, target_node, self.target.entry.scope)
5892 from_py_node.temp_code = loopvar_name
5893 from_py_node.generate_result_code(code)
5894 if self.target.entry.is_pyglobal:
5895 code.put_decref(target_node.result(), target_node.type)
5896 target_node.release(code)
5897 code.putln("}")
5898 if self.py_loopvar_node:
5899 # This is potentially wasteful, but we don't want the semantics to
5900 # depend on whether or not the loop is a python type.
5901 self.py_loopvar_node.generate_evaluation_code(code)
5902 self.target.generate_assignment_code(self.py_loopvar_node, code)
5903 if from_range:
5904 code.funcstate.release_temp(loopvar_name)
5905 break_label = code.break_label
5906 code.set_loop_labels(old_loop_labels)
5907 if self.else_clause:
5908 code.putln("/*else*/ {")
5909 self.else_clause.generate_execution_code(code)
5910 code.putln("}")
5911 code.put_label(break_label)
5912 self.bound1.generate_disposal_code(code)
5913 self.bound1.free_temps(code)
5914 self.bound2.generate_disposal_code(code)
5915 self.bound2.free_temps(code)
5916 if isinstance(self.loopvar_node, ExprNodes.TempNode):
5917 self.loopvar_node.release(code)
5918 if isinstance(self.py_loopvar_node, ExprNodes.TempNode):
5919 self.py_loopvar_node.release(code)
5920 if self.step is not None:
5921 self.step.generate_disposal_code(code)
5922 self.step.free_temps(code)
5923
5924 relation_table = {
5925 # {relop : (initial offset, increment op)}
5926 '<=': ("", "++"),
5927 '<' : ("+1", "++"),
5928 '>=': ("", "--"),
5929 '>' : ("-1", "--")
5930 }
5931
5932 def generate_function_definitions(self, env, code):
5933 self.target.generate_function_definitions(env, code)
5934 self.bound1.generate_function_definitions(env, code)
5935 self.bound2.generate_function_definitions(env, code)
5936 if self.step is not None:
5937 self.step.generate_function_definitions(env, code)
5938 self.body.generate_function_definitions(env, code)
5939 if self.else_clause is not None:
5940 self.else_clause.generate_function_definitions(env, code)
5941
5942 def annotate(self, code):
5943 self.target.annotate(code)
5944 self.bound1.annotate(code)
5945 self.bound2.annotate(code)
5946 if self.step:
5947 self.step.annotate(code)
5948 self.body.annotate(code)
5949 if self.else_clause:
5950 self.else_clause.annotate(code)
5951
5952
5953 class WithStatNode(StatNode):
5954 """
5955 Represents a Python with statement.
5956
5957 Implemented by the WithTransform as follows:
5958
5959 MGR = EXPR
5960 EXIT = MGR.__exit__
5961 VALUE = MGR.__enter__()
5962 EXC = True
5963 try:
5964 try:
5965 TARGET = VALUE # optional
5966 BODY
5967 except:
5968 EXC = False
5969 if not EXIT(*EXCINFO):
5970 raise
5971 finally:
5972 if EXC:
5973 EXIT(None, None, None)
5974 MGR = EXIT = VALUE = None
5975 """
5976 # manager The with statement manager object
5977 # target ExprNode the target lhs of the __enter__() call
5978 # body StatNode
5979 # enter_call ExprNode the call to the __enter__() method
5980 # exit_var String the cname of the __exit__() method reference
5981
5982 child_attrs = ["manager", "enter_call", "target", "body"]
5983
5984 enter_call = None
5985
5986 def analyse_declarations(self, env):
5987 self.manager.analyse_declarations(env)
5988 self.enter_call.analyse_declarations(env)
5989 self.body.analyse_declarations(env)
5990
5991 def analyse_expressions(self, env):
5992 self.manager = self.manager.analyse_types(env)
5993 self.enter_call = self.enter_call.analyse_types(env)
5994 self.body = self.body.analyse_expressions(env)
5995 return self
5996
5997 def generate_function_definitions(self, env, code):
5998 self.manager.generate_function_definitions(env, code)
5999 self.enter_call.generate_function_definitions(env, code)
6000 self.body.generate_function_definitions(env, code)
6001
6002 def generate_execution_code(self, code):
6003 code.putln("/*with:*/ {")
6004 self.manager.generate_evaluation_code(code)
6005 self.exit_var = code.funcstate.allocate_temp(py_object_type, manage_ref=False)
6006 code.globalstate.use_utility_code(
6007 UtilityCode.load_cached("PyObjectLookupSpecial", "ObjectHandling.c"))
6008 code.putln("%s = __Pyx_PyObject_LookupSpecial(%s, %s); %s" % (
6009 self.exit_var,
6010 self.manager.py_result(),
6011 code.intern_identifier(EncodedString('__exit__')),
6012 code.error_goto_if_null(self.exit_var, self.pos),
6013 ))
6014 code.put_gotref(self.exit_var)
6015
6016 # need to free exit_var in the face of exceptions during setup
6017 old_error_label = code.new_error_label()
6018 intermediate_error_label = code.error_label
6019
6020 self.enter_call.generate_evaluation_code(code)
6021 if not self.target:
6022 self.enter_call.generate_disposal_code(code)
6023 self.enter_call.free_temps(code)
6024 else:
6025 # Otherwise, the node will be cleaned up by the
6026 # WithTargetAssignmentStatNode after assigning its result
6027 # to the target of the 'with' statement.
6028 pass
6029 self.manager.generate_disposal_code(code)
6030 self.manager.free_temps(code)
6031
6032 code.error_label = old_error_label
6033 self.body.generate_execution_code(code)
6034
6035 if code.label_used(intermediate_error_label):
6036 step_over_label = code.new_label()
6037 code.put_goto(step_over_label)
6038 code.put_label(intermediate_error_label)
6039 code.put_decref_clear(self.exit_var, py_object_type)
6040 code.put_goto(old_error_label)
6041 code.put_label(step_over_label)
6042
6043 code.funcstate.release_temp(self.exit_var)
6044 code.putln('}')
6045
6046 class WithTargetAssignmentStatNode(AssignmentNode):
6047 # The target assignment of the 'with' statement value (return
6048 # value of the __enter__() call).
6049 #
6050 # This is a special cased assignment that steals the RHS reference
6051 # and frees its temp.
6052 #
6053 # lhs ExprNode the assignment target
6054 # rhs CloneNode a (coerced) CloneNode for the orig_rhs (not owned by this node)
6055 # orig_rhs ExprNode the original ExprNode of the rhs. this node will clean up the
6056 # temps of the orig_rhs. basically, it takes ownership of the node
6057 # when the WithStatNode is done with it.
6058
6059 child_attrs = ["lhs"]
6060
6061 def analyse_declarations(self, env):
6062 self.lhs.analyse_target_declaration(env)
6063
6064 def analyse_expressions(self, env):
6065 self.rhs = self.rhs.analyse_types(env)
6066 self.lhs = self.lhs.analyse_target_types(env)
6067 self.lhs.gil_assignment_check(env)
6068 self.rhs = self.rhs.coerce_to(self.lhs.type, env)
6069 return self
6070
6071 def generate_execution_code(self, code):
6072 if self.orig_rhs.type.is_pyobject:
6073 # make sure rhs gets freed on errors, see below
6074 old_error_label = code.new_error_label()
6075 intermediate_error_label = code.error_label
6076
6077 self.rhs.generate_evaluation_code(code)
6078 self.lhs.generate_assignment_code(self.rhs, code)
6079
6080 if self.orig_rhs.type.is_pyobject:
6081 self.orig_rhs.generate_disposal_code(code)
6082 code.error_label = old_error_label
6083 if code.label_used(intermediate_error_label):
6084 step_over_label = code.new_label()
6085 code.put_goto(step_over_label)
6086 code.put_label(intermediate_error_label)
6087 self.orig_rhs.generate_disposal_code(code)
6088 code.put_goto(old_error_label)
6089 code.put_label(step_over_label)
6090
6091 self.orig_rhs.free_temps(code)
6092
6093 def annotate(self, code):
6094 self.lhs.annotate(code)
6095 self.rhs.annotate(code)
6096
6097
6098 class TryExceptStatNode(StatNode):
6099 # try .. except statement
6100 #
6101 # body StatNode
6102 # except_clauses [ExceptClauseNode]
6103 # else_clause StatNode or None
6104
6105 child_attrs = ["body", "except_clauses", "else_clause"]
6106
6107 def analyse_declarations(self, env):
6108 self.body.analyse_declarations(env)
6109 for except_clause in self.except_clauses:
6110 except_clause.analyse_declarations(env)
6111 if self.else_clause:
6112 self.else_clause.analyse_declarations(env)
6113
6114 def analyse_expressions(self, env):
6115 self.body = self.body.analyse_expressions(env)
6116 default_clause_seen = 0
6117 for i, except_clause in enumerate(self.except_clauses):
6118 except_clause = self.except_clauses[i] = except_clause.analyse_expressions(env)
6119 if default_clause_seen:
6120 error(except_clause.pos, "default 'except:' must be last")
6121 if not except_clause.pattern:
6122 default_clause_seen = 1
6123 self.has_default_clause = default_clause_seen
6124 if self.else_clause:
6125 self.else_clause = self.else_clause.analyse_expressions(env)
6126 return self
6127
6128 nogil_check = Node.gil_error
6129 gil_message = "Try-except statement"
6130
6131 def generate_execution_code(self, code):
6132 old_return_label = code.return_label
6133 old_break_label = code.break_label
6134 old_continue_label = code.continue_label
6135 old_error_label = code.new_error_label()
6136 our_error_label = code.error_label
6137 except_end_label = code.new_label('exception_handled')
6138 except_error_label = code.new_label('except_error')
6139 except_return_label = code.new_label('except_return')
6140 try_return_label = code.new_label('try_return')
6141 try_break_label = code.new_label('try_break')
6142 try_continue_label = code.new_label('try_continue')
6143 try_end_label = code.new_label('try_end')
6144
6145 exc_save_vars = [code.funcstate.allocate_temp(py_object_type, False)
6146 for _ in xrange(3)]
6147 code.putln("{")
6148 save_exc = code.insertion_point()
6149 code.putln(
6150 "/*try:*/ {")
6151 code.return_label = try_return_label
6152 code.break_label = try_break_label
6153 code.continue_label = try_continue_label
6154 self.body.generate_execution_code(code)
6155 code.putln(
6156 "}")
6157 temps_to_clean_up = code.funcstate.all_free_managed_temps()
6158 can_raise = code.label_used(our_error_label)
6159
6160 if can_raise:
6161 # inject code before the try block to save away the exception state
6162 code.globalstate.use_utility_code(reset_exception_utility_code)
6163 save_exc.putln("__Pyx_ExceptionSave(%s);" %
6164 ', '.join(['&%s' % var for var in exc_save_vars]))
6165 for var in exc_save_vars:
6166 save_exc.put_xgotref(var)
6167
6168 def restore_saved_exception():
6169 for name in exc_save_vars:
6170 code.put_xgiveref(name)
6171 code.putln("__Pyx_ExceptionReset(%s);" %
6172 ', '.join(exc_save_vars))
6173 else:
6174 # try block cannot raise exceptions, but we had to allocate the temps above,
6175 # so just keep the C compiler from complaining about them being unused
6176 save_exc.putln("if (%s); else {/*mark used*/};" % '||'.join(exc_save_vars))
6177
6178 def restore_saved_exception():
6179 pass
6180
6181 code.error_label = except_error_label
6182 code.return_label = except_return_label
6183 if self.else_clause:
6184 code.putln(
6185 "/*else:*/ {")
6186 self.else_clause.generate_execution_code(code)
6187 code.putln(
6188 "}")
6189
6190 if can_raise:
6191 for var in exc_save_vars:
6192 code.put_xdecref_clear(var, py_object_type)
6193 code.put_goto(try_end_label)
6194 code.put_label(our_error_label)
6195 for temp_name, temp_type in temps_to_clean_up:
6196 code.put_xdecref_clear(temp_name, temp_type)
6197 for except_clause in self.except_clauses:
6198 except_clause.generate_handling_code(code, except_end_label)
6199 if not self.has_default_clause:
6200 code.put_goto(except_error_label)
6201
6202 for exit_label, old_label in [(except_error_label, old_error_label),
6203 (try_break_label, old_break_label),
6204 (try_continue_label, old_continue_label),
6205 (try_return_label, old_return_label),
6206 (except_return_label, old_return_label)]:
6207 if code.label_used(exit_label):
6208 if not code.label_used(try_end_label):
6209 code.put_goto(try_end_label)
6210 code.put_label(exit_label)
6211 restore_saved_exception()
6212 code.put_goto(old_label)
6213
6214 if code.label_used(except_end_label):
6215 if not code.label_used(try_end_label):
6216 code.put_goto(try_end_label)
6217 code.put_label(except_end_label)
6218 restore_saved_exception()
6219 if code.label_used(try_end_label):
6220 code.put_label(try_end_label)
6221 code.putln("}")
6222
6223 for cname in exc_save_vars:
6224 code.funcstate.release_temp(cname)
6225
6226 code.return_label = old_return_label
6227 code.break_label = old_break_label
6228 code.continue_label = old_continue_label
6229 code.error_label = old_error_label
6230
6231 def generate_function_definitions(self, env, code):
6232 self.body.generate_function_definitions(env, code)
6233 for except_clause in self.except_clauses:
6234 except_clause.generate_function_definitions(env, code)
6235 if self.else_clause is not None:
6236 self.else_clause.generate_function_definitions(env, code)
6237
6238 def annotate(self, code):
6239 self.body.annotate(code)
6240 for except_node in self.except_clauses:
6241 except_node.annotate(code)
6242 if self.else_clause:
6243 self.else_clause.annotate(code)
6244
6245
6246 class ExceptClauseNode(Node):
6247 # Part of try ... except statement.
6248 #
6249 # pattern [ExprNode]
6250 # target ExprNode or None
6251 # body StatNode
6252 # excinfo_target TupleNode(3*ResultRefNode) or None optional target for exception info (not owned here!)
6253 # match_flag string result of exception match
6254 # exc_value ExcValueNode used internally
6255 # function_name string qualified name of enclosing function
6256 # exc_vars (string * 3) local exception variables
6257 # is_except_as bool Py3-style "except ... as xyz"
6258
6259 # excinfo_target is never set by the parser, but can be set by a transform
6260 # in order to extract more extensive information about the exception as a
6261 # sys.exc_info()-style tuple into a target variable
6262
6263 child_attrs = ["pattern", "target", "body", "exc_value"]
6264
6265 exc_value = None
6266 excinfo_target = None
6267 is_except_as = False
6268
6269 def analyse_declarations(self, env):
6270 if self.target:
6271 self.target.analyse_target_declaration(env)
6272 self.body.analyse_declarations(env)
6273
6274 def analyse_expressions(self, env):
6275 self.function_name = env.qualified_name
6276 if self.pattern:
6277 # normalise/unpack self.pattern into a list
6278 for i, pattern in enumerate(self.pattern):
6279 pattern = pattern.analyse_expressions(env)
6280 self.pattern[i] = pattern.coerce_to_pyobject(env)
6281
6282 if self.target:
6283 import ExprNodes
6284 self.exc_value = ExprNodes.ExcValueNode(self.pos)
6285 self.target = self.target.analyse_target_expression(env, self.exc_value)
6286
6287 self.body = self.body.analyse_expressions(env)
6288 return self
6289
6290 def generate_handling_code(self, code, end_label):
6291 code.mark_pos(self.pos)
6292 if self.pattern:
6293 exc_tests = []
6294 for pattern in self.pattern:
6295 pattern.generate_evaluation_code(code)
6296 exc_tests.append("PyErr_ExceptionMatches(%s)" % pattern.py_result())
6297
6298 match_flag = code.funcstate.allocate_temp(PyrexTypes.c_int_type, False)
6299 code.putln(
6300 "%s = %s;" % (match_flag, ' || '.join(exc_tests)))
6301 for pattern in self.pattern:
6302 pattern.generate_disposal_code(code)
6303 pattern.free_temps(code)
6304 code.putln(
6305 "if (%s) {" %
6306 match_flag)
6307 code.funcstate.release_temp(match_flag)
6308 else:
6309 code.putln("/*except:*/ {")
6310
6311 if (not getattr(self.body, 'stats', True)
6312 and self.excinfo_target is None
6313 and self.target is None):
6314 # most simple case: no exception variable, empty body (pass)
6315 # => reset the exception state, done
6316 code.putln("PyErr_Restore(0,0,0);")
6317 code.put_goto(end_label)
6318 code.putln("}")
6319 return
6320
6321 exc_vars = [code.funcstate.allocate_temp(py_object_type,
6322 manage_ref=True)
6323 for _ in xrange(3)]
6324 code.put_add_traceback(self.function_name)
6325 # We always have to fetch the exception value even if
6326 # there is no target, because this also normalises the
6327 # exception and stores it in the thread state.
6328 code.globalstate.use_utility_code(get_exception_utility_code)
6329 exc_args = "&%s, &%s, &%s" % tuple(exc_vars)
6330 code.putln("if (__Pyx_GetException(%s) < 0) %s" % (exc_args,
6331 code.error_goto(self.pos)))
6332 for x in exc_vars:
6333 code.put_gotref(x)
6334 if self.target:
6335 self.exc_value.set_var(exc_vars[1])
6336 self.exc_value.generate_evaluation_code(code)
6337 self.target.generate_assignment_code(self.exc_value, code)
6338 if self.excinfo_target is not None:
6339 for tempvar, node in zip(exc_vars, self.excinfo_target.args):
6340 node.set_var(tempvar)
6341
6342 old_break_label, old_continue_label = code.break_label, code.continue_label
6343 code.break_label = code.new_label('except_break')
6344 code.continue_label = code.new_label('except_continue')
6345
6346 old_exc_vars = code.funcstate.exc_vars
6347 code.funcstate.exc_vars = exc_vars
6348 self.body.generate_execution_code(code)
6349 code.funcstate.exc_vars = old_exc_vars
6350 for var in exc_vars:
6351 code.put_decref_clear(var, py_object_type)
6352 code.put_goto(end_label)
6353
6354 for new_label, old_label in [(code.break_label, old_break_label),
6355 (code.continue_label, old_continue_label)]:
6356 if code.label_used(new_label):
6357 code.put_label(new_label)
6358 for var in exc_vars:
6359 code.put_decref_clear(var, py_object_type)
6360 code.put_goto(old_label)
6361 code.break_label = old_break_label
6362 code.continue_label = old_continue_label
6363
6364 for temp in exc_vars:
6365 code.funcstate.release_temp(temp)
6366
6367 code.putln(
6368 "}")
6369
6370 def generate_function_definitions(self, env, code):
6371 if self.target is not None:
6372 self.target.generate_function_definitions(env, code)
6373 self.body.generate_function_definitions(env, code)
6374
6375 def annotate(self, code):
6376 if self.pattern:
6377 for pattern in self.pattern:
6378 pattern.annotate(code)
6379 if self.target:
6380 self.target.annotate(code)
6381 self.body.annotate(code)
6382
6383
6384 class TryFinallyStatNode(StatNode):
6385 # try ... finally statement
6386 #
6387 # body StatNode
6388 # finally_clause StatNode
6389 #
6390 # The plan is that we funnel all continue, break
6391 # return and error gotos into the beginning of the
6392 # finally block, setting a variable to remember which
6393 # one we're doing. At the end of the finally block, we
6394 # switch on the variable to figure out where to go.
6395 # In addition, if we're doing an error, we save the
6396 # exception on entry to the finally block and restore
6397 # it on exit.
6398
6399 child_attrs = ["body", "finally_clause"]
6400
6401 preserve_exception = 1
6402
6403 # handle exception case, in addition to return/break/continue
6404 handle_error_case = True
6405 func_return_type = None
6406
6407 disallow_continue_in_try_finally = 0
6408 # There doesn't seem to be any point in disallowing
6409 # continue in the try block, since we have no problem
6410 # handling it.
6411
6412 is_try_finally_in_nogil = False
6413
6414 def create_analysed(pos, env, body, finally_clause):
6415 node = TryFinallyStatNode(pos, body=body, finally_clause=finally_clause)
6416 return node
6417 create_analysed = staticmethod(create_analysed)
6418
6419 def analyse_declarations(self, env):
6420 self.body.analyse_declarations(env)
6421 self.finally_clause.analyse_declarations(env)
6422
6423 def analyse_expressions(self, env):
6424 self.body = self.body.analyse_expressions(env)
6425 self.finally_clause = self.finally_clause.analyse_expressions(env)
6426 if env.return_type and not env.return_type.is_void:
6427 self.func_return_type = env.return_type
6428 return self
6429
6430 nogil_check = Node.gil_error
6431 gil_message = "Try-finally statement"
6432
6433 def generate_execution_code(self, code):
6434 old_error_label = code.error_label
6435 old_labels = code.all_new_labels()
6436 new_labels = code.get_all_labels()
6437 new_error_label = code.error_label
6438 if not self.handle_error_case:
6439 code.error_label = old_error_label
6440 catch_label = code.new_label()
6441
6442 code.putln("/*try:*/ {")
6443
6444 if self.disallow_continue_in_try_finally:
6445 was_in_try_finally = code.funcstate.in_try_finally
6446 code.funcstate.in_try_finally = 1
6447
6448 self.body.generate_execution_code(code)
6449
6450 if self.disallow_continue_in_try_finally:
6451 code.funcstate.in_try_finally = was_in_try_finally
6452
6453 code.putln("}")
6454 code.set_all_labels(old_labels)
6455
6456 temps_to_clean_up = code.funcstate.all_free_managed_temps()
6457 code.mark_pos(self.finally_clause.pos)
6458 code.putln("/*finally:*/ {")
6459
6460 def fresh_finally_clause(_next=[self.finally_clause]):
6461 # generate the original subtree once and always keep a fresh copy
6462 node = _next[0]
6463 node_copy = copy.deepcopy(node)
6464 if node is self.finally_clause:
6465 _next[0] = node_copy
6466 else:
6467 node = node_copy
6468 return node
6469
6470 preserve_error = self.preserve_exception and code.label_used(new_error_label)
6471 needs_success_cleanup = not self.finally_clause.is_terminator
6472
6473 if not self.body.is_terminator:
6474 code.putln('/*normal exit:*/{')
6475 fresh_finally_clause().generate_execution_code(code)
6476 if not self.finally_clause.is_terminator:
6477 code.put_goto(catch_label)
6478 code.putln('}')
6479
6480 if preserve_error:
6481 code.putln('/*exception exit:*/{')
6482 if self.is_try_finally_in_nogil:
6483 code.declare_gilstate()
6484 if needs_success_cleanup:
6485 exc_lineno_cnames = tuple([
6486 code.funcstate.allocate_temp(PyrexTypes.c_int_type, manage_ref=False)
6487 for _ in range(2)])
6488 exc_filename_cname = code.funcstate.allocate_temp(
6489 PyrexTypes.CPtrType(PyrexTypes.c_const_type(PyrexTypes.c_char_type)),
6490 manage_ref=False)
6491 else:
6492 exc_lineno_cnames = exc_filename_cname = None
6493 exc_vars = tuple([
6494 code.funcstate.allocate_temp(py_object_type, manage_ref=False)
6495 for _ in range(6)])
6496 code.put_label(new_error_label)
6497 self.put_error_catcher(
6498 code, temps_to_clean_up, exc_vars, exc_lineno_cnames, exc_filename_cname)
6499 finally_old_labels = code.all_new_labels()
6500
6501 code.putln('{')
6502 old_exc_vars = code.funcstate.exc_vars
6503 code.funcstate.exc_vars = exc_vars[:3]
6504 fresh_finally_clause().generate_execution_code(code)
6505 code.funcstate.exc_vars = old_exc_vars
6506 code.putln('}')
6507
6508 if needs_success_cleanup:
6509 self.put_error_uncatcher(code, exc_vars, exc_lineno_cnames, exc_filename_cname)
6510 if exc_lineno_cnames:
6511 for cname in exc_lineno_cnames:
6512 code.funcstate.release_temp(cname)
6513 if exc_filename_cname:
6514 code.funcstate.release_temp(exc_filename_cname)
6515 code.put_goto(old_error_label)
6516
6517 for new_label, old_label in zip(code.get_all_labels(), finally_old_labels):
6518 if not code.label_used(new_label):
6519 continue
6520 code.put_label(new_label)
6521 self.put_error_cleaner(code, exc_vars)
6522 code.put_goto(old_label)
6523
6524 for cname in exc_vars:
6525 code.funcstate.release_temp(cname)
6526 code.putln('}')
6527
6528 code.set_all_labels(old_labels)
6529 return_label = code.return_label
6530 for i, (new_label, old_label) in enumerate(zip(new_labels, old_labels)):
6531 if not code.label_used(new_label):
6532 continue
6533 if new_label == new_error_label and preserve_error:
6534 continue # handled above
6535
6536 code.put('%s: ' % new_label)
6537 code.putln('{')
6538 ret_temp = None
6539 if old_label == return_label and not self.finally_clause.is_terminator:
6540 # store away return value for later reuse
6541 if (self.func_return_type and
6542 not self.is_try_finally_in_nogil and
6543 not isinstance(self.finally_clause, GILExitNode)):
6544 ret_temp = code.funcstate.allocate_temp(
6545 self.func_return_type, manage_ref=False)
6546 code.putln("%s = %s;" % (ret_temp, Naming.retval_cname))
6547 if self.func_return_type.is_pyobject:
6548 code.putln("%s = 0;" % Naming.retval_cname)
6549 fresh_finally_clause().generate_execution_code(code)
6550 if ret_temp:
6551 code.putln("%s = %s;" % (Naming.retval_cname, ret_temp))
6552 if self.func_return_type.is_pyobject:
6553 code.putln("%s = 0;" % ret_temp)
6554 code.funcstate.release_temp(ret_temp)
6555 ret_temp = None
6556 if not self.finally_clause.is_terminator:
6557 code.put_goto(old_label)
6558 code.putln('}')
6559
6560 # End finally
6561 code.put_label(catch_label)
6562 code.putln(
6563 "}")
6564
6565 def generate_function_definitions(self, env, code):
6566 self.body.generate_function_definitions(env, code)
6567 self.finally_clause.generate_function_definitions(env, code)
6568
6569 def put_error_catcher(self, code, temps_to_clean_up, exc_vars,
6570 exc_lineno_cnames, exc_filename_cname):
6571 code.globalstate.use_utility_code(restore_exception_utility_code)
6572 code.globalstate.use_utility_code(get_exception_utility_code)
6573 code.globalstate.use_utility_code(swap_exception_utility_code)
6574
6575 code.putln(' '.join(["%s = 0;"]*len(exc_vars)) % exc_vars)
6576 if self.is_try_finally_in_nogil:
6577 code.put_ensure_gil(declare_gilstate=False)
6578
6579 for temp_name, type in temps_to_clean_up:
6580 code.put_xdecref_clear(temp_name, type)
6581
6582 # not using preprocessor here to avoid warnings about
6583 # unused utility functions and/or temps
6584 code.putln("if (PY_MAJOR_VERSION >= 3)"
6585 " __Pyx_ExceptionSwap(&%s, &%s, &%s);" % exc_vars[3:])
6586 code.putln("if ((PY_MAJOR_VERSION < 3) ||"
6587 # if __Pyx_GetException() fails in Py3,
6588 # store the newly raised exception instead
6589 " unlikely(__Pyx_GetException(&%s, &%s, &%s) < 0)) "
6590 "__Pyx_ErrFetch(&%s, &%s, &%s);" % (exc_vars[:3] * 2))
6591 for var in exc_vars:
6592 code.put_xgotref(var)
6593 if exc_lineno_cnames:
6594 code.putln("%s = %s; %s = %s; %s = %s;" % (
6595 exc_lineno_cnames[0], Naming.lineno_cname,
6596 exc_lineno_cnames[1], Naming.clineno_cname,
6597 exc_filename_cname, Naming.filename_cname))
6598
6599 if self.is_try_finally_in_nogil:
6600 code.put_release_ensured_gil()
6601
6602 def put_error_uncatcher(self, code, exc_vars, exc_lineno_cnames, exc_filename_cname):
6603 code.globalstate.use_utility_code(restore_exception_utility_code)
6604 code.globalstate.use_utility_code(reset_exception_utility_code)
6605
6606 if self.is_try_finally_in_nogil:
6607 code.put_ensure_gil(declare_gilstate=False)
6608
6609 # not using preprocessor here to avoid warnings about
6610 # unused utility functions and/or temps
6611 code.putln("if (PY_MAJOR_VERSION >= 3) {")
6612 for var in exc_vars[3:]:
6613 code.put_xgiveref(var)
6614 code.putln("__Pyx_ExceptionReset(%s, %s, %s);" % exc_vars[3:])
6615 code.putln("}")
6616 for var in exc_vars[:3]:
6617 code.put_xgiveref(var)
6618 code.putln("__Pyx_ErrRestore(%s, %s, %s);" % exc_vars[:3])
6619
6620 if self.is_try_finally_in_nogil:
6621 code.put_release_ensured_gil()
6622
6623 code.putln(' '.join(["%s = 0;"]*len(exc_vars)) % exc_vars)
6624 if exc_lineno_cnames:
6625 code.putln("%s = %s; %s = %s; %s = %s;" % (
6626 Naming.lineno_cname, exc_lineno_cnames[0],
6627 Naming.clineno_cname, exc_lineno_cnames[1],
6628 Naming.filename_cname, exc_filename_cname))
6629
6630 def put_error_cleaner(self, code, exc_vars):
6631 code.globalstate.use_utility_code(reset_exception_utility_code)
6632 if self.is_try_finally_in_nogil:
6633 code.put_ensure_gil(declare_gilstate=False)
6634 # not using preprocessor here to avoid warnings about
6635 # unused utility functions and/or temps
6636 code.putln("if (PY_MAJOR_VERSION >= 3) {")
6637 for var in exc_vars[3:]:
6638 code.put_xgiveref(var)
6639 code.putln("__Pyx_ExceptionReset(%s, %s, %s);" % exc_vars[3:])
6640 code.putln("}")
6641 for var in exc_vars[:3]:
6642 code.put_xdecref_clear(var, py_object_type)
6643 if self.is_try_finally_in_nogil:
6644 code.put_release_ensured_gil()
6645 code.putln(' '.join(["%s = 0;"]*3) % exc_vars[3:])
6646
6647 def annotate(self, code):
6648 self.body.annotate(code)
6649 self.finally_clause.annotate(code)
6650
6651
6652 class NogilTryFinallyStatNode(TryFinallyStatNode):
6653 """
6654 A try/finally statement that may be used in nogil code sections.
6655 """
6656
6657 preserve_exception = False
6658 nogil_check = None
6659
6660
6661 class GILStatNode(NogilTryFinallyStatNode):
6662 # 'with gil' or 'with nogil' statement
6663 #
6664 # state string 'gil' or 'nogil'
6665
6666 state_temp = None
6667
6668 def __init__(self, pos, state, body):
6669 self.state = state
6670 self.create_state_temp_if_needed(pos, state, body)
6671 TryFinallyStatNode.__init__(self, pos,
6672 body=body,
6673 finally_clause=GILExitNode(
6674 pos, state=state, state_temp=self.state_temp))
6675
6676 def create_state_temp_if_needed(self, pos, state, body):
6677 from ParseTreeTransforms import YieldNodeCollector
6678 collector = YieldNodeCollector()
6679 collector.visitchildren(body)
6680 if not collector.yields:
6681 return
6682
6683 if state == 'gil':
6684 temp_type = PyrexTypes.c_gilstate_type
6685 else:
6686 temp_type = PyrexTypes.c_threadstate_ptr_type
6687 import ExprNodes
6688 self.state_temp = ExprNodes.TempNode(pos, temp_type)
6689
6690 def analyse_declarations(self, env):
6691 env._in_with_gil_block = (self.state == 'gil')
6692 if self.state == 'gil':
6693 env.has_with_gil_block = True
6694
6695 return super(GILStatNode, self).analyse_declarations(env)
6696
6697 def analyse_expressions(self, env):
6698 env.use_utility_code(
6699 UtilityCode.load_cached("ForceInitThreads", "ModuleSetupCode.c"))
6700 was_nogil = env.nogil
6701 env.nogil = self.state == 'nogil'
6702 node = TryFinallyStatNode.analyse_expressions(self, env)
6703 env.nogil = was_nogil
6704 return node
6705
6706 def generate_execution_code(self, code):
6707 code.mark_pos(self.pos)
6708 code.begin_block()
6709 if self.state_temp:
6710 self.state_temp.allocate(code)
6711 variable = self.state_temp.result()
6712 else:
6713 variable = None
6714
6715 old_trace_config = code.funcstate.can_trace
6716 if self.state == 'gil':
6717 code.put_ensure_gil(variable=variable)
6718 # FIXME: not that easy, tracing may not be possible at all here
6719 #code.funcstate.can_trace = True
6720 else:
6721 code.put_release_gil(variable=variable)
6722 code.funcstate.can_trace = False
6723
6724 TryFinallyStatNode.generate_execution_code(self, code)
6725
6726 if self.state_temp:
6727 self.state_temp.release(code)
6728
6729 code.funcstate.can_trace = old_trace_config
6730 code.end_block()
6731
6732
6733 class GILExitNode(StatNode):
6734 """
6735 Used as the 'finally' block in a GILStatNode
6736
6737 state string 'gil' or 'nogil'
6738 """
6739
6740 child_attrs = []
6741 state_temp = None
6742
6743 def analyse_expressions(self, env):
6744 return self
6745
6746 def generate_execution_code(self, code):
6747 if self.state_temp:
6748 variable = self.state_temp.result()
6749 else:
6750 variable = None
6751
6752 if self.state == 'gil':
6753 code.put_release_ensured_gil(variable)
6754 else:
6755 code.put_acquire_gil(variable)
6756
6757
6758 class EnsureGILNode(GILExitNode):
6759 """
6760 Ensure the GIL in nogil functions for cleanup before returning.
6761 """
6762
6763 def generate_execution_code(self, code):
6764 code.put_ensure_gil(declare_gilstate=False)
6765
6766 utility_code_for_cimports = {
6767 # utility code (or inlining c) in a pxd (or pyx) file.
6768 # TODO: Consider a generic user-level mechanism for importing
6769 'cpython.array' : ("ArrayAPI", "arrayarray.h"),
6770 'cpython.array.array' : ("ArrayAPI", "arrayarray.h"),
6771 }
6772
6773 class CImportStatNode(StatNode):
6774 # cimport statement
6775 #
6776 # module_name string Qualified name of module being imported
6777 # as_name string or None Name specified in "as" clause, if any
6778
6779 child_attrs = []
6780
6781 def analyse_declarations(self, env):
6782 if not env.is_module_scope:
6783 error(self.pos, "cimport only allowed at module level")
6784 return
6785 module_scope = env.find_module(self.module_name, self.pos)
6786 if "." in self.module_name:
6787 names = [EncodedString(name) for name in self.module_name.split(".")]
6788 top_name = names[0]
6789 top_module_scope = env.context.find_submodule(top_name)
6790 module_scope = top_module_scope
6791 for name in names[1:]:
6792 submodule_scope = module_scope.find_submodule(name)
6793 module_scope.declare_module(name, submodule_scope, self.pos)
6794 module_scope = submodule_scope
6795 if self.as_name:
6796 env.declare_module(self.as_name, module_scope, self.pos)
6797 else:
6798 env.add_imported_module(module_scope)
6799 env.declare_module(top_name, top_module_scope, self.pos)
6800 else:
6801 name = self.as_name or self.module_name
6802 env.declare_module(name, module_scope, self.pos)
6803 if self.module_name in utility_code_for_cimports:
6804 env.use_utility_code(UtilityCode.load_cached(
6805 *utility_code_for_cimports[self.module_name]))
6806
6807 def analyse_expressions(self, env):
6808 return self
6809
6810 def generate_execution_code(self, code):
6811 pass
6812
6813
6814 class FromCImportStatNode(StatNode):
6815 # from ... cimport statement
6816 #
6817 # module_name string Qualified name of module
6818 # imported_names [(pos, name, as_name, kind)] Names to be imported
6819
6820 child_attrs = []
6821
6822 def analyse_declarations(self, env):
6823 if not env.is_module_scope:
6824 error(self.pos, "cimport only allowed at module level")
6825 return
6826 module_scope = env.find_module(self.module_name, self.pos)
6827 env.add_imported_module(module_scope)
6828 for pos, name, as_name, kind in self.imported_names:
6829 if name == "*":
6830 for local_name, entry in module_scope.entries.items():
6831 env.add_imported_entry(local_name, entry, pos)
6832 else:
6833 entry = module_scope.lookup(name)
6834 if entry:
6835 if kind and not self.declaration_matches(entry, kind):
6836 entry.redeclared(pos)
6837 entry.used = 1
6838 else:
6839 if kind == 'struct' or kind == 'union':
6840 entry = module_scope.declare_struct_or_union(name,
6841 kind = kind, scope = None, typedef_flag = 0, pos = pos)
6842 elif kind == 'class':
6843 entry = module_scope.declare_c_class(name, pos = pos,
6844 module_name = self.module_name)
6845 else:
6846 submodule_scope = env.context.find_module(name, relative_to = module_scope, pos = self.pos)
6847 if submodule_scope.parent_module is module_scope:
6848 env.declare_module(as_name or name, submodule_scope, self.pos)
6849 else:
6850 error(pos, "Name '%s' not declared in module '%s'"
6851 % (name, self.module_name))
6852
6853 if entry:
6854 local_name = as_name or name
6855 env.add_imported_entry(local_name, entry, pos)
6856
6857 if self.module_name.startswith('cpython'): # enough for now
6858 if self.module_name in utility_code_for_cimports:
6859 env.use_utility_code(UtilityCode.load_cached(
6860 *utility_code_for_cimports[self.module_name]))
6861 for _, name, _, _ in self.imported_names:
6862 fqname = '%s.%s' % (self.module_name, name)
6863 if fqname in utility_code_for_cimports:
6864 env.use_utility_code(UtilityCode.load_cached(
6865 *utility_code_for_cimports[fqname]))
6866
6867 def declaration_matches(self, entry, kind):
6868 if not entry.is_type:
6869 return 0
6870 type = entry.type
6871 if kind == 'class':
6872 if not type.is_extension_type:
6873 return 0
6874 else:
6875 if not type.is_struct_or_union:
6876 return 0
6877 if kind != type.kind:
6878 return 0
6879 return 1
6880
6881 def analyse_expressions(self, env):
6882 return self
6883
6884 def generate_execution_code(self, code):
6885 pass
6886
6887
6888 class FromImportStatNode(StatNode):
6889 # from ... import statement
6890 #
6891 # module ImportNode
6892 # items [(string, NameNode)]
6893 # interned_items [(string, NameNode, ExprNode)]
6894 # item PyTempNode used internally
6895 # import_star boolean used internally
6896
6897 child_attrs = ["module"]
6898 import_star = 0
6899
6900 def analyse_declarations(self, env):
6901 for name, target in self.items:
6902 if name == "*":
6903 if not env.is_module_scope:
6904 error(self.pos, "import * only allowed at module level")
6905 return
6906 env.has_import_star = 1
6907 self.import_star = 1
6908 else:
6909 target.analyse_target_declaration(env)
6910
6911 def analyse_expressions(self, env):
6912 import ExprNodes
6913 self.module = self.module.analyse_expressions(env)
6914 self.item = ExprNodes.RawCNameExprNode(self.pos, py_object_type)
6915 self.interned_items = []
6916 for name, target in self.items:
6917 if name == '*':
6918 for _, entry in env.entries.items():
6919 if not entry.is_type and entry.type.is_extension_type:
6920 env.use_utility_code(UtilityCode.load_cached("ExtTypeTest", "ObjectHandling.c"))
6921 break
6922 else:
6923 entry = env.lookup(target.name)
6924 # check whether or not entry is already cimported
6925 if (entry.is_type and entry.type.name == name
6926 and hasattr(entry.type, 'module_name')):
6927 if entry.type.module_name == self.module.module_name.value:
6928 # cimported with absolute name
6929 continue
6930 try:
6931 # cimported with relative name
6932 module = env.find_module(self.module.module_name.value,
6933 pos=None)
6934 if entry.type.module_name == module.qualified_name:
6935 continue
6936 except AttributeError:
6937 pass
6938 target = target.analyse_target_expression(env, None) # FIXME?
6939 if target.type is py_object_type:
6940 coerced_item = None
6941 else:
6942 coerced_item = self.item.coerce_to(target.type, env)
6943 self.interned_items.append((name, target, coerced_item))
6944 return self
6945
6946 def generate_execution_code(self, code):
6947 self.module.generate_evaluation_code(code)
6948 if self.import_star:
6949 code.putln(
6950 'if (%s(%s) < 0) %s;' % (
6951 Naming.import_star,
6952 self.module.py_result(),
6953 code.error_goto(self.pos)))
6954 item_temp = code.funcstate.allocate_temp(py_object_type, manage_ref=True)
6955 self.item.set_cname(item_temp)
6956 if self.interned_items:
6957 code.globalstate.use_utility_code(
6958 UtilityCode.load_cached("ImportFrom", "ImportExport.c"))
6959 for name, target, coerced_item in self.interned_items:
6960 code.putln(
6961 '%s = __Pyx_ImportFrom(%s, %s); %s' % (
6962 item_temp,
6963 self.module.py_result(),
6964 code.intern_identifier(name),
6965 code.error_goto_if_null(item_temp, self.pos)))
6966 code.put_gotref(item_temp)
6967 if coerced_item is None:
6968 target.generate_assignment_code(self.item, code)
6969 else:
6970 coerced_item.allocate_temp_result(code)
6971 coerced_item.generate_result_code(code)
6972 target.generate_assignment_code(coerced_item, code)
6973 code.put_decref_clear(item_temp, py_object_type)
6974 code.funcstate.release_temp(item_temp)
6975 self.module.generate_disposal_code(code)
6976 self.module.free_temps(code)
6977
6978
6979 class ParallelNode(Node):
6980 """
6981 Base class for cython.parallel constructs.
6982 """
6983
6984 nogil_check = None
6985
6986
6987 class ParallelStatNode(StatNode, ParallelNode):
6988 """
6989 Base class for 'with cython.parallel.parallel():' and 'for i in prange():'.
6990
6991 assignments { Entry(var) : (var.pos, inplace_operator_or_None) }
6992 assignments to variables in this parallel section
6993
6994 parent parent ParallelStatNode or None
6995 is_parallel indicates whether this node is OpenMP parallel
6996 (true for #pragma omp parallel for and
6997 #pragma omp parallel)
6998
6999 is_parallel is true for:
7000
7001 #pragma omp parallel
7002 #pragma omp parallel for
7003
7004 sections, but NOT for
7005
7006 #pragma omp for
7007
7008 We need this to determine the sharing attributes.
7009
7010 privatization_insertion_point a code insertion point used to make temps
7011 private (esp. the "nsteps" temp)
7012
7013 args tuple the arguments passed to the parallel construct
7014 kwargs DictNode the keyword arguments passed to the parallel
7015 construct (replaced by its compile time value)
7016 """
7017
7018 child_attrs = ['body', 'num_threads']
7019
7020 body = None
7021
7022 is_prange = False
7023 is_nested_prange = False
7024
7025 error_label_used = False
7026
7027 num_threads = None
7028 chunksize = None
7029
7030 parallel_exc = (
7031 Naming.parallel_exc_type,
7032 Naming.parallel_exc_value,
7033 Naming.parallel_exc_tb,
7034 )
7035
7036 parallel_pos_info = (
7037 Naming.parallel_filename,
7038 Naming.parallel_lineno,
7039 Naming.parallel_clineno,
7040 )
7041
7042 pos_info = (
7043 Naming.filename_cname,
7044 Naming.lineno_cname,
7045 Naming.clineno_cname,
7046 )
7047
7048 critical_section_counter = 0
7049
7050 def __init__(self, pos, **kwargs):
7051 super(ParallelStatNode, self).__init__(pos, **kwargs)
7052
7053 # All assignments in this scope
7054 self.assignments = kwargs.get('assignments') or {}
7055
7056 # All seen closure cnames and their temporary cnames
7057 self.seen_closure_vars = set()
7058
7059 # Dict of variables that should be declared (first|last|)private or
7060 # reduction { Entry: (op, lastprivate) }.
7061 # If op is not None, it's a reduction.
7062 self.privates = {}
7063
7064 # [NameNode]
7065 self.assigned_nodes = []
7066
7067 def analyse_declarations(self, env):
7068 self.body.analyse_declarations(env)
7069
7070 self.num_threads = None
7071
7072 if self.kwargs:
7073 # Try to find num_threads and chunksize keyword arguments
7074 pairs = []
7075 for dictitem in self.kwargs.key_value_pairs:
7076 if dictitem.key.value == 'num_threads':
7077 self.num_threads = dictitem.value
7078 elif self.is_prange and dictitem.key.value == 'chunksize':
7079 self.chunksize = dictitem.value
7080 else:
7081 pairs.append(dictitem)
7082
7083 self.kwargs.key_value_pairs = pairs
7084
7085 try:
7086 self.kwargs = self.kwargs.compile_time_value(env)
7087 except Exception, e:
7088 error(self.kwargs.pos, "Only compile-time values may be "
7089 "supplied as keyword arguments")
7090 else:
7091 self.kwargs = {}
7092
7093 for kw, val in self.kwargs.iteritems():
7094 if kw not in self.valid_keyword_arguments:
7095 error(self.pos, "Invalid keyword argument: %s" % kw)
7096 else:
7097 setattr(self, kw, val)
7098
7099 def analyse_expressions(self, env):
7100 if self.num_threads:
7101 self.num_threads = self.num_threads.analyse_expressions(env)
7102
7103 if self.chunksize:
7104 self.chunksize = self.chunksize.analyse_expressions(env)
7105
7106 self.body = self.body.analyse_expressions(env)
7107 self.analyse_sharing_attributes(env)
7108
7109 if self.num_threads is not None:
7110 if (self.parent and self.parent.num_threads is not None and not
7111 self.parent.is_prange):
7112 error(self.pos,
7113 "num_threads already declared in outer section")
7114 elif self.parent and not self.parent.is_prange:
7115 error(self.pos,
7116 "num_threads must be declared in the parent parallel section")
7117 elif (self.num_threads.type.is_int and
7118 self.num_threads.is_literal and
7119 self.num_threads.compile_time_value(env) <= 0):
7120 error(self.pos,
7121 "argument to num_threads must be greater than 0")
7122
7123 if not self.num_threads.is_simple():
7124 self.num_threads = self.num_threads.coerce_to(
7125 PyrexTypes.c_int_type, env).coerce_to_temp(env)
7126 return self
7127
7128 def analyse_sharing_attributes(self, env):
7129 """
7130 Analyse the privates for this block and set them in self.privates.
7131 This should be called in a post-order fashion during the
7132 analyse_expressions phase
7133 """
7134 for entry, (pos, op) in self.assignments.iteritems():
7135
7136 if self.is_prange and not self.is_parallel:
7137 # closely nested prange in a with parallel block, disallow
7138 # assigning to privates in the with parallel block (we
7139 # consider it too implicit and magicky for users)
7140 if entry in self.parent.assignments:
7141 error(pos,
7142 "Cannot assign to private of outer parallel block")
7143 continue
7144
7145 if not self.is_prange and op:
7146 # Again possible, but considered to magicky
7147 error(pos, "Reductions not allowed for parallel blocks")
7148 continue
7149
7150 # By default all variables should have the same values as if
7151 # executed sequentially
7152 lastprivate = True
7153 self.propagate_var_privatization(entry, pos, op, lastprivate)
7154
7155 def propagate_var_privatization(self, entry, pos, op, lastprivate):
7156 """
7157 Propagate the sharing attributes of a variable. If the privatization is
7158 determined by a parent scope, done propagate further.
7159
7160 If we are a prange, we propagate our sharing attributes outwards to
7161 other pranges. If we are a prange in parallel block and the parallel
7162 block does not determine the variable private, we propagate to the
7163 parent of the parent. Recursion stops at parallel blocks, as they have
7164 no concept of lastprivate or reduction.
7165
7166 So the following cases propagate:
7167
7168 sum is a reduction for all loops:
7169
7170 for i in prange(n):
7171 for j in prange(n):
7172 for k in prange(n):
7173 sum += i * j * k
7174
7175 sum is a reduction for both loops, local_var is private to the
7176 parallel with block:
7177
7178 for i in prange(n):
7179 with parallel:
7180 local_var = ... # private to the parallel
7181 for j in prange(n):
7182 sum += i * j
7183
7184 Nested with parallel blocks are disallowed, because they wouldn't
7185 allow you to propagate lastprivates or reductions:
7186
7187 #pragma omp parallel for lastprivate(i)
7188 for i in prange(n):
7189
7190 sum = 0
7191
7192 #pragma omp parallel private(j, sum)
7193 with parallel:
7194
7195 #pragma omp parallel
7196 with parallel:
7197
7198 #pragma omp for lastprivate(j) reduction(+:sum)
7199 for j in prange(n):
7200 sum += i
7201
7202 # sum and j are well-defined here
7203
7204 # sum and j are undefined here
7205
7206 # sum and j are undefined here
7207 """
7208 self.privates[entry] = (op, lastprivate)
7209
7210 if entry.type.is_memoryviewslice:
7211 error(pos, "Memoryview slices can only be shared in parallel sections")
7212 return
7213
7214 if self.is_prange:
7215 if not self.is_parallel and entry not in self.parent.assignments:
7216 # Parent is a parallel with block
7217 parent = self.parent.parent
7218 else:
7219 parent = self.parent
7220
7221 # We don't need to propagate privates, only reductions and
7222 # lastprivates
7223 if parent and (op or lastprivate):
7224 parent.propagate_var_privatization(entry, pos, op, lastprivate)
7225
7226 def _allocate_closure_temp(self, code, entry):
7227 """
7228 Helper function that allocate a temporary for a closure variable that
7229 is assigned to.
7230 """
7231 if self.parent:
7232 return self.parent._allocate_closure_temp(code, entry)
7233
7234 if entry.cname in self.seen_closure_vars:
7235 return entry.cname
7236
7237 cname = code.funcstate.allocate_temp(entry.type, True)
7238
7239 # Add both the actual cname and the temp cname, as the actual cname
7240 # will be replaced with the temp cname on the entry
7241 self.seen_closure_vars.add(entry.cname)
7242 self.seen_closure_vars.add(cname)
7243
7244 self.modified_entries.append((entry, entry.cname))
7245 code.putln("%s = %s;" % (cname, entry.cname))
7246 entry.cname = cname
7247
7248 def initialize_privates_to_nan(self, code, exclude=None):
7249 first = True
7250
7251 for entry, (op, lastprivate) in self.privates.iteritems():
7252 if not op and (not exclude or entry != exclude):
7253 invalid_value = entry.type.invalid_value()
7254
7255 if invalid_value:
7256 if first:
7257 code.putln("/* Initialize private variables to "
7258 "invalid values */")
7259 first = False
7260 code.putln("%s = %s;" % (entry.cname,
7261 entry.type.cast_code(invalid_value)))
7262
7263 def evaluate_before_block(self, code, expr):
7264 c = self.begin_of_parallel_control_block_point_after_decls
7265 # we need to set the owner to ourselves temporarily, as
7266 # allocate_temp may generate a comment in the middle of our pragma
7267 # otherwise when DebugFlags.debug_temp_code_comments is in effect
7268 owner = c.funcstate.owner
7269 c.funcstate.owner = c
7270 expr.generate_evaluation_code(c)
7271 c.funcstate.owner = owner
7272
7273 return expr.result()
7274
7275 def put_num_threads(self, code):
7276 """
7277 Write self.num_threads if set as the num_threads OpenMP directive
7278 """
7279 if self.num_threads is not None:
7280 code.put(" num_threads(%s)" % self.evaluate_before_block(code,
7281 self.num_threads))
7282
7283
7284 def declare_closure_privates(self, code):
7285 """
7286 If a variable is in a scope object, we need to allocate a temp and
7287 assign the value from the temp to the variable in the scope object
7288 after the parallel section. This kind of copying should be done only
7289 in the outermost parallel section.
7290 """
7291 self.modified_entries = []
7292
7293 for entry in self.assignments:
7294 if entry.from_closure or entry.in_closure:
7295 self._allocate_closure_temp(code, entry)
7296
7297 def release_closure_privates(self, code):
7298 """
7299 Release any temps used for variables in scope objects. As this is the
7300 outermost parallel block, we don't need to delete the cnames from
7301 self.seen_closure_vars.
7302 """
7303 for entry, original_cname in self.modified_entries:
7304 code.putln("%s = %s;" % (original_cname, entry.cname))
7305 code.funcstate.release_temp(entry.cname)
7306 entry.cname = original_cname
7307
7308 def privatize_temps(self, code, exclude_temps=()):
7309 """
7310 Make any used temporaries private. Before the relevant code block
7311 code.start_collecting_temps() should have been called.
7312 """
7313 if self.is_parallel:
7314 c = self.privatization_insertion_point
7315
7316 self.temps = temps = code.funcstate.stop_collecting_temps()
7317 privates, firstprivates = [], []
7318 for temp, type in temps:
7319 if type.is_pyobject or type.is_memoryviewslice:
7320 firstprivates.append(temp)
7321 else:
7322 privates.append(temp)
7323
7324 if privates:
7325 c.put(" private(%s)" % ", ".join(privates))
7326 if firstprivates:
7327 c.put(" firstprivate(%s)" % ", ".join(firstprivates))
7328
7329 if self.breaking_label_used:
7330 shared_vars = [Naming.parallel_why]
7331 if self.error_label_used:
7332 shared_vars.extend(self.parallel_exc)
7333 c.put(" private(%s, %s, %s)" % self.pos_info)
7334
7335 c.put(" shared(%s)" % ', '.join(shared_vars))
7336
7337 def cleanup_temps(self, code):
7338 # Now clean up any memoryview slice and object temporaries
7339 if self.is_parallel and not self.is_nested_prange:
7340 code.putln("/* Clean up any temporaries */")
7341 for temp, type in self.temps:
7342 if type.is_memoryviewslice:
7343 code.put_xdecref_memoryviewslice(temp, have_gil=False)
7344 elif type.is_pyobject:
7345 code.put_xdecref(temp, type)
7346 code.putln("%s = NULL;" % temp)
7347
7348 def setup_parallel_control_flow_block(self, code):
7349 """
7350 Sets up a block that surrounds the parallel block to determine
7351 how the parallel section was exited. Any kind of return is
7352 trapped (break, continue, return, exceptions). This is the idea:
7353
7354 {
7355 int why = 0;
7356
7357 #pragma omp parallel
7358 {
7359 return # -> goto new_return_label;
7360 goto end_parallel;
7361
7362 new_return_label:
7363 why = 3;
7364 goto end_parallel;
7365
7366 end_parallel:;
7367 #pragma omp flush(why) # we need to flush for every iteration
7368 }
7369
7370 if (why == 3)
7371 goto old_return_label;
7372 }
7373 """
7374 self.old_loop_labels = code.new_loop_labels()
7375 self.old_error_label = code.new_error_label()
7376 self.old_return_label = code.return_label
7377 code.return_label = code.new_label(name="return")
7378
7379 code.begin_block() # parallel control flow block
7380 self.begin_of_parallel_control_block_point = code.insertion_point()
7381 self.begin_of_parallel_control_block_point_after_decls = code.insertion_point()
7382
7383 self.undef_builtin_expect_apple_gcc_bug(code)
7384
7385 def begin_parallel_block(self, code):
7386 """
7387 Each OpenMP thread in a parallel section that contains a with gil block
7388 must have the thread-state initialized. The call to
7389 PyGILState_Release() then deallocates our threadstate. If we wouldn't
7390 do this, each with gil block would allocate and deallocate one, thereby
7391 losing exception information before it can be saved before leaving the
7392 parallel section.
7393 """
7394 self.begin_of_parallel_block = code.insertion_point()
7395
7396 def end_parallel_block(self, code):
7397 """
7398 To ensure all OpenMP threads have thread states, we ensure the GIL
7399 in each thread (which creates a thread state if it doesn't exist),
7400 after which we release the GIL.
7401 On exit, reacquire the GIL and release the thread state.
7402
7403 If compiled without OpenMP support (at the C level), then we still have
7404 to acquire the GIL to decref any object temporaries.
7405 """
7406 if self.error_label_used:
7407 begin_code = self.begin_of_parallel_block
7408 end_code = code
7409
7410 begin_code.putln("#ifdef _OPENMP")
7411 begin_code.put_ensure_gil(declare_gilstate=True)
7412 begin_code.putln("Py_BEGIN_ALLOW_THREADS")
7413 begin_code.putln("#endif /* _OPENMP */")
7414
7415 end_code.putln("#ifdef _OPENMP")
7416 end_code.putln("Py_END_ALLOW_THREADS")
7417 end_code.putln("#else")
7418 end_code.put_safe("{\n")
7419 end_code.put_ensure_gil()
7420 end_code.putln("#endif /* _OPENMP */")
7421 self.cleanup_temps(end_code)
7422 end_code.put_release_ensured_gil()
7423 end_code.putln("#ifndef _OPENMP")
7424 end_code.put_safe("}\n")
7425 end_code.putln("#endif /* _OPENMP */")
7426
7427 def trap_parallel_exit(self, code, should_flush=False):
7428 """
7429 Trap any kind of return inside a parallel construct. 'should_flush'
7430 indicates whether the variable should be flushed, which is needed by
7431 prange to skip the loop. It also indicates whether we need to register
7432 a continue (we need this for parallel blocks, but not for prange
7433 loops, as it is a direct jump there).
7434
7435 It uses the same mechanism as try/finally:
7436 1 continue
7437 2 break
7438 3 return
7439 4 error
7440 """
7441 save_lastprivates_label = code.new_label()
7442 dont_return_label = code.new_label()
7443
7444 self.any_label_used = False
7445 self.breaking_label_used = False
7446 self.error_label_used = False
7447
7448 self.parallel_private_temps = []
7449
7450 all_labels = code.get_all_labels()
7451
7452 # Figure this out before starting to generate any code
7453 for label in all_labels:
7454 if code.label_used(label):
7455 self.breaking_label_used = (self.breaking_label_used or
7456 label != code.continue_label)
7457 self.any_label_used = True
7458
7459 if self.any_label_used:
7460 code.put_goto(dont_return_label)
7461
7462 for i, label in enumerate(all_labels):
7463 if not code.label_used(label):
7464 continue
7465
7466 is_continue_label = label == code.continue_label
7467
7468 code.put_label(label)
7469
7470 if not (should_flush and is_continue_label):
7471 if label == code.error_label:
7472 self.error_label_used = True
7473 self.fetch_parallel_exception(code)
7474
7475 code.putln("%s = %d;" % (Naming.parallel_why, i + 1))
7476
7477 if (self.breaking_label_used and self.is_prange and not
7478 is_continue_label):
7479 code.put_goto(save_lastprivates_label)
7480 else:
7481 code.put_goto(dont_return_label)
7482
7483 if self.any_label_used:
7484 if self.is_prange and self.breaking_label_used:
7485 # Don't rely on lastprivate, save our lastprivates
7486 code.put_label(save_lastprivates_label)
7487 self.save_parallel_vars(code)
7488
7489 code.put_label(dont_return_label)
7490
7491 if should_flush and self.breaking_label_used:
7492 code.putln_openmp("#pragma omp flush(%s)" % Naming.parallel_why)
7493
7494 def save_parallel_vars(self, code):
7495 """
7496 The following shenanigans are instated when we break, return or
7497 propagate errors from a prange. In this case we cannot rely on
7498 lastprivate() to do its job, as no iterations may have executed yet
7499 in the last thread, leaving the values undefined. It is most likely
7500 that the breaking thread has well-defined values of the lastprivate
7501 variables, so we keep those values.
7502 """
7503 section_name = ("__pyx_parallel_lastprivates%d" %
7504 self.critical_section_counter)
7505 code.putln_openmp("#pragma omp critical(%s)" % section_name)
7506 ParallelStatNode.critical_section_counter += 1
7507
7508 code.begin_block() # begin critical section
7509
7510 c = self.begin_of_parallel_control_block_point
7511
7512 temp_count = 0
7513 for entry, (op, lastprivate) in self.privates.iteritems():
7514 if not lastprivate or entry.type.is_pyobject:
7515 continue
7516
7517 type_decl = entry.type.declaration_code("")
7518 temp_cname = "__pyx_parallel_temp%d" % temp_count
7519 private_cname = entry.cname
7520
7521 temp_count += 1
7522
7523 invalid_value = entry.type.invalid_value()
7524 if invalid_value:
7525 init = ' = ' + invalid_value
7526 else:
7527 init = ''
7528 # Declare the parallel private in the outer block
7529 c.putln("%s %s%s;" % (type_decl, temp_cname, init))
7530
7531 # Initialize before escaping
7532 code.putln("%s = %s;" % (temp_cname, private_cname))
7533
7534 self.parallel_private_temps.append((temp_cname, private_cname))
7535
7536 code.end_block() # end critical section
7537
7538 def fetch_parallel_exception(self, code):
7539 """
7540 As each OpenMP thread may raise an exception, we need to fetch that
7541 exception from the threadstate and save it for after the parallel
7542 section where it can be re-raised in the master thread.
7543
7544 Although it would seem that __pyx_filename, __pyx_lineno and
7545 __pyx_clineno are only assigned to under exception conditions (i.e.,
7546 when we have the GIL), and thus should be allowed to be shared without
7547 any race condition, they are in fact subject to the same race
7548 conditions that they were previously when they were global variables
7549 and functions were allowed to release the GIL:
7550
7551 thread A thread B
7552 acquire
7553 set lineno
7554 release
7555 acquire
7556 set lineno
7557 release
7558 acquire
7559 fetch exception
7560 release
7561 skip the fetch
7562
7563 deallocate threadstate deallocate threadstate
7564 """
7565 code.begin_block()
7566 code.put_ensure_gil(declare_gilstate=True)
7567
7568 code.putln_openmp("#pragma omp flush(%s)" % Naming.parallel_exc_type)
7569 code.putln(
7570 "if (!%s) {" % Naming.parallel_exc_type)
7571
7572 code.putln("__Pyx_ErrFetch(&%s, &%s, &%s);" % self.parallel_exc)
7573 pos_info = chain(*zip(self.parallel_pos_info, self.pos_info))
7574 code.funcstate.uses_error_indicator = True
7575 code.putln("%s = %s; %s = %s; %s = %s;" % tuple(pos_info))
7576 code.put_gotref(Naming.parallel_exc_type)
7577
7578 code.putln(
7579 "}")
7580
7581 code.put_release_ensured_gil()
7582 code.end_block()
7583
7584 def restore_parallel_exception(self, code):
7585 "Re-raise a parallel exception"
7586 code.begin_block()
7587 code.put_ensure_gil(declare_gilstate=True)
7588
7589 code.put_giveref(Naming.parallel_exc_type)
7590 code.putln("__Pyx_ErrRestore(%s, %s, %s);" % self.parallel_exc)
7591 pos_info = chain(*zip(self.pos_info, self.parallel_pos_info))
7592 code.putln("%s = %s; %s = %s; %s = %s;" % tuple(pos_info))
7593
7594 code.put_release_ensured_gil()
7595 code.end_block()
7596
7597 def restore_labels(self, code):
7598 """
7599 Restore all old labels. Call this before the 'else' clause to for
7600 loops and always before ending the parallel control flow block.
7601 """
7602 code.set_all_labels(self.old_loop_labels + (self.old_return_label,
7603 self.old_error_label))
7604
7605 def end_parallel_control_flow_block(self, code,
7606 break_=False, continue_=False):
7607 """
7608 This ends the parallel control flow block and based on how the parallel
7609 section was exited, takes the corresponding action. The break_ and
7610 continue_ parameters indicate whether these should be propagated
7611 outwards:
7612
7613 for i in prange(...):
7614 with cython.parallel.parallel():
7615 continue
7616
7617 Here break should be trapped in the parallel block, and propagated to
7618 the for loop.
7619 """
7620 c = self.begin_of_parallel_control_block_point
7621
7622 # Firstly, always prefer errors over returning, continue or break
7623 if self.error_label_used:
7624 c.putln("const char *%s = NULL; int %s = 0, %s = 0;" %
7625 self.parallel_pos_info)
7626
7627 c.putln("PyObject *%s = NULL, *%s = NULL, *%s = NULL;" %
7628 self.parallel_exc)
7629
7630 code.putln(
7631 "if (%s) {" % Naming.parallel_exc_type)
7632 code.putln("/* This may have been overridden by a continue, "
7633 "break or return in another thread. Prefer the error. */")
7634 code.putln("%s = 4;" % Naming.parallel_why)
7635 code.putln(
7636 "}")
7637
7638 if continue_:
7639 any_label_used = self.any_label_used
7640 else:
7641 any_label_used = self.breaking_label_used
7642
7643 if any_label_used:
7644 # __pyx_parallel_why is used, declare and initialize
7645 c.putln("int %s;" % Naming.parallel_why)
7646 c.putln("%s = 0;" % Naming.parallel_why)
7647
7648 code.putln(
7649 "if (%s) {" % Naming.parallel_why)
7650
7651 for temp_cname, private_cname in self.parallel_private_temps:
7652 code.putln("%s = %s;" % (private_cname, temp_cname))
7653
7654 code.putln("switch (%s) {" % Naming.parallel_why)
7655 if continue_:
7656 code.put(" case 1: ")
7657 code.put_goto(code.continue_label)
7658
7659 if break_:
7660 code.put(" case 2: ")
7661 code.put_goto(code.break_label)
7662
7663 code.put(" case 3: ")
7664 code.put_goto(code.return_label)
7665
7666 if self.error_label_used:
7667 code.globalstate.use_utility_code(restore_exception_utility_code)
7668 code.putln(" case 4:")
7669 self.restore_parallel_exception(code)
7670 code.put_goto(code.error_label)
7671
7672 code.putln("}") # end switch
7673 code.putln(
7674 "}") # end if
7675
7676 code.end_block() # end parallel control flow block
7677 self.redef_builtin_expect_apple_gcc_bug(code)
7678
7679 # FIXME: improve with version number for OS X Lion
7680 buggy_platform_macro_condition = "(defined(__APPLE__) || defined(__OSX__))"
7681 have_expect_condition = "(defined(__GNUC__) && " \
7682 "(__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))))"
7683 redef_condition = "(%s && %s)" % (buggy_platform_macro_condition, have_expect_condition)
7684
7685 def undef_builtin_expect_apple_gcc_bug(self, code):
7686 """
7687 A bug on OS X Lion disallows __builtin_expect macros. This code avoids them
7688 """
7689 if not self.parent:
7690 code.undef_builtin_expect(self.redef_condition)
7691
7692 def redef_builtin_expect_apple_gcc_bug(self, code):
7693 if not self.parent:
7694 code.redef_builtin_expect(self.redef_condition)
7695
7696
7697 class ParallelWithBlockNode(ParallelStatNode):
7698 """
7699 This node represents a 'with cython.parallel.parallel():' block
7700 """
7701
7702 valid_keyword_arguments = ['num_threads']
7703
7704 num_threads = None
7705
7706 def analyse_declarations(self, env):
7707 super(ParallelWithBlockNode, self).analyse_declarations(env)
7708 if self.args:
7709 error(self.pos, "cython.parallel.parallel() does not take "
7710 "positional arguments")
7711
7712 def generate_execution_code(self, code):
7713 self.declare_closure_privates(code)
7714 self.setup_parallel_control_flow_block(code)
7715
7716 code.putln("#ifdef _OPENMP")
7717 code.put("#pragma omp parallel ")
7718
7719 if self.privates:
7720 privates = [e.cname for e in self.privates
7721 if not e.type.is_pyobject]
7722 code.put('private(%s)' % ', '.join(privates))
7723
7724 self.privatization_insertion_point = code.insertion_point()
7725 self.put_num_threads(code)
7726 code.putln("")
7727
7728 code.putln("#endif /* _OPENMP */")
7729
7730 code.begin_block() # parallel block
7731 self.begin_parallel_block(code)
7732 self.initialize_privates_to_nan(code)
7733 code.funcstate.start_collecting_temps()
7734 self.body.generate_execution_code(code)
7735 self.trap_parallel_exit(code)
7736 self.privatize_temps(code)
7737 self.end_parallel_block(code)
7738 code.end_block() # end parallel block
7739
7740 continue_ = code.label_used(code.continue_label)
7741 break_ = code.label_used(code.break_label)
7742
7743 self.restore_labels(code)
7744 self.end_parallel_control_flow_block(code, break_=break_,
7745 continue_=continue_)
7746 self.release_closure_privates(code)
7747
7748
7749 class ParallelRangeNode(ParallelStatNode):
7750 """
7751 This node represents a 'for i in cython.parallel.prange():' construct.
7752
7753 target NameNode the target iteration variable
7754 else_clause Node or None the else clause of this loop
7755 """
7756
7757 child_attrs = ['body', 'target', 'else_clause', 'args', 'num_threads',
7758 'chunksize']
7759
7760 body = target = else_clause = args = None
7761
7762 start = stop = step = None
7763
7764 is_prange = True
7765
7766 nogil = None
7767 schedule = None
7768
7769 valid_keyword_arguments = ['schedule', 'nogil', 'num_threads', 'chunksize']
7770
7771 def __init__(self, pos, **kwds):
7772 super(ParallelRangeNode, self).__init__(pos, **kwds)
7773 # Pretend to be a ForInStatNode for control flow analysis
7774 self.iterator = PassStatNode(pos)
7775
7776 def analyse_declarations(self, env):
7777 super(ParallelRangeNode, self).analyse_declarations(env)
7778 self.target.analyse_target_declaration(env)
7779 if self.else_clause is not None:
7780 self.else_clause.analyse_declarations(env)
7781
7782 if not self.args or len(self.args) > 3:
7783 error(self.pos, "Invalid number of positional arguments to prange")
7784 return
7785
7786 if len(self.args) == 1:
7787 self.stop, = self.args
7788 elif len(self.args) == 2:
7789 self.start, self.stop = self.args
7790 else:
7791 self.start, self.stop, self.step = self.args
7792
7793 if hasattr(self.schedule, 'decode'):
7794 self.schedule = self.schedule.decode('ascii')
7795
7796 if self.schedule not in (None, 'static', 'dynamic', 'guided',
7797 'runtime'):
7798 error(self.pos, "Invalid schedule argument to prange: %s" %
7799 (self.schedule,))
7800
7801 def analyse_expressions(self, env):
7802 was_nogil = env.nogil
7803 if self.nogil:
7804 env.nogil = True
7805
7806 if self.target is None:
7807 error(self.pos, "prange() can only be used as part of a for loop")
7808 return self
7809
7810 self.target = self.target.analyse_target_types(env)
7811
7812 if not self.target.type.is_numeric:
7813 # Not a valid type, assume one for now anyway
7814
7815 if not self.target.type.is_pyobject:
7816 # nogil_check will catch the is_pyobject case
7817 error(self.target.pos,
7818 "Must be of numeric type, not %s" % self.target.type)
7819
7820 self.index_type = PyrexTypes.c_py_ssize_t_type
7821 else:
7822 self.index_type = self.target.type
7823 if not self.index_type.signed:
7824 warning(self.target.pos,
7825 "Unsigned index type not allowed before OpenMP 3.0",
7826 level=2)
7827
7828 # Setup start, stop and step, allocating temps if needed
7829 self.names = 'start', 'stop', 'step'
7830 start_stop_step = self.start, self.stop, self.step
7831
7832 for node, name in zip(start_stop_step, self.names):
7833 if node is not None:
7834 node.analyse_types(env)
7835 if not node.type.is_numeric:
7836 error(node.pos, "%s argument must be numeric" % name)
7837 continue
7838
7839 if not node.is_literal:
7840 node = node.coerce_to_temp(env)
7841 setattr(self, name, node)
7842
7843 # As we range from 0 to nsteps, computing the index along the
7844 # way, we need a fitting type for 'i' and 'nsteps'
7845 self.index_type = PyrexTypes.widest_numeric_type(
7846 self.index_type, node.type)
7847
7848 if self.else_clause is not None:
7849 self.else_clause = self.else_clause.analyse_expressions(env)
7850
7851 # Although not actually an assignment in this scope, it should be
7852 # treated as such to ensure it is unpacked if a closure temp, and to
7853 # ensure lastprivate behaviour and propagation. If the target index is
7854 # not a NameNode, it won't have an entry, and an error was issued by
7855 # ParallelRangeTransform
7856 if hasattr(self.target, 'entry'):
7857 self.assignments[self.target.entry] = self.target.pos, None
7858
7859 node = super(ParallelRangeNode, self).analyse_expressions(env)
7860
7861 if node.chunksize:
7862 if not node.schedule:
7863 error(node.chunksize.pos,
7864 "Must provide schedule with chunksize")
7865 elif node.schedule == 'runtime':
7866 error(node.chunksize.pos,
7867 "Chunksize not valid for the schedule runtime")
7868 elif (node.chunksize.type.is_int and
7869 node.chunksize.is_literal and
7870 node.chunksize.compile_time_value(env) <= 0):
7871 error(node.chunksize.pos, "Chunksize must not be negative")
7872
7873 node.chunksize = node.chunksize.coerce_to(
7874 PyrexTypes.c_int_type, env).coerce_to_temp(env)
7875
7876 if node.nogil:
7877 env.nogil = was_nogil
7878
7879 node.is_nested_prange = node.parent and node.parent.is_prange
7880 if node.is_nested_prange:
7881 parent = node
7882 while parent.parent and parent.parent.is_prange:
7883 parent = parent.parent
7884
7885 parent.assignments.update(node.assignments)
7886 parent.privates.update(node.privates)
7887 parent.assigned_nodes.extend(node.assigned_nodes)
7888 return node
7889
7890 def nogil_check(self, env):
7891 names = 'start', 'stop', 'step', 'target'
7892 nodes = self.start, self.stop, self.step, self.target
7893 for name, node in zip(names, nodes):
7894 if node is not None and node.type.is_pyobject:
7895 error(node.pos, "%s may not be a Python object "
7896 "as we don't have the GIL" % name)
7897
7898 def generate_execution_code(self, code):
7899 """
7900 Generate code in the following steps
7901
7902 1) copy any closure variables determined thread-private
7903 into temporaries
7904
7905 2) allocate temps for start, stop and step
7906
7907 3) generate a loop that calculates the total number of steps,
7908 which then computes the target iteration variable for every step:
7909
7910 for i in prange(start, stop, step):
7911 ...
7912
7913 becomes
7914
7915 nsteps = (stop - start) / step;
7916 i = start;
7917
7918 #pragma omp parallel for lastprivate(i)
7919 for (temp = 0; temp < nsteps; temp++) {
7920 i = start + step * temp;
7921 ...
7922 }
7923
7924 Note that accumulation of 'i' would have a data dependency
7925 between iterations.
7926
7927 Also, you can't do this
7928
7929 for (i = start; i < stop; i += step)
7930 ...
7931
7932 as the '<' operator should become '>' for descending loops.
7933 'for i from x < i < y:' does not suffer from this problem
7934 as the relational operator is known at compile time!
7935
7936 4) release our temps and write back any private closure variables
7937 """
7938 self.declare_closure_privates(code)
7939
7940 # This can only be a NameNode
7941 target_index_cname = self.target.entry.cname
7942
7943 # This will be used as the dict to format our code strings, holding
7944 # the start, stop , step, temps and target cnames
7945 fmt_dict = {
7946 'target': target_index_cname,
7947 }
7948
7949 # Setup start, stop and step, allocating temps if needed
7950 start_stop_step = self.start, self.stop, self.step
7951 defaults = '0', '0', '1'
7952 for node, name, default in zip(start_stop_step, self.names, defaults):
7953 if node is None:
7954 result = default
7955 elif node.is_literal:
7956 result = node.get_constant_c_result_code()
7957 else:
7958 node.generate_evaluation_code(code)
7959 result = node.result()
7960
7961 fmt_dict[name] = result
7962
7963 fmt_dict['i'] = code.funcstate.allocate_temp(self.index_type, False)
7964 fmt_dict['nsteps'] = code.funcstate.allocate_temp(self.index_type, False)
7965
7966 # TODO: check if the step is 0 and if so, raise an exception in a
7967 # 'with gil' block. For now, just abort
7968 code.putln("if (%(step)s == 0) abort();" % fmt_dict)
7969
7970 self.setup_parallel_control_flow_block(code) # parallel control flow block
7971
7972 self.control_flow_var_code_point = code.insertion_point()
7973
7974 # Note: nsteps is private in an outer scope if present
7975 code.putln("%(nsteps)s = (%(stop)s - %(start)s) / %(step)s;" % fmt_dict)
7976
7977 # The target iteration variable might not be initialized, do it only if
7978 # we are executing at least 1 iteration, otherwise we should leave the
7979 # target unaffected. The target iteration variable is firstprivate to
7980 # shut up compiler warnings caused by lastprivate, as the compiler
7981 # erroneously believes that nsteps may be <= 0, leaving the private
7982 # target index uninitialized
7983 code.putln("if (%(nsteps)s > 0)" % fmt_dict)
7984 code.begin_block() # if block
7985 self.generate_loop(code, fmt_dict)
7986 code.end_block() # end if block
7987
7988 self.restore_labels(code)
7989
7990 if self.else_clause:
7991 if self.breaking_label_used:
7992 code.put("if (%s < 2)" % Naming.parallel_why)
7993
7994 code.begin_block() # else block
7995 code.putln("/* else */")
7996 self.else_clause.generate_execution_code(code)
7997 code.end_block() # end else block
7998
7999 # ------ cleanup ------
8000 self.end_parallel_control_flow_block(code) # end parallel control flow block
8001
8002 # And finally, release our privates and write back any closure
8003 # variables
8004 for temp in start_stop_step:
8005 if temp is not None:
8006 temp.generate_disposal_code(code)
8007 temp.free_temps(code)
8008
8009 code.funcstate.release_temp(fmt_dict['i'])
8010 code.funcstate.release_temp(fmt_dict['nsteps'])
8011
8012 self.release_closure_privates(code)
8013
8014 def generate_loop(self, code, fmt_dict):
8015 if self.is_nested_prange:
8016 code.putln("#if 0")
8017 else:
8018 code.putln("#ifdef _OPENMP")
8019
8020 if not self.is_parallel:
8021 code.put("#pragma omp for")
8022 self.privatization_insertion_point = code.insertion_point()
8023 reduction_codepoint = self.parent.privatization_insertion_point
8024 else:
8025 code.put("#pragma omp parallel")
8026 self.privatization_insertion_point = code.insertion_point()
8027 reduction_codepoint = self.privatization_insertion_point
8028 code.putln("")
8029 code.putln("#endif /* _OPENMP */")
8030
8031 code.begin_block() # pragma omp parallel begin block
8032
8033 # Initialize the GIL if needed for this thread
8034 self.begin_parallel_block(code)
8035
8036 if self.is_nested_prange:
8037 code.putln("#if 0")
8038 else:
8039 code.putln("#ifdef _OPENMP")
8040 code.put("#pragma omp for")
8041
8042 for entry, (op, lastprivate) in self.privates.iteritems():
8043 # Don't declare the index variable as a reduction
8044 if op and op in "+*-&^|" and entry != self.target.entry:
8045 if entry.type.is_pyobject:
8046 error(self.pos, "Python objects cannot be reductions")
8047 else:
8048 #code.put(" reduction(%s:%s)" % (op, entry.cname))
8049 # This is the only way reductions + nesting works in gcc4.5
8050 reduction_codepoint.put(
8051 " reduction(%s:%s)" % (op, entry.cname))
8052 else:
8053 if entry == self.target.entry:
8054 code.put(" firstprivate(%s)" % entry.cname)
8055 code.put(" lastprivate(%s)" % entry.cname)
8056 continue
8057
8058 if not entry.type.is_pyobject:
8059 if lastprivate:
8060 private = 'lastprivate'
8061 else:
8062 private = 'private'
8063
8064 code.put(" %s(%s)" % (private, entry.cname))
8065
8066 if self.schedule:
8067 if self.chunksize:
8068 chunksize = ", %s" % self.evaluate_before_block(code,
8069 self.chunksize)
8070 else:
8071 chunksize = ""
8072
8073 code.put(" schedule(%s%s)" % (self.schedule, chunksize))
8074
8075 self.put_num_threads(reduction_codepoint)
8076
8077 code.putln("")
8078 code.putln("#endif /* _OPENMP */")
8079
8080 code.put("for (%(i)s = 0; %(i)s < %(nsteps)s; %(i)s++)" % fmt_dict)
8081 code.begin_block() # for loop block
8082
8083 guard_around_body_codepoint = code.insertion_point()
8084
8085 # Start if guard block around the body. This may be unnecessary, but
8086 # at least it doesn't spoil indentation
8087 code.begin_block()
8088
8089 code.putln("%(target)s = %(start)s + %(step)s * %(i)s;" % fmt_dict)
8090 self.initialize_privates_to_nan(code, exclude=self.target.entry)
8091
8092 if self.is_parallel:
8093 code.funcstate.start_collecting_temps()
8094
8095 self.body.generate_execution_code(code)
8096 self.trap_parallel_exit(code, should_flush=True)
8097 self.privatize_temps(code)
8098
8099 if self.breaking_label_used:
8100 # Put a guard around the loop body in case return, break or
8101 # exceptions might be used
8102 guard_around_body_codepoint.putln("if (%s < 2)" % Naming.parallel_why)
8103
8104 code.end_block() # end guard around loop body
8105 code.end_block() # end for loop block
8106
8107 if self.is_parallel:
8108 # Release the GIL and deallocate the thread state
8109 self.end_parallel_block(code)
8110 code.end_block() # pragma omp parallel end block
8111
8112
8113 class CnameDecoratorNode(StatNode):
8114 """
8115 This node is for the cname decorator in CythonUtilityCode:
8116
8117 @cname('the_cname')
8118 cdef func(...):
8119 ...
8120
8121 In case of a cdef class the cname specifies the objstruct_cname.
8122
8123 node the node to which the cname decorator is applied
8124 cname the cname the node should get
8125 """
8126
8127 child_attrs = ['node']
8128
8129 def analyse_declarations(self, env):
8130 self.node.analyse_declarations(env)
8131
8132 node = self.node
8133 if isinstance(node, CompilerDirectivesNode):
8134 node = node.body.stats[0]
8135
8136 self.is_function = isinstance(node, FuncDefNode)
8137 is_struct_or_enum = isinstance(node, (CStructOrUnionDefNode,
8138 CEnumDefNode))
8139 e = node.entry
8140
8141 if self.is_function:
8142 e.cname = self.cname
8143 e.func_cname = self.cname
8144 e.used = True
8145 if e.pyfunc_cname and '.' in e.pyfunc_cname:
8146 e.pyfunc_cname = self.mangle(e.pyfunc_cname)
8147 elif is_struct_or_enum:
8148 e.cname = e.type.cname = self.cname
8149 else:
8150 scope = node.scope
8151
8152 e.cname = self.cname
8153 e.type.objstruct_cname = self.cname + '_obj'
8154 e.type.typeobj_cname = Naming.typeobj_prefix + self.cname
8155 e.type.typeptr_cname = self.cname + '_type'
8156 e.type.scope.namespace_cname = e.type.typeptr_cname
8157
8158 e.as_variable.cname = py_object_type.cast_code(e.type.typeptr_cname)
8159
8160 scope.scope_prefix = self.cname + "_"
8161
8162 for name, entry in scope.entries.iteritems():
8163 if entry.func_cname:
8164 entry.func_cname = self.mangle(entry.cname)
8165 if entry.pyfunc_cname:
8166 entry.pyfunc_cname = self.mangle(entry.pyfunc_cname)
8167
8168 def mangle(self, cname):
8169 if '.' in cname:
8170 # remove __pyx_base from func_cname
8171 cname = cname.split('.')[-1]
8172 return '%s_%s' % (self.cname, cname)
8173
8174 def analyse_expressions(self, env):
8175 self.node = self.node.analyse_expressions(env)
8176 return self
8177
8178 def generate_function_definitions(self, env, code):
8179 "Ensure a prototype for every @cname method in the right place"
8180 if self.is_function and env.is_c_class_scope:
8181 # method in cdef class, generate a prototype in the header
8182 h_code = code.globalstate['utility_code_proto']
8183
8184 if isinstance(self.node, DefNode):
8185 self.node.generate_function_header(
8186 h_code, with_pymethdef=False, proto_only=True)
8187 else:
8188 import ModuleNode
8189 entry = self.node.entry
8190 cname = entry.cname
8191 entry.cname = entry.func_cname
8192
8193 ModuleNode.generate_cfunction_declaration(
8194 entry,
8195 env.global_scope(),
8196 h_code,
8197 definition=True)
8198
8199 entry.cname = cname
8200
8201 self.node.generate_function_definitions(env, code)
8202
8203 def generate_execution_code(self, code):
8204 self.node.generate_execution_code(code)
8205
8206
8207 #------------------------------------------------------------------------------------
8208 #
8209 # Runtime support code
8210 #
8211 #------------------------------------------------------------------------------------
8212
8213 if Options.gcc_branch_hints:
8214 branch_prediction_macros = """
8215 /* Test for GCC > 2.95 */
8216 #if defined(__GNUC__) \
8217 && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))
8218 #define likely(x) __builtin_expect(!!(x), 1)
8219 #define unlikely(x) __builtin_expect(!!(x), 0)
8220 #else /* !__GNUC__ or GCC < 2.95 */
8221 #define likely(x) (x)
8222 #define unlikely(x) (x)
8223 #endif /* __GNUC__ */
8224 """
8225 else:
8226 branch_prediction_macros = """
8227 #define likely(x) (x)
8228 #define unlikely(x) (x)
8229 """
8230
8231 #------------------------------------------------------------------------------------
8232
8233 printing_utility_code = UtilityCode.load_cached("Print", "Printing.c")
8234 printing_one_utility_code = UtilityCode.load_cached("PrintOne", "Printing.c")
8235
8236 #------------------------------------------------------------------------------------
8237
8238 # Exception raising code
8239 #
8240 # Exceptions are raised by __Pyx_Raise() and stored as plain
8241 # type/value/tb in PyThreadState->curexc_*. When being caught by an
8242 # 'except' statement, curexc_* is moved over to exc_* by
8243 # __Pyx_GetException()
8244
8245 restore_exception_utility_code = UtilityCode.load_cached("PyErrFetchRestore", "Exceptions.c")
8246 raise_utility_code = UtilityCode.load_cached("RaiseException", "Exceptions.c")
8247 get_exception_utility_code = UtilityCode.load_cached("GetException", "Exceptions.c")
8248 swap_exception_utility_code = UtilityCode.load_cached("SwapException", "Exceptions.c")
8249 reset_exception_utility_code = UtilityCode.load_cached("SaveResetException", "Exceptions.c")
8250 traceback_utility_code = UtilityCode.load_cached("AddTraceback", "Exceptions.c")
8251
8252 #------------------------------------------------------------------------------------
8253
8254 get_exception_tuple_utility_code = UtilityCode(proto="""
8255 static PyObject *__Pyx_GetExceptionTuple(void); /*proto*/
8256 """,
8257 # I doubt that calling __Pyx_GetException() here is correct as it moves
8258 # the exception from tstate->curexc_* to tstate->exc_*, which prevents
8259 # exception handlers later on from receiving it.
8260 impl = """
8261 static PyObject *__Pyx_GetExceptionTuple(void) {
8262 PyObject *type = NULL, *value = NULL, *tb = NULL;
8263 if (__Pyx_GetException(&type, &value, &tb) == 0) {
8264 PyObject* exc_info = PyTuple_New(3);
8265 if (exc_info) {
8266 Py_INCREF(type);
8267 Py_INCREF(value);
8268 Py_INCREF(tb);
8269 PyTuple_SET_ITEM(exc_info, 0, type);
8270 PyTuple_SET_ITEM(exc_info, 1, value);
8271 PyTuple_SET_ITEM(exc_info, 2, tb);
8272 return exc_info;
8273 }
8274 }
8275 return NULL;
8276 }
8277 """,
8278 requires=[get_exception_utility_code])