3 # Pyrex - Parse tree nodes
8 cython.declare(sys=object, os=object, time=object, copy=object,
9 Builtin=object, error=object, warning=object, Naming=object, PyrexTypes=object,
10 py_object_type=object, ModuleScope=object, LocalScope=object, ClosureScope=object, \
11 StructOrUnionScope=object, PyClassScope=object, CClassScope=object,
12 CppClassScope=object, UtilityCode=object, EncodedString=object,
13 absolute_path_length=cython.Py_ssize_t)
15 import sys, os, time, copy
18 from Errors import error, warning, InternalError
22 from PyrexTypes import py_object_type, error_type, CFuncType
23 from Symtab import ModuleScope, LocalScope, ClosureScope, \
24 StructOrUnionScope, PyClassScope, CClassScope, CppClassScope
25 from Cython.Utils import open_new_file, replace_suffix
26 from Code import UtilityCode
27 from StringEncoding import EncodedString, escape_byte_string, split_string_literal
32 absolute_path_length = 0
34 def relative_position(pos):
36 We embed the relative filename in the generated C file, since we
37 don't want to have to regnerate and compile all the source code
38 whenever the Python install directory moves (which could happen,
39 e.g,. when distributing binaries.)
42 a position tuple -- (absolute filename, line number column position)
50 global absolute_path_length
51 if absolute_path_length==0:
52 absolute_path_length = len(os.path.abspath(os.getcwd()))
53 return (pos[0].get_filenametable_entry()[absolute_path_length+1:], pos[1])
55 def embed_position(pos, docstring):
56 if not Options.embed_pos_in_docstring:
58 pos_line = u'File: %s (starting at line %s)' % relative_position(pos)
61 return EncodedString(pos_line)
63 # make sure we can encode the filename in the docstring encoding
64 # otherwise make the docstring a unicode string
65 encoding = docstring.encoding
66 if encoding is not None:
68 encoded_bytes = pos_line.encode(encoding)
69 except UnicodeEncodeError:
73 # reuse the string encoding of the original docstring
74 doc = EncodedString(pos_line)
76 doc = EncodedString(pos_line + u'\n' + docstring)
77 doc.encoding = encoding
81 from Code import CCodeWriter
82 from types import FunctionType
84 def write_func_call(func):
86 if len(args) > 1 and isinstance(args[1], CCodeWriter):
87 # here we annotate the code with this function call
88 # but only if new code is generated
90 marker = ' /* %s -> %s.%s %s */' % (
91 ' ' * code.call_level,
92 node.__class__.__name__,
95 pristine = code.buffer.stream.tell()
97 start = code.buffer.stream.tell()
99 res = func(*args, **kwds)
101 if start == code.buffer.stream.tell():
102 code.buffer.stream.seek(pristine)
104 marker = marker.replace('->', '<-')
108 return func(*args, **kwds)
111 class VerboseCodeWriter(type):
112 # Set this as a metaclass to trace function calls in code.
113 # This slows down code generation and makes much larger files.
114 def __new__(cls, name, bases, attrs):
116 for mname, m in attrs.items():
117 if isinstance(m, FunctionType):
118 attrs[mname] = write_func_call(m)
119 return super(VerboseCodeWriter, cls).__new__(cls, name, bases, attrs)
123 # pos (string, int, int) Source file position
124 # is_name boolean Is a NameNode
125 # is_literal boolean Is a ConstNode
127 if DebugFlags.debug_trace_code_generation:
128 __metaclass__ = VerboseCodeWriter
134 # All descandants should set child_attrs to a list of the attributes
135 # containing nodes considered "children" in the tree. Each such attribute
136 # can either contain a single node or a list of nodes. See Visitor.py.
139 def __init__(self, pos, **kw):
141 self.__dict__.update(kw)
143 gil_message = "Operation"
147 def gil_error(self, env=None):
148 error(self.pos, "%s not allowed without gil" % self.gil_message)
150 cpp_message = "Operation"
152 def cpp_check(self, env):
157 error(self.pos, "%s only allowed in c++" % self.cpp_message)
159 def clone_node(self):
160 """Clone the node. This is defined as a shallow copy, except for member lists
161 amongst the child attributes (from get_child_accessors) which are also
162 copied. Lists containing child nodes are thus seen as a way for the node
163 to hold multiple children directly; the list is not treated as a seperate
164 level in the tree."""
165 result = copy.copy(self)
166 for attrname in result.child_attrs:
167 value = getattr(result, attrname)
168 if isinstance(value, list):
169 setattr(result, attrname, [x for x in value])
174 # There are 4 phases of parse tree processing, applied in order to
175 # all the statements in a given scope-block:
177 # (0) analyse_control_flow
178 # Create the control flow tree into which state can be asserted and
181 # (1) analyse_declarations
182 # Make symbol table entries for all declarations at the current
183 # level, both explicit (def, cdef, etc.) and implicit (assignment
184 # to an otherwise undeclared name).
186 # (2) analyse_expressions
187 # Determine the result types of expressions and fill in the
188 # 'type' attribute of each ExprNode. Insert coercion nodes into the
189 # tree where needed to convert to and from Python objects.
190 # Allocate temporary locals for intermediate results. Fill
191 # in the 'result_code' attribute of each ExprNode with a C code
195 # Emit C code for all declarations, statements and expressions.
196 # Recursively applies the 3 processing phases to the bodies of
200 def analyse_control_flow(self, env):
203 def analyse_declarations(self, env):
206 def analyse_expressions(self, env):
207 raise InternalError("analyse_expressions not implemented for %s" % \
208 self.__class__.__name__)
210 def generate_code(self, code):
211 raise InternalError("generate_code not implemented for %s" % \
212 self.__class__.__name__)
214 def annotate(self, code):
215 # mro does the wrong thing
216 if isinstance(self, BlockNode):
217 self.body.annotate(code)
222 except AttributeError:
224 if not self.child_attrs:
227 for attr in self.child_attrs:
228 child = getattr(self, attr)
229 # Sometimes lists, sometimes nodes
232 elif isinstance(child, list):
234 pos = max(pos, c.end_pos())
236 pos = max(pos, child.end_pos())
240 def dump(self, level=0, filter_out=("pos",), cutoff=100, encountered=None):
242 return "<...nesting level cutoff...>"
243 if encountered is None:
245 if id(self) in encountered:
246 return "<%s (0x%x) -- already output>" % (self.__class__.__name__, id(self))
247 encountered.add(id(self))
249 def dump_child(x, level):
250 if isinstance(x, Node):
251 return x.dump(level, filter_out, cutoff-1, encountered)
252 elif isinstance(x, list):
253 return "[%s]" % ", ".join([dump_child(item, level) for item in x])
258 attrs = [(key, value) for key, value in self.__dict__.items() if key not in filter_out]
260 return "<%s (0x%x)>" % (self.__class__.__name__, id(self))
263 res = "<%s (0x%x)\n" % (self.__class__.__name__, id(self))
264 for key, value in attrs:
265 res += "%s %s: %s\n" % (indent, key, dump_child(value, level + 1))
266 res += "%s>" % indent
269 class CompilerDirectivesNode(Node):
271 Sets compiler directives for the children nodes
273 # directives {string:value} A dictionary holding the right value for
274 # *all* possible directives.
276 child_attrs = ["body"]
278 def analyse_control_flow(self, env):
280 env.directives = self.directives
281 self.body.analyse_control_flow(env)
284 def analyse_declarations(self, env):
286 env.directives = self.directives
287 self.body.analyse_declarations(env)
290 def analyse_expressions(self, env):
292 env.directives = self.directives
293 self.body.analyse_expressions(env)
296 def generate_function_definitions(self, env, code):
297 env_old = env.directives
298 code_old = code.globalstate.directives
299 code.globalstate.directives = self.directives
300 self.body.generate_function_definitions(env, code)
301 env.directives = env_old
302 code.globalstate.directives = code_old
304 def generate_execution_code(self, code):
305 old = code.globalstate.directives
306 code.globalstate.directives = self.directives
307 self.body.generate_execution_code(code)
308 code.globalstate.directives = old
310 def annotate(self, code):
311 old = code.globalstate.directives
312 code.globalstate.directives = self.directives
313 self.body.annotate(code)
314 code.globalstate.directives = old
316 class BlockNode(object):
317 # Mixin class for nodes representing a declaration block.
319 def generate_cached_builtins_decls(self, env, code):
320 entries = env.global_scope().undeclared_cached_builtins
321 for entry in entries:
322 code.globalstate.add_cached_builtin_decl(entry)
326 class StatListNode(Node):
327 # stats a list of StatNode
329 child_attrs = ["stats"]
331 def create_analysed(pos, env, *args, **kw):
332 node = StatListNode(pos, *args, **kw)
333 return node # No node-specific analysis necesarry
334 create_analysed = staticmethod(create_analysed)
336 def analyse_control_flow(self, env):
337 for stat in self.stats:
338 stat.analyse_control_flow(env)
340 def analyse_declarations(self, env):
341 #print "StatListNode.analyse_declarations" ###
342 for stat in self.stats:
343 stat.analyse_declarations(env)
345 def analyse_expressions(self, env):
346 #print "StatListNode.analyse_expressions" ###
347 for stat in self.stats:
348 stat.analyse_expressions(env)
350 def generate_function_definitions(self, env, code):
351 #print "StatListNode.generate_function_definitions" ###
352 for stat in self.stats:
353 stat.generate_function_definitions(env, code)
355 def generate_execution_code(self, code):
356 #print "StatListNode.generate_execution_code" ###
357 for stat in self.stats:
358 code.mark_pos(stat.pos)
359 stat.generate_execution_code(code)
361 def annotate(self, code):
362 for stat in self.stats:
366 class StatNode(Node):
368 # Code generation for statements is split into the following subphases:
370 # (1) generate_function_definitions
371 # Emit C code for the definitions of any structs,
372 # unions, enums and functions defined in the current
375 # (2) generate_execution_code
376 # Emit C code for executable statements.
379 def generate_function_definitions(self, env, code):
382 def generate_execution_code(self, code):
383 raise InternalError("generate_execution_code not implemented for %s" % \
384 self.__class__.__name__)
387 class CDefExternNode(StatNode):
388 # include_file string or None
391 child_attrs = ["body"]
393 def analyse_declarations(self, env):
394 if self.include_file:
395 env.add_include_file(self.include_file)
396 old_cinclude_flag = env.in_cinclude
398 self.body.analyse_declarations(env)
399 env.in_cinclude = old_cinclude_flag
401 def analyse_expressions(self, env):
404 def generate_execution_code(self, code):
407 def annotate(self, code):
408 self.body.annotate(code)
411 class CDeclaratorNode(Node):
412 # Part of a C declaration.
414 # Processing during analyse_declarations phase:
417 # Returns (name, type) pair where name is the
418 # CNameDeclaratorNode of the name being declared
419 # and type is the type it is being declared as.
421 # calling_convention string Calling convention of CFuncDeclaratorNode
422 # for which this is a base
426 calling_convention = ""
429 class CNameDeclaratorNode(CDeclaratorNode):
430 # name string The Pyrex name being declared
431 # cname string or None C name, if specified
432 # default ExprNode or None the value assigned on declaration
434 child_attrs = ['default']
438 def analyse(self, base_type, env, nonempty = 0):
439 if nonempty and self.name == '':
440 # May have mistaken the name for the type.
441 if base_type.is_ptr or base_type.is_array or base_type.is_buffer:
442 error(self.pos, "Missing argument name")
443 elif base_type.is_void:
444 error(self.pos, "Use spam() rather than spam(void) to declare a function with no arguments.")
446 self.name = base_type.declaration_code("", for_display=1, pyrex=1)
447 base_type = py_object_type
448 self.type = base_type
449 return self, base_type
451 class CPtrDeclaratorNode(CDeclaratorNode):
452 # base CDeclaratorNode
454 child_attrs = ["base"]
456 def analyse(self, base_type, env, nonempty = 0):
457 if base_type.is_pyobject:
459 "Pointer base type cannot be a Python object")
460 ptr_type = PyrexTypes.c_ptr_type(base_type)
461 return self.base.analyse(ptr_type, env, nonempty = nonempty)
463 class CReferenceDeclaratorNode(CDeclaratorNode):
464 # base CDeclaratorNode
466 child_attrs = ["base"]
468 def analyse(self, base_type, env, nonempty = 0):
469 if base_type.is_pyobject:
471 "Reference base type cannot be a Python object")
472 ref_type = PyrexTypes.c_ref_type(base_type)
473 return self.base.analyse(ref_type, env, nonempty = nonempty)
475 class CArrayDeclaratorNode(CDeclaratorNode):
476 # base CDeclaratorNode
479 child_attrs = ["base", "dimension"]
481 def analyse(self, base_type, env, nonempty = 0):
482 if base_type.is_cpp_class:
483 from ExprNodes import TupleNode
484 if isinstance(self.dimension, TupleNode):
485 args = self.dimension.args
487 args = self.dimension,
488 values = [v.analyse_as_type(env) for v in args]
490 ix = values.index(None)
491 error(args[ix].pos, "Template parameter not a type.")
493 base_type = base_type.specialize_here(self.pos, values)
494 return self.base.analyse(base_type, env, nonempty = nonempty)
496 self.dimension.analyse_const_expression(env)
497 if not self.dimension.type.is_int:
498 error(self.dimension.pos, "Array dimension not integer")
499 size = self.dimension.get_constant_c_result_code()
508 if not base_type.is_complete():
510 "Array element type '%s' is incomplete" % base_type)
511 if base_type.is_pyobject:
513 "Array element cannot be a Python object")
514 if base_type.is_cfunction:
516 "Array element cannot be a function")
517 array_type = PyrexTypes.c_array_type(base_type, size)
518 return self.base.analyse(array_type, env, nonempty = nonempty)
521 class CFuncDeclaratorNode(CDeclaratorNode):
522 # base CDeclaratorNode
523 # args [CArgDeclNode]
524 # has_varargs boolean
525 # exception_value ConstNode
526 # exception_check boolean True if PyErr_Occurred check needed
527 # nogil boolean Can be called without gil
528 # with_gil boolean Acquire gil around function body
530 child_attrs = ["base", "args", "exception_value"]
533 optional_arg_count = 0
535 def analyse(self, return_type, env, nonempty = 0):
539 for i, arg_node in enumerate(self.args):
540 name_declarator, type = arg_node.analyse(env, nonempty = nonempty,
541 is_self_arg = (i == 0 and env.is_c_class_scope))
542 name = name_declarator.name
543 if name_declarator.cname:
545 "Function argument cannot have C name specification")
546 # Turn *[] argument into **
548 type = PyrexTypes.c_ptr_type(type.base_type)
549 # Catch attempted C-style func(void) decl
551 error(arg_node.pos, "Use spam() rather than spam(void) to declare a function with no arguments.")
552 func_type_args.append(
553 PyrexTypes.CFuncTypeArg(name, type, arg_node.pos))
555 self.optional_arg_count += 1
556 elif self.optional_arg_count:
557 error(self.pos, "Non-default argument follows default argument")
559 if self.optional_arg_count:
560 scope = StructOrUnionScope()
561 arg_count_member = '%sn' % Naming.pyrex_prefix
562 scope.declare_var(arg_count_member, PyrexTypes.c_int_type, self.pos)
563 for arg in func_type_args[len(func_type_args)-self.optional_arg_count:]:
564 scope.declare_var(arg.name, arg.type, arg.pos, allow_pyobject = 1)
565 struct_cname = env.mangle(Naming.opt_arg_prefix, self.base.name)
566 self.op_args_struct = env.global_scope().declare_struct_or_union(name = struct_cname,
571 cname = struct_cname)
572 self.op_args_struct.defined_in_pxd = 1
573 self.op_args_struct.used = 1
577 if self.exception_check == '+':
578 env.add_include_file('stdexcept')
579 if return_type.is_pyobject \
580 and (self.exception_value or self.exception_check) \
581 and self.exception_check != '+':
583 "Exception clause not allowed for function returning Python object")
585 if self.exception_value:
586 self.exception_value.analyse_const_expression(env)
587 if self.exception_check == '+':
588 self.exception_value.analyse_types(env)
589 exc_val_type = self.exception_value.type
590 if not exc_val_type.is_error and \
591 not exc_val_type.is_pyobject and \
592 not (exc_val_type.is_cfunction and not exc_val_type.return_type.is_pyobject and len(exc_val_type.args)==0):
593 error(self.exception_value.pos,
594 "Exception value must be a Python exception or cdef function with no arguments.")
595 exc_val = self.exception_value
597 self.exception_value = self.exception_value.coerce_to(return_type, env)
598 if self.exception_value.analyse_const_expression(env):
599 exc_val = self.exception_value.get_constant_c_result_code()
601 raise InternalError("get_constant_c_result_code not implemented for %s" %
602 self.exception_value.__class__.__name__)
603 if not return_type.assignable_from(self.exception_value.type):
604 error(self.exception_value.pos,
605 "Exception value incompatible with function return type")
606 exc_check = self.exception_check
607 if return_type.is_array:
609 "Function cannot return an array")
610 if return_type.is_cfunction:
612 "Function cannot return a function")
613 func_type = PyrexTypes.CFuncType(
614 return_type, func_type_args, self.has_varargs,
615 optional_arg_count = self.optional_arg_count,
616 exception_value = exc_val, exception_check = exc_check,
617 calling_convention = self.base.calling_convention,
618 nogil = self.nogil, with_gil = self.with_gil, is_overridable = self.overridable)
619 if self.optional_arg_count:
620 func_type.op_arg_struct = PyrexTypes.c_ptr_type(self.op_args_struct.type)
621 callspec = env.directives['callspec']
623 current = func_type.calling_convention
624 if current and current != callspec:
625 error(self.pos, "cannot have both '%s' and '%s' "
626 "calling conventions" % (current, callspec))
627 func_type.calling_convention = callspec
628 return self.base.analyse(func_type, env)
631 class CArgDeclNode(Node):
632 # Item in a function declaration argument list.
634 # base_type CBaseTypeNode
635 # declarator CDeclaratorNode
636 # not_none boolean Tagged with 'not None'
637 # or_none boolean Tagged with 'or None'
638 # accept_none boolean Resolved boolean for not_none/or_none
639 # default ExprNode or None
640 # default_value PyObjectConst constant for default value
641 # annotation ExprNode or None Py3 function arg annotation
642 # is_self_arg boolean Is the "self" arg of an extension type method
643 # is_type_arg boolean Is the "class" arg of an extension type classmethod
644 # is_kw_only boolean Is a keyword-only argument
646 child_attrs = ["base_type", "declarator", "default"]
652 name_declarator = None
656 def analyse(self, env, nonempty = 0, is_self_arg = False):
658 self.base_type.is_self_arg = self.is_self_arg = True
659 if self.type is None:
660 # The parser may missinterpret names as types...
662 if isinstance(self.declarator, CNameDeclaratorNode) and self.declarator.name == '':
664 self.declarator.name = self.base_type.name
665 self.base_type.name = None
666 self.base_type.is_basic_c_type = False
669 could_be_name = False
670 base_type = self.base_type.analyse(env, could_be_name = could_be_name)
671 if hasattr(self.base_type, 'arg_name') and self.base_type.arg_name:
672 self.declarator.name = self.base_type.arg_name
673 # The parser is unable to resolve the ambiguity of [] as part of the
674 # type (e.g. in buffers) or empty declarator (as with arrays).
675 # This is only arises for empty multi-dimensional arrays.
676 if (base_type.is_array
677 and isinstance(self.base_type, TemplatedTypeNode)
678 and isinstance(self.declarator, CArrayDeclaratorNode)):
679 declarator = self.declarator
680 while isinstance(declarator.base, CArrayDeclaratorNode):
681 declarator = declarator.base
682 declarator.base = self.base_type.array_declarator
683 base_type = base_type.base_type
684 return self.declarator.analyse(base_type, env, nonempty = nonempty)
686 return self.name_declarator, self.type
688 def calculate_default_value_code(self, code):
689 if self.default_value is None:
691 if self.default.is_literal:
692 # will not output any code, just assign the result_code
693 self.default.generate_evaluation_code(code)
694 return self.type.cast_code(self.default.result())
695 self.default_value = code.get_argument_default_const(self.type)
696 return self.default_value
698 def annotate(self, code):
700 self.default.annotate(code)
703 class CBaseTypeNode(Node):
704 # Abstract base class for C base type nodes.
706 # Processing during analyse_declarations phase:
713 def analyse_as_type(self, env):
714 return self.analyse(env)
716 class CAnalysedBaseTypeNode(Node):
721 def analyse(self, env, could_be_name = False):
724 class CSimpleBaseTypeNode(CBaseTypeNode):
726 # module_path [string] Qualifying name components
727 # is_basic_c_type boolean
731 # is_self_arg boolean Is self argument of C method
732 # ##is_type_arg boolean Is type argument of class method
735 arg_name = None # in case the argument name was interpreted as a type
737 def analyse(self, env, could_be_name = False):
738 # Return type descriptor.
739 #print "CSimpleBaseTypeNode.analyse: is_self_arg =", self.is_self_arg ###
741 if self.is_basic_c_type:
742 type = PyrexTypes.simple_c_type(self.signed, self.longness, self.name)
744 error(self.pos, "Unrecognised type modifier combination")
745 elif self.name == "object" and not self.module_path:
746 type = py_object_type
747 elif self.name is None:
748 if self.is_self_arg and env.is_c_class_scope:
749 #print "CSimpleBaseTypeNode.analyse: defaulting to parent type" ###
750 type = env.parent_type
751 ## elif self.is_type_arg and env.is_c_class_scope:
752 ## type = Builtin.type_type
754 type = py_object_type
757 scope = env.find_imported_module(self.module_path, self.pos)
761 if scope.is_c_class_scope:
762 scope = scope.global_scope()
763 entry = scope.lookup(self.name)
764 if entry and entry.is_type:
767 if self.is_self_arg and env.is_c_class_scope:
768 type = env.parent_type
769 ## elif self.is_type_arg and env.is_c_class_scope:
770 ## type = Builtin.type_type
772 type = py_object_type
773 self.arg_name = self.name
776 if not self.name in self.templates:
777 error(self.pos, "'%s' is not a type identifier" % self.name)
778 type = PyrexTypes.TemplatePlaceholderType(self.name)
780 error(self.pos, "'%s' is not a type identifier" % self.name)
782 if not type.is_numeric or type.is_complex:
783 error(self.pos, "can only complexify c numeric types")
784 type = PyrexTypes.CComplexType(type)
785 type.create_declaration_utility_code(env)
789 return PyrexTypes.error_type
791 class CNestedBaseTypeNode(CBaseTypeNode):
792 # For C++ classes that live inside other C++ classes.
795 # base_type CBaseTypeNode
797 child_attrs = ['base_type']
799 def analyse(self, env, could_be_name = None):
800 base_type = self.base_type.analyse(env)
801 if base_type is PyrexTypes.error_type:
802 return PyrexTypes.error_type
803 if not base_type.is_cpp_class:
804 error(self.pos, "'%s' is not a valid type scope" % base_type)
805 return PyrexTypes.error_type
806 type_entry = base_type.scope.lookup_here(self.name)
807 if not type_entry or not type_entry.is_type:
808 error(self.pos, "'%s.%s' is not a type identifier" % (base_type, self.name))
809 return PyrexTypes.error_type
810 return type_entry.type
812 class TemplatedTypeNode(CBaseTypeNode):
814 # positional_args [ExprNode] List of positional arguments
815 # keyword_args DictNode Keyword arguments
816 # base_type_node CBaseTypeNode
819 # type PyrexTypes.BufferType or PyrexTypes.CppClassType ...containing the right options
822 child_attrs = ["base_type_node", "positional_args",
823 "keyword_args", "dtype_node"]
829 def analyse(self, env, could_be_name = False, base_type = None):
830 if base_type is None:
831 base_type = self.base_type_node.analyse(env)
832 if base_type.is_error: return base_type
834 if base_type.is_cpp_class:
836 if self.keyword_args and self.keyword_args.key_value_pairs:
837 error(self.pos, "c++ templates cannot take keyword arguments");
838 self.type = PyrexTypes.error_type
841 for template_node in self.positional_args:
842 type = template_node.analyse_as_type(env)
844 error(template_node.pos, "unknown type in template argument")
846 template_types.append(type)
847 self.type = base_type.specialize_here(self.pos, template_types)
849 elif base_type.is_pyobject:
853 options = Buffer.analyse_buffer_options(
856 self.positional_args,
858 base_type.buffer_defaults)
860 if sys.version_info[0] < 3:
861 # Py 2.x enforces byte strings as keyword arguments ...
862 options = dict([ (name.encode('ASCII'), value)
863 for name, value in options.items() ])
865 self.type = PyrexTypes.BufferType(base_type, **options)
869 empty_declarator = CNameDeclaratorNode(self.pos, name="", cname=None)
870 if len(self.positional_args) > 1 or self.keyword_args.key_value_pairs:
871 error(self.pos, "invalid array declaration")
872 self.type = PyrexTypes.error_type
874 # It would be nice to merge this class with CArrayDeclaratorNode,
875 # but arrays are part of the declaration, not the type...
876 if not self.positional_args:
879 dimension = self.positional_args[0]
880 self.array_declarator = CArrayDeclaratorNode(self.pos,
881 base = empty_declarator,
882 dimension = dimension)
883 self.type = self.array_declarator.analyse(base_type, env)[1]
887 class CComplexBaseTypeNode(CBaseTypeNode):
888 # base_type CBaseTypeNode
889 # declarator CDeclaratorNode
891 child_attrs = ["base_type", "declarator"]
893 def analyse(self, env, could_be_name = False):
894 base = self.base_type.analyse(env, could_be_name)
895 _, type = self.declarator.analyse(base, env)
899 class CVarDefNode(StatNode):
900 # C variable definition or forward/extern function declaration.
902 # visibility 'private' or 'public' or 'extern'
903 # base_type CBaseTypeNode
904 # declarators [CDeclaratorNode]
908 # decorators [cython.locals(...)] or None
909 # directive_locals { string : NameNode } locals defined by cython.locals(...)
911 child_attrs = ["base_type", "declarators"]
914 directive_locals = {}
916 def analyse_declarations(self, env, dest_scope = None):
919 self.dest_scope = dest_scope
920 base_type = self.base_type.analyse(env)
922 # If the field is an external typedef, we cannot be sure about the type,
923 # so do conversion ourself rather than rely on the CPython mechanism (through
924 # a property; made in AnalyseDeclarationsTransform).
925 if (dest_scope.is_c_class_scope
926 and self.visibility in ('public', 'readonly')):
929 need_property = False
930 visibility = self.visibility
932 for declarator in self.declarators:
933 name_declarator, type = declarator.analyse(base_type, env)
934 if not type.is_complete():
935 if not (self.visibility == 'extern' and type.is_array):
936 error(declarator.pos,
937 "Variable type '%s' is incomplete" % type)
938 if self.visibility == 'extern' and type.is_pyobject:
939 error(declarator.pos,
940 "Python object cannot be declared extern")
941 name = name_declarator.name
942 cname = name_declarator.cname
944 error(declarator.pos, "Missing name in declaration.")
946 if type.is_cfunction:
947 entry = dest_scope.declare_cfunction(name, type, declarator.pos,
948 cname = cname, visibility = self.visibility, in_pxd = self.in_pxd,
950 if entry is not None:
951 entry.directive_locals = self.directive_locals
953 if self.directive_locals:
954 error(self.pos, "Decorators can only be followed by functions")
955 if self.in_pxd and self.visibility != 'extern':
957 "Only 'extern' C variable declaration allowed in .pxd file")
958 entry = dest_scope.declare_var(name, type, declarator.pos,
959 cname = cname, visibility = visibility, is_cdef = 1)
960 entry.needs_property = need_property
963 class CStructOrUnionDefNode(StatNode):
965 # cname string or None
966 # kind "struct" or "union"
967 # typedef_flag boolean
968 # visibility "public" or "private"
970 # attributes [CVarDefNode] or None
974 child_attrs = ["attributes"]
976 def analyse_declarations(self, env):
978 if self.visibility == 'extern' and self.packed:
979 error(self.pos, "Cannot declare extern struct as 'packed'")
980 if self.attributes is not None:
981 scope = StructOrUnionScope(self.name)
982 self.entry = env.declare_struct_or_union(
983 self.name, self.kind, scope, self.typedef_flag, self.pos,
984 self.cname, visibility = self.visibility, packed = self.packed)
985 if self.attributes is not None:
986 if self.in_pxd and not env.in_cinclude:
987 self.entry.defined_in_pxd = 1
988 for attr in self.attributes:
989 attr.analyse_declarations(env, scope)
990 if self.visibility != 'extern':
991 need_typedef_indirection = False
992 for attr in scope.var_entries:
995 type = type.base_type
996 if type == self.entry.type:
997 error(attr.pos, "Struct cannot contain itself as a member.")
998 if self.typedef_flag:
1000 type = type.base_type
1001 if type == self.entry.type:
1002 need_typedef_indirection = True
1003 if need_typedef_indirection:
1004 # C can't handle typedef structs that refer to themselves.
1005 struct_entry = self.entry
1006 self.entry = env.declare_typedef(
1007 self.name, struct_entry.type, self.pos,
1008 cname = self.cname, visibility='ignore')
1009 struct_entry.type.typedef_flag = False
1010 # FIXME: this might be considered a hack ;-)
1011 struct_entry.cname = struct_entry.type.cname = \
1012 '_' + self.entry.type.typedef_cname
1014 def analyse_expressions(self, env):
1017 def generate_execution_code(self, code):
1021 class CppClassNode(CStructOrUnionDefNode):
1024 # cname string or None
1025 # visibility "extern"
1027 # attributes [CVarDefNode] or None
1029 # base_classes [string]
1030 # templates [string] or None
1032 def analyse_declarations(self, env):
1034 if self.attributes is not None:
1035 scope = CppClassScope(self.name, env)
1036 base_class_types = []
1037 for base_class_name in self.base_classes:
1038 base_class_entry = env.lookup(base_class_name)
1039 if base_class_entry is None:
1040 error(self.pos, "'%s' not found" % base_class_name)
1041 elif not base_class_entry.is_type or not base_class_entry.type.is_cpp_class:
1042 error(self.pos, "'%s' is not a cpp class type" % base_class_name)
1044 base_class_types.append(base_class_entry.type)
1045 if self.templates is None:
1046 template_types = None
1048 template_types = [PyrexTypes.TemplatePlaceholderType(template_name) for template_name in self.templates]
1049 self.entry = env.declare_cpp_class(
1050 self.name, scope, self.pos,
1051 self.cname, base_class_types, visibility = self.visibility, templates = template_types)
1052 self.entry.is_cpp_class = 1
1053 if self.attributes is not None:
1054 if self.in_pxd and not env.in_cinclude:
1055 self.entry.defined_in_pxd = 1
1056 for attr in self.attributes:
1057 attr.analyse_declarations(scope)
1059 class CEnumDefNode(StatNode):
1060 # name string or None
1061 # cname string or None
1062 # items [CEnumDefItemNode]
1063 # typedef_flag boolean
1064 # visibility "public" or "private"
1068 child_attrs = ["items"]
1070 def analyse_declarations(self, env):
1071 self.entry = env.declare_enum(self.name, self.pos,
1072 cname = self.cname, typedef_flag = self.typedef_flag,
1073 visibility = self.visibility)
1074 if self.items is not None:
1075 if self.in_pxd and not env.in_cinclude:
1076 self.entry.defined_in_pxd = 1
1077 for item in self.items:
1078 item.analyse_declarations(env, self.entry)
1080 def analyse_expressions(self, env):
1083 def generate_execution_code(self, code):
1084 if self.visibility == 'public':
1085 temp = code.funcstate.allocate_temp(PyrexTypes.py_object_type, manage_ref=True)
1086 for item in self.entry.enum_values:
1087 code.putln("%s = PyInt_FromLong(%s); %s" % (
1090 code.error_goto_if_null(temp, item.pos)))
1091 code.put_gotref(temp)
1092 code.putln('if (__Pyx_SetAttrString(%s, "%s", %s) < 0) %s' % (
1093 Naming.module_cname,
1096 code.error_goto(item.pos)))
1097 code.put_decref_clear(temp, PyrexTypes.py_object_type)
1098 code.funcstate.release_temp(temp)
1101 class CEnumDefItemNode(StatNode):
1103 # cname string or None
1104 # value ExprNode or None
1106 child_attrs = ["value"]
1108 def analyse_declarations(self, env, enum_entry):
1110 self.value.analyse_const_expression(env)
1111 if not self.value.type.is_int:
1112 self.value = self.value.coerce_to(PyrexTypes.c_int_type, env)
1113 self.value.analyse_const_expression(env)
1114 entry = env.declare_const(self.name, enum_entry.type,
1115 self.value, self.pos, cname = self.cname,
1116 visibility = enum_entry.visibility)
1117 enum_entry.enum_values.append(entry)
1120 class CTypeDefNode(StatNode):
1121 # base_type CBaseTypeNode
1122 # declarator CDeclaratorNode
1123 # visibility "public" or "private"
1126 child_attrs = ["base_type", "declarator"]
1128 def analyse_declarations(self, env):
1129 base = self.base_type.analyse(env)
1130 name_declarator, type = self.declarator.analyse(base, env)
1131 name = name_declarator.name
1132 cname = name_declarator.cname
1133 entry = env.declare_typedef(name, type, self.pos,
1134 cname = cname, visibility = self.visibility)
1135 if self.in_pxd and not env.in_cinclude:
1136 entry.defined_in_pxd = 1
1138 def analyse_expressions(self, env):
1140 def generate_execution_code(self, code):
1144 class FuncDefNode(StatNode, BlockNode):
1145 # Base class for function definition nodes.
1147 # return_type PyrexType
1148 # #filename string C name of filename string const
1149 # entry Symtab.Entry
1150 # needs_closure boolean Whether or not this function has inner functions/classes/yield
1151 # needs_outer_scope boolean Whether or not this function requires outer scope
1152 # directive_locals { string : NameNode } locals defined by cython.locals(...)
1156 needs_closure = False
1157 needs_outer_scope = False
1160 def analyse_default_values(self, env):
1161 genv = env.global_scope()
1163 for arg in self.args:
1167 arg.default.analyse_types(env)
1168 arg.default = arg.default.coerce_to(arg.type, genv)
1171 "This argument cannot have a default value")
1176 error(arg.pos, "Non-default argument following default argument")
1178 def need_gil_acquisition(self, lenv):
1181 def create_local_scope(self, env):
1183 while genv.is_py_class_scope or genv.is_c_class_scope:
1184 genv = genv.outer_scope
1185 if self.needs_closure:
1186 lenv = ClosureScope(name=self.entry.name,
1188 scope_name=self.entry.cname)
1190 lenv = LocalScope(name=self.entry.name,
1193 lenv.return_type = self.return_type
1194 type = self.entry.type
1195 if type.is_cfunction:
1196 lenv.nogil = type.nogil and not type.with_gil
1197 self.local_scope = lenv
1198 lenv.directives = env.directives
1201 def generate_function_definitions(self, env, code):
1204 lenv = self.local_scope
1205 if lenv.is_closure_scope and not lenv.is_passthrough:
1206 outer_scope_cname = "%s->%s" % (Naming.cur_scope_cname,
1207 Naming.outer_scope_cname)
1209 outer_scope_cname = Naming.outer_scope_cname
1210 lenv.mangle_closure_cnames(outer_scope_cname)
1211 # Generate closure function definitions
1212 self.body.generate_function_definitions(lenv, code)
1213 # generate lambda function definitions
1214 for node in lenv.lambda_defs:
1215 node.generate_function_definitions(lenv, code)
1217 is_getbuffer_slot = (self.entry.name == "__getbuffer__" and
1218 self.entry.scope.is_c_class_scope)
1219 is_releasebuffer_slot = (self.entry.name == "__releasebuffer__" and
1220 self.entry.scope.is_c_class_scope)
1221 is_buffer_slot = is_getbuffer_slot or is_releasebuffer_slot
1223 if 'cython_unused' not in self.modifiers:
1224 self.modifiers = self.modifiers + ['cython_unused']
1226 preprocessor_guard = None
1227 if self.entry.is_special and not is_buffer_slot:
1228 slot = TypeSlots.method_name_to_slot.get(self.entry.name)
1230 preprocessor_guard = slot.preprocessor_guard_code()
1231 if (self.entry.name == '__long__' and
1232 not self.entry.scope.lookup_here('__int__')):
1233 preprocessor_guard = None
1235 profile = code.globalstate.directives['profile']
1238 error(self.pos, "Cannot profile nogil function.")
1239 code.globalstate.use_utility_code(profile_utility_code)
1241 # Generate C code for header and body of function
1242 code.enter_cfunc_scope()
1243 code.return_from_error_cleanup_label = code.new_label()
1245 # ----- Top-level constants used by this function
1246 code.mark_pos(self.pos)
1247 self.generate_cached_builtins_decls(lenv, code)
1248 # ----- Function header
1251 if preprocessor_guard:
1252 code.putln(preprocessor_guard)
1254 with_pymethdef = self.needs_assignment_synthesis(env, code)
1256 self.py_func.generate_function_header(code,
1257 with_pymethdef = with_pymethdef,
1259 self.generate_function_header(code,
1260 with_pymethdef = with_pymethdef)
1261 # ----- Local variable declarations
1262 # Find function scope
1264 while cenv.is_py_class_scope or cenv.is_c_class_scope:
1265 cenv = cenv.outer_scope
1266 if self.needs_closure:
1267 code.put(lenv.scope_class.type.declaration_code(Naming.cur_scope_cname))
1269 elif self.needs_outer_scope:
1270 if lenv.is_passthrough:
1271 code.put(lenv.scope_class.type.declaration_code(Naming.cur_scope_cname))
1273 code.put(cenv.scope_class.type.declaration_code(Naming.outer_scope_cname))
1275 self.generate_argument_declarations(lenv, code)
1276 for entry in lenv.var_entries:
1277 if not entry.in_closure:
1278 code.put_var_declaration(entry)
1280 if not self.return_type.is_void:
1281 if self.return_type.is_pyobject:
1285 (self.return_type.declaration_code(Naming.retval_cname),
1287 tempvardecl_code = code.insertion_point()
1288 self.generate_keyword_list(code)
1290 code.put_trace_declarations()
1291 # ----- Extern library function declarations
1292 lenv.generate_library_function_declarations(code)
1293 # ----- GIL acquisition
1294 acquire_gil = self.acquire_gil
1296 env.use_utility_code(force_init_threads_utility_code)
1297 code.putln("#ifdef WITH_THREAD")
1298 code.putln("PyGILState_STATE _save = PyGILState_Ensure();")
1299 code.putln("#endif")
1300 # ----- set up refnanny
1302 code.put_setup_refcount_context(self.entry.name)
1303 # ----- Automatic lead-ins for certain special functions
1304 if is_getbuffer_slot:
1305 self.getbuffer_init(code)
1306 # ----- Create closure scope object
1307 if self.needs_closure:
1308 code.putln("%s = (%s)%s->tp_new(%s, %s, NULL);" % (
1309 Naming.cur_scope_cname,
1310 lenv.scope_class.type.declaration_code(''),
1311 lenv.scope_class.type.typeptr_cname,
1312 lenv.scope_class.type.typeptr_cname,
1313 Naming.empty_tuple))
1314 code.putln("if (unlikely(!%s)) {" % Naming.cur_scope_cname)
1315 if is_getbuffer_slot:
1316 self.getbuffer_error_cleanup(code)
1318 code.put_finish_refcount_context()
1319 # FIXME: what if the error return value is a Python value?
1320 code.putln("return %s;" % self.error_value())
1322 code.put_gotref(Naming.cur_scope_cname)
1323 # Note that it is unsafe to decref the scope at this point.
1324 if self.needs_outer_scope:
1325 code.putln("%s = (%s)%s;" % (
1327 cenv.scope_class.type.declaration_code(''),
1329 if lenv.is_passthrough:
1330 code.putln("%s = %s;" % (Naming.cur_scope_cname, outer_scope_cname));
1331 elif self.needs_closure:
1332 # inner closures own a reference to their outer parent
1333 code.put_incref(outer_scope_cname, cenv.scope_class.type)
1334 code.put_giveref(outer_scope_cname)
1335 # ----- Trace function call
1337 # this looks a bit late, but if we don't get here due to a
1338 # fatal error before hand, it's not really worth tracing
1339 code.put_trace_call(self.entry.name, self.pos)
1340 # ----- Fetch arguments
1341 self.generate_argument_parsing_code(env, code)
1342 # If an argument is assigned to in the body, we must
1343 # incref it to properly keep track of refcounts.
1344 for entry in lenv.arg_entries:
1345 if entry.type.is_pyobject:
1346 if entry.assignments and not entry.in_closure:
1347 code.put_var_incref(entry)
1348 # ----- Initialise local variables
1349 for entry in lenv.var_entries:
1350 if entry.type.is_pyobject and entry.init_to_none and entry.used:
1351 code.put_init_var_to_py_none(entry)
1352 # ----- Initialise local buffer auxiliary variables
1353 for entry in lenv.var_entries + lenv.arg_entries:
1354 if entry.type.is_buffer and entry.buffer_aux.buffer_info_var.used:
1355 code.putln("%s.buf = NULL;" %
1356 entry.buffer_aux.buffer_info_var.cname)
1357 # ----- Check and convert arguments
1358 self.generate_argument_type_tests(code)
1359 # ----- Acquire buffer arguments
1360 for entry in lenv.arg_entries:
1361 if entry.type.is_buffer:
1362 Buffer.put_acquire_arg_buffer(entry, code, self.pos)
1364 # -------------------------
1365 # ----- Function body -----
1366 # -------------------------
1367 self.body.generate_execution_code(code)
1369 # ----- Default return value
1371 if self.return_type.is_pyobject:
1372 #if self.return_type.is_extension_type:
1373 # lhs = "(PyObject *)%s" % Naming.retval_cname
1375 lhs = Naming.retval_cname
1376 code.put_init_to_py_none(lhs, self.return_type)
1378 val = self.return_type.default_value
1380 code.putln("%s = %s;" % (Naming.retval_cname, val))
1381 # ----- Error cleanup
1382 if code.error_label in code.labels_used:
1383 code.put_goto(code.return_label)
1384 code.put_label(code.error_label)
1385 for cname, type in code.funcstate.all_managed_temps():
1386 code.put_xdecref(cname, type)
1388 # Clean up buffers -- this calls a Python function
1389 # so need to save and restore error state
1390 buffers_present = len(lenv.buffer_entries) > 0
1392 code.globalstate.use_utility_code(restore_exception_utility_code)
1393 code.putln("{ PyObject *__pyx_type, *__pyx_value, *__pyx_tb;")
1394 code.putln("__Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);")
1395 for entry in lenv.buffer_entries:
1396 Buffer.put_release_buffer_code(code, entry)
1397 #code.putln("%s = 0;" % entry.cname)
1398 code.putln("__Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}")
1400 err_val = self.error_value()
1401 exc_check = self.caller_will_check_exceptions()
1402 if err_val is not None or exc_check:
1403 # TODO: Fix exception tracing (though currently unused by cProfile).
1404 # code.globalstate.use_utility_code(get_exception_tuple_utility_code)
1405 # code.put_trace_exception()
1406 code.putln('__Pyx_AddTraceback("%s");' % self.entry.qualified_name)
1408 warning(self.entry.pos, "Unraisable exception in function '%s'." \
1409 % self.entry.qualified_name, 0)
1411 '__Pyx_WriteUnraisable("%s");' %
1412 self.entry.qualified_name)
1413 env.use_utility_code(unraisable_exception_utility_code)
1414 env.use_utility_code(restore_exception_utility_code)
1415 default_retval = self.return_type.default_value
1416 if err_val is None and default_retval:
1417 err_val = default_retval
1418 if err_val is not None:
1419 code.putln("%s = %s;" % (Naming.retval_cname, err_val))
1421 if is_getbuffer_slot:
1422 self.getbuffer_error_cleanup(code)
1424 # If we are using the non-error cleanup section we should
1425 # jump past it if we have an error. The if-test below determine
1426 # whether this section is used.
1427 if buffers_present or is_getbuffer_slot:
1428 code.put_goto(code.return_from_error_cleanup_label)
1431 # ----- Non-error return cleanup
1432 code.put_label(code.return_label)
1433 for entry in lenv.buffer_entries:
1435 Buffer.put_release_buffer_code(code, entry)
1436 if is_getbuffer_slot:
1437 self.getbuffer_normal_cleanup(code)
1438 # ----- Return cleanup for both error and no-error return
1439 code.put_label(code.return_from_error_cleanup_label)
1440 if not Options.init_local_none:
1441 for entry in lenv.var_entries:
1442 if lenv.control_flow.get_state((entry.name, 'initialized')) is not True:
1443 entry.xdecref_cleanup = 1
1445 for entry in lenv.var_entries:
1446 if entry.type.is_pyobject:
1447 if entry.used and not entry.in_closure:
1448 code.put_var_decref(entry)
1449 elif entry.in_closure and self.needs_closure:
1450 code.put_giveref(entry.cname)
1451 # Decref any increfed args
1452 for entry in lenv.arg_entries:
1453 if entry.type.is_pyobject:
1454 if entry.in_closure:
1455 code.put_var_giveref(entry)
1456 elif entry.assignments:
1457 code.put_var_decref(entry)
1458 if self.needs_closure:
1459 code.put_decref(Naming.cur_scope_cname, lenv.scope_class.type)
1462 # This code is duplicated in ModuleNode.generate_module_init_func
1464 default_retval = self.return_type.default_value
1465 err_val = self.error_value()
1466 if err_val is None and default_retval:
1467 err_val = default_retval
1468 if self.return_type.is_pyobject:
1469 code.put_xgiveref(self.return_type.as_pyobject(Naming.retval_cname))
1471 if self.entry.is_special and self.entry.name == "__hash__":
1472 # Returning -1 for __hash__ is supposed to signal an error
1473 # We do as Python instances and coerce -1 into -2.
1474 code.putln("if (unlikely(%s == -1) && !PyErr_Occurred()) %s = -2;" % (
1475 Naming.retval_cname, Naming.retval_cname))
1478 if self.return_type.is_pyobject:
1479 code.put_trace_return(Naming.retval_cname)
1481 code.put_trace_return("Py_None")
1483 code.put_finish_refcount_context()
1486 code.putln("#ifdef WITH_THREAD")
1487 code.putln("PyGILState_Release(_save);")
1488 code.putln("#endif")
1490 if not self.return_type.is_void:
1491 code.putln("return %s;" % Naming.retval_cname)
1495 if preprocessor_guard:
1496 code.putln("#endif /*!(%s)*/" % preprocessor_guard)
1498 # ----- Go back and insert temp variable declarations
1499 tempvardecl_code.put_temp_declarations(code.funcstate)
1500 # ----- Python version
1501 code.exit_cfunc_scope()
1503 self.py_func.generate_function_definitions(env, code)
1504 self.generate_wrapper_functions(code)
1506 def declare_argument(self, env, arg):
1507 if arg.type.is_void:
1508 error(arg.pos, "Invalid use of 'void'")
1509 elif not arg.type.is_complete() and not arg.type.is_array:
1511 "Argument type '%s' is incomplete" % arg.type)
1512 return env.declare_arg(arg.name, arg.type, arg.pos)
1514 def generate_arg_type_test(self, arg, code):
1515 # Generate type test for one argument.
1516 if arg.type.typeobj_is_available():
1517 code.globalstate.use_utility_code(arg_type_test_utility_code)
1518 typeptr_cname = arg.type.typeptr_cname
1519 arg_code = "((PyObject *)%s)" % arg.entry.cname
1521 'if (unlikely(!__Pyx_ArgTypeTest(%s, %s, %d, "%s", %s))) %s' % (
1526 arg.type.is_builtin_type,
1527 code.error_goto(arg.pos)))
1529 error(arg.pos, "Cannot test type of extern C class "
1530 "without type object name specification")
1532 def generate_arg_none_check(self, arg, code):
1533 # Generate None check for one argument.
1534 code.globalstate.use_utility_code(arg_type_test_utility_code)
1535 code.putln('if (unlikely(((PyObject *)%s) == Py_None)) {' % arg.entry.cname)
1536 code.putln('''PyErr_Format(PyExc_TypeError, "Argument '%s' must not be None"); %s''' % (
1538 code.error_goto(arg.pos)))
1541 def generate_wrapper_functions(self, code):
1544 def generate_execution_code(self, code):
1545 # Evaluate and store argument default values
1546 for arg in self.args:
1547 default = arg.default
1549 if not default.is_literal:
1550 default.generate_evaluation_code(code)
1551 default.make_owned_reference(code)
1552 result = default.result_as(arg.type)
1555 arg.calculate_default_value_code(code),
1557 if arg.type.is_pyobject:
1558 code.put_giveref(default.result())
1559 default.generate_post_assignment_code(code)
1560 default.free_temps(code)
1561 # For Python class methods, create and store function object
1563 self.assmt.generate_execution_code(code)
1566 # Special code for the __getbuffer__ function
1568 def getbuffer_init(self, code):
1569 info = self.local_scope.arg_entries[1].cname
1570 # Python 3.0 betas have a bug in memoryview which makes it call
1571 # getbuffer with a NULL parameter. For now we work around this;
1572 # the following line should be removed when this bug is fixed.
1573 code.putln("if (%s == NULL) return 0;" % info)
1574 code.putln("%s->obj = Py_None; __Pyx_INCREF(Py_None);" % info)
1575 code.put_giveref("%s->obj" % info) # Do not refnanny object within structs
1577 def getbuffer_error_cleanup(self, code):
1578 info = self.local_scope.arg_entries[1].cname
1579 code.put_gotref("%s->obj" % info)
1580 code.putln("__Pyx_DECREF(%s->obj); %s->obj = NULL;" %
1583 def getbuffer_normal_cleanup(self, code):
1584 info = self.local_scope.arg_entries[1].cname
1585 code.putln("if (%s->obj == Py_None) {" % info)
1586 code.put_gotref("Py_None")
1587 code.putln("__Pyx_DECREF(Py_None); %s->obj = NULL;" % info)
1590 class CFuncDefNode(FuncDefNode):
1591 # C function definition.
1593 # modifiers ['inline']
1594 # visibility 'private' or 'public' or 'extern'
1595 # base_type CBaseTypeNode
1596 # declarator CDeclaratorNode
1599 # decorators [DecoratorNode] list of decorators
1601 # with_gil boolean Acquire GIL around body
1603 # py_func wrapper for calling from Python
1604 # overridable whether or not this is a cpdef function
1605 # inline_in_pxd whether this is an inline function in a pxd file
1607 child_attrs = ["base_type", "declarator", "body", "py_func"]
1609 inline_in_pxd = False
1611 directive_locals = {}
1613 def unqualified_name(self):
1614 return self.entry.name
1616 def analyse_declarations(self, env):
1617 self.directive_locals.update(env.directives['locals'])
1618 base_type = self.base_type.analyse(env)
1619 # The 2 here is because we need both function and argument names.
1620 name_declarator, type = self.declarator.analyse(base_type, env, nonempty = 2 * (self.body is not None))
1621 if not type.is_cfunction:
1623 "Suite attached to non-function declaration")
1624 # Remember the actual type according to the function header
1625 # written here, because the type in the symbol table entry
1626 # may be different if we're overriding a C method inherited
1627 # from the base type of an extension type.
1629 type.is_overridable = self.overridable
1630 declarator = self.declarator
1631 while not hasattr(declarator, 'args'):
1632 declarator = declarator.base
1633 self.args = declarator.args
1634 for formal_arg, type_arg in zip(self.args, type.args):
1635 formal_arg.type = type_arg.type
1636 formal_arg.name = type_arg.name
1637 formal_arg.cname = type_arg.cname
1638 name = name_declarator.name
1639 cname = name_declarator.cname
1640 self.entry = env.declare_cfunction(
1641 name, type, self.pos,
1642 cname = cname, visibility = self.visibility,
1643 defining = self.body is not None,
1644 api = self.api, modifiers = self.modifiers)
1645 self.entry.inline_func_in_pxd = self.inline_in_pxd
1646 self.return_type = type.return_type
1648 if self.overridable and not env.is_module_scope:
1649 if len(self.args) < 1 or not self.args[0].type.is_pyobject:
1650 # An error will be produced in the cdef function
1651 self.overridable = False
1653 if self.overridable:
1655 py_func_body = self.call_self_node(is_module_scope = env.is_module_scope)
1656 self.py_func = DefNode(pos = self.pos,
1657 name = self.entry.name,
1660 starstar_arg = None,
1662 body = py_func_body,
1664 self.py_func.is_module_scope = env.is_module_scope
1665 self.py_func.analyse_declarations(env)
1666 self.entry.as_variable = self.py_func.entry
1667 # Reset scope entry the above cfunction
1668 env.entries[name] = self.entry
1669 if not env.is_module_scope or Options.lookup_module_cpdef:
1670 self.override = OverrideCheckNode(self.pos, py_func = self.py_func)
1671 self.body = StatListNode(self.pos, stats=[self.override, self.body])
1672 self.create_local_scope(env)
1674 def call_self_node(self, omit_optional_args=0, is_module_scope=0):
1676 args = self.type.args
1677 if omit_optional_args:
1678 args = args[:len(args) - self.type.optional_arg_count]
1679 arg_names = [arg.name for arg in args]
1681 cfunc = ExprNodes.NameNode(self.pos, name=self.entry.name)
1683 self_arg = ExprNodes.NameNode(self.pos, name=arg_names[0])
1684 cfunc = ExprNodes.AttributeNode(self.pos, obj=self_arg, attribute=self.entry.name)
1685 skip_dispatch = not is_module_scope or Options.lookup_module_cpdef
1686 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)
1687 return ReturnStatNode(pos=self.pos, return_type=PyrexTypes.py_object_type, value=c_call)
1689 def declare_arguments(self, env):
1690 for arg in self.type.args:
1692 error(arg.pos, "Missing argument name")
1693 self.declare_argument(env, arg)
1695 def need_gil_acquisition(self, lenv):
1696 return self.type.with_gil
1698 def nogil_check(self, env):
1700 with_gil = type.with_gil
1701 if type.nogil and not with_gil:
1702 if type.return_type.is_pyobject:
1704 "Function with Python return type cannot be declared nogil")
1705 for entry in self.local_scope.var_entries:
1706 if entry.type.is_pyobject:
1707 error(self.pos, "Function declared nogil has Python locals or temporaries")
1709 def analyse_expressions(self, env):
1710 self.local_scope.directives = env.directives
1711 if self.py_func is not None:
1712 # this will also analyse the default values
1713 self.py_func.analyse_expressions(env)
1715 self.analyse_default_values(env)
1716 self.acquire_gil = self.need_gil_acquisition(self.local_scope)
1718 def needs_assignment_synthesis(self, env, code=None):
1721 def generate_function_header(self, code, with_pymethdef, with_opt_args = 1, with_dispatch = 1, cname = None):
1724 visibility = self.entry.visibility
1725 for arg in type.args[:len(type.args)-type.optional_arg_count]:
1726 arg_decls.append(arg.declaration_code())
1727 if with_dispatch and self.overridable:
1728 arg_decls.append(PyrexTypes.c_int_type.declaration_code(Naming.skip_dispatch_cname))
1729 if type.optional_arg_count and with_opt_args:
1730 arg_decls.append(type.op_arg_struct.declaration_code(Naming.optional_args_cname))
1731 if type.has_varargs:
1732 arg_decls.append("...")
1734 arg_decls = ["void"]
1736 cname = self.entry.func_cname
1737 entity = type.function_header_code(cname, ', '.join(arg_decls))
1738 if visibility == 'public':
1739 dll_linkage = "DL_EXPORT"
1742 header = self.return_type.declaration_code(entity,
1743 dll_linkage = dll_linkage)
1744 if visibility == 'extern':
1745 storage_class = "%s " % Naming.extern_c_macro
1746 elif visibility == 'public':
1749 storage_class = "static "
1750 if 'inline' in self.modifiers:
1751 self.modifiers[self.modifiers.index('inline')] = 'cython_inline'
1752 code.putln("%s%s %s {" % (
1754 ' '.join(self.modifiers).upper(), # macro forms
1757 def generate_argument_declarations(self, env, code):
1758 for arg in self.args:
1760 result = arg.calculate_default_value_code(code)
1761 code.putln('%s = %s;' % (
1762 arg.type.declaration_code(arg.cname), result))
1764 def generate_keyword_list(self, code):
1767 def generate_argument_parsing_code(self, env, code):
1769 if self.type.optional_arg_count:
1770 code.putln('if (%s) {' % Naming.optional_args_cname)
1771 for arg in self.args:
1773 code.putln('if (%s->%sn > %s) {' % (Naming.optional_args_cname, Naming.pyrex_prefix, i))
1774 declarator = arg.declarator
1775 while not hasattr(declarator, 'name'):
1776 declarator = declarator.base
1777 code.putln('%s = %s->%s;' % (arg.cname, Naming.optional_args_cname, self.type.opt_arg_cname(declarator.name)))
1779 for _ in range(self.type.optional_arg_count):
1783 def generate_argument_conversion_code(self, code):
1786 def generate_argument_type_tests(self, code):
1787 # Generate type tests for args whose type in a parent
1788 # class is a supertype of the declared type.
1789 for arg in self.type.args:
1790 if arg.needs_type_test:
1791 self.generate_arg_type_test(arg, code)
1792 elif arg.type.is_pyobject and not arg.accept_none:
1793 self.generate_arg_none_check(arg, code)
1795 def error_value(self):
1796 if self.return_type.is_pyobject:
1800 return self.entry.type.exception_value
1802 def caller_will_check_exceptions(self):
1803 return self.entry.type.exception_check
1805 def generate_wrapper_functions(self, code):
1806 # If the C signature of a function has changed, we need to generate
1807 # wrappers to put in the slots here.
1810 func_type = entry.type
1811 while entry.prev_entry is not None:
1813 entry = entry.prev_entry
1814 entry.func_cname = "%s%swrap_%s" % (self.entry.func_cname, Naming.pyrex_prefix, k)
1816 self.generate_function_header(code,
1818 with_dispatch = entry.type.is_overridable,
1819 with_opt_args = entry.type.optional_arg_count,
1820 cname = entry.func_cname)
1821 if not self.return_type.is_void:
1823 args = self.type.args
1824 arglist = [arg.cname for arg in args[:len(args)-self.type.optional_arg_count]]
1825 if entry.type.is_overridable:
1826 arglist.append(Naming.skip_dispatch_cname)
1827 elif func_type.is_overridable:
1829 if entry.type.optional_arg_count:
1830 arglist.append(Naming.optional_args_cname)
1831 elif func_type.optional_arg_count:
1832 arglist.append('NULL')
1833 code.putln('%s(%s);' % (self.entry.func_cname, ', '.join(arglist)))
1837 class PyArgDeclNode(Node):
1838 # Argument which must be a Python object (used
1839 # for * and ** arguments).
1842 # entry Symtab.Entry
1843 # annotation ExprNode or None Py3 argument annotation
1846 def generate_function_definitions(self, env, code):
1847 self.entry.generate_function_definitions(env, code)
1849 class DecoratorNode(Node):
1852 # decorator NameNode or CallNode or AttributeNode
1853 child_attrs = ['decorator']
1856 class DefNode(FuncDefNode):
1857 # A Python function definition.
1859 # name string the Python name of the function
1860 # lambda_name string the internal name of a lambda 'function'
1861 # decorators [DecoratorNode] list of decorators
1862 # args [CArgDeclNode] formal arguments
1863 # star_arg PyArgDeclNode or None * argument
1864 # starstar_arg PyArgDeclNode or None ** argument
1865 # doc EncodedString or None
1867 # return_type_annotation
1868 # ExprNode or None the Py3 return type annotation
1870 # The following subnode is constructed internally
1871 # when the def statement is inside a Python class definition.
1873 # assmt AssignmentNode Function construction/assignment
1875 child_attrs = ["args", "star_arg", "starstar_arg", "body", "decorators"]
1880 num_required_kw_args = 0
1881 reqd_kw_flags_cname = "0"
1884 return_type_annotation = None
1889 def __init__(self, pos, **kwds):
1890 FuncDefNode.__init__(self, pos, **kwds)
1892 for arg in self.args:
1899 self.num_kwonly_args = k
1900 self.num_required_kw_args = rk
1901 self.num_required_args = r
1903 def as_cfunction(self, cfunc=None, scope=None):
1905 error(self.star_arg.pos, "cdef function cannot have star argument")
1906 if self.starstar_arg:
1907 error(self.starstar_arg.pos, "cdef function cannot have starstar argument")
1910 for formal_arg in self.args:
1911 name_declarator, type = formal_arg.analyse(scope, nonempty=1)
1912 cfunc_args.append(PyrexTypes.CFuncTypeArg(name = name_declarator.name,
1914 type = py_object_type,
1915 pos = formal_arg.pos))
1916 cfunc_type = PyrexTypes.CFuncType(return_type = py_object_type,
1918 has_varargs = False,
1919 exception_value = None,
1920 exception_check = False,
1923 is_overridable = True)
1924 cfunc = CVarDefNode(self.pos, type=cfunc_type)
1928 cfunc_type = cfunc.type
1929 if len(self.args) != len(cfunc_type.args) or cfunc_type.has_varargs:
1930 error(self.pos, "wrong number of arguments")
1931 error(cfunc.pos, "previous declaration here")
1932 for i, (formal_arg, type_arg) in enumerate(zip(self.args, cfunc_type.args)):
1933 name_declarator, type = formal_arg.analyse(scope, nonempty=1,
1934 is_self_arg = (i == 0 and scope.is_c_class_scope))
1935 if type is None or type is PyrexTypes.py_object_type:
1936 formal_arg.type = type_arg.type
1937 formal_arg.name_declarator = name_declarator
1939 if cfunc_type.exception_value is None:
1940 exception_value = None
1942 exception_value = ExprNodes.ConstNode(self.pos, value=cfunc_type.exception_value, type=cfunc_type.return_type)
1943 declarator = CFuncDeclaratorNode(self.pos,
1944 base = CNameDeclaratorNode(self.pos, name=self.name, cname=None),
1946 has_varargs = False,
1947 exception_check = cfunc_type.exception_check,
1948 exception_value = exception_value,
1949 with_gil = cfunc_type.with_gil,
1950 nogil = cfunc_type.nogil)
1951 return CFuncDefNode(self.pos,
1953 base_type = CAnalysedBaseTypeNode(self.pos, type=cfunc_type.return_type),
1954 declarator = declarator,
1957 overridable = cfunc_type.is_overridable,
1959 with_gil = cfunc_type.with_gil,
1960 nogil = cfunc_type.nogil,
1961 visibility = 'private',
1963 directive_locals = getattr(cfunc, 'directive_locals', {}))
1965 def analyse_declarations(self, env):
1966 self.is_classmethod = self.is_staticmethod = False
1968 for decorator in self.decorators:
1969 func = decorator.decorator
1971 self.is_classmethod |= func.name == 'classmethod'
1972 self.is_staticmethod |= func.name == 'staticmethod'
1974 if self.is_classmethod and env.lookup_here('classmethod'):
1975 # classmethod() was overridden - not much we can do here ...
1976 self.is_classmethod = False
1977 if self.is_staticmethod and env.lookup_here('staticmethod'):
1978 # staticmethod() was overridden - not much we can do here ...
1979 self.is_staticmethod = False
1981 if self.name == '__new__':
1982 self.is_staticmethod = 1
1984 self.analyse_argument_types(env)
1985 if self.name == '<lambda>':
1986 self.declare_lambda_function(env)
1988 self.declare_pyfunction(env)
1989 self.analyse_signature(env)
1990 self.return_type = self.entry.signature.return_type()
1991 self.create_local_scope(env)
1993 def analyse_argument_types(self, env):
1994 directive_locals = self.directive_locals = env.directives['locals']
1995 allow_none_for_extension_args = env.directives['allow_none_for_extension_args']
1996 for arg in self.args:
1997 if hasattr(arg, 'name'):
1999 name_declarator = None
2001 base_type = arg.base_type.analyse(env)
2002 name_declarator, type = \
2003 arg.declarator.analyse(base_type, env)
2004 arg.name = name_declarator.name
2005 if arg.name in directive_locals:
2006 type_node = directive_locals[arg.name]
2007 other_type = type_node.analyse_as_type(env)
2008 if other_type is None:
2009 error(type_node.pos, "Not a type")
2010 elif (type is not PyrexTypes.py_object_type
2011 and not type.same_as(other_type)):
2012 error(arg.base_type.pos, "Signature does not agree with previous declaration")
2013 error(type_node.pos, "Previous declaration here")
2016 if name_declarator and name_declarator.cname:
2018 "Python function argument cannot have C name specification")
2019 arg.type = type.as_argument_type()
2021 arg.needs_conversion = 0
2022 arg.needs_type_test = 0
2024 if arg.type.is_pyobject:
2026 arg.accept_none = True
2028 arg.accept_none = False
2029 elif arg.type.is_extension_type or arg.type.is_builtin_type:
2030 if arg.default and arg.default.constant_result is None:
2031 # special case: def func(MyType obj = None)
2032 arg.accept_none = True
2034 # default depends on compiler directive
2035 arg.accept_none = allow_none_for_extension_args
2037 # probably just a plain 'object'
2038 arg.accept_none = True
2040 arg.accept_none = True # won't be used, but must be there
2042 error(arg.pos, "Only Python type arguments can have 'not None'")
2044 error(arg.pos, "Only Python type arguments can have 'or None'")
2046 def analyse_signature(self, env):
2047 if self.entry.is_special:
2048 self.entry.trivial_signature = len(self.args) == 1 and not (self.star_arg or self.starstar_arg)
2049 elif not env.directives['always_allow_keywords'] and not (self.star_arg or self.starstar_arg):
2050 # Use the simpler calling signature for zero- and one-argument functions.
2051 if self.entry.signature is TypeSlots.pyfunction_signature:
2052 if len(self.args) == 0:
2053 self.entry.signature = TypeSlots.pyfunction_noargs
2054 elif len(self.args) == 1:
2055 if self.args[0].default is None and not self.args[0].kw_only:
2056 self.entry.signature = TypeSlots.pyfunction_onearg
2057 elif self.entry.signature is TypeSlots.pymethod_signature:
2058 if len(self.args) == 1:
2059 self.entry.signature = TypeSlots.unaryfunc
2060 elif len(self.args) == 2:
2061 if self.args[1].default is None and not self.args[1].kw_only:
2062 self.entry.signature = TypeSlots.ibinaryfunc
2064 sig = self.entry.signature
2065 nfixed = sig.num_fixed_args()
2066 if sig is TypeSlots.pymethod_signature and nfixed == 1 \
2067 and len(self.args) == 0 and self.star_arg:
2068 # this is the only case where a diverging number of
2069 # arguments is not an error - when we have no explicit
2070 # 'self' parameter as in method(*args)
2071 sig = self.entry.signature = TypeSlots.pyfunction_signature # self is not 'really' used
2072 self.self_in_stararg = 1
2075 for i in range(min(nfixed, len(self.args))):
2078 if sig.is_self_arg(i) and not self.is_staticmethod:
2079 if self.is_classmethod:
2081 arg.hdr_type = arg.type = Builtin.type_type
2084 arg.hdr_type = arg.type = env.parent_type
2085 arg.needs_conversion = 0
2087 arg.hdr_type = sig.fixed_arg_type(i)
2088 if not arg.type.same_as(arg.hdr_type):
2089 if arg.hdr_type.is_pyobject and arg.type.is_pyobject:
2090 arg.needs_type_test = 1
2092 arg.needs_conversion = 1
2093 if arg.needs_conversion:
2094 arg.hdr_cname = Naming.arg_prefix + arg.name
2096 arg.hdr_cname = Naming.var_prefix + arg.name
2098 if nfixed > len(self.args):
2099 self.bad_signature()
2101 elif nfixed < len(self.args):
2102 if not sig.has_generic_args:
2103 self.bad_signature()
2104 for arg in self.args:
2105 if arg.is_generic and \
2106 (arg.type.is_extension_type or arg.type.is_builtin_type):
2107 arg.needs_type_test = 1
2109 def bad_signature(self):
2110 sig = self.entry.signature
2111 expected_str = "%d" % sig.num_fixed_args()
2112 if sig.has_generic_args:
2113 expected_str = expected_str + " or more"
2115 if name.startswith("__") and name.endswith("__"):
2116 desc = "Special method"
2120 "%s %s has wrong number of arguments "
2121 "(%d declared, %s expected)" % (
2122 desc, self.name, len(self.args), expected_str))
2124 def signature_has_nongeneric_args(self):
2125 argcount = len(self.args)
2126 if argcount == 0 or (
2127 argcount == 1 and (self.args[0].is_self_arg or
2128 self.args[0].is_type_arg)):
2132 def signature_has_generic_args(self):
2133 return self.entry.signature.has_generic_args
2135 def declare_pyfunction(self, env):
2136 #print "DefNode.declare_pyfunction:", self.name, "in", env ###
2138 entry = env.lookup_here(name)
2139 if entry and entry.type.is_cfunction and not self.is_wrapper:
2140 warning(self.pos, "Overriding cdef method with def method.", 5)
2141 entry = env.declare_pyfunction(name, self.pos)
2143 prefix = env.scope_prefix
2144 entry.func_cname = \
2145 Naming.pyfunc_prefix + prefix + name
2146 entry.pymethdef_cname = \
2147 Naming.pymethdef_prefix + prefix + name
2148 if Options.docstrings:
2149 entry.doc = embed_position(self.pos, self.doc)
2151 Naming.funcdoc_prefix + prefix + name
2152 if entry.is_special:
2153 if entry.name in TypeSlots.invisible or not entry.doc or (entry.name in '__getattr__' and env.directives['fast_getattr']):
2154 entry.wrapperbase_cname = None
2156 entry.wrapperbase_cname = Naming.wrapperbase_prefix + prefix + name
2160 def declare_lambda_function(self, env):
2162 prefix = env.scope_prefix
2164 Naming.lambda_func_prefix + u'funcdef' + prefix + self.lambda_name
2165 entry = env.declare_lambda_function(func_cname, self.pos)
2166 entry.pymethdef_cname = \
2167 Naming.lambda_func_prefix + u'methdef' + prefix + self.lambda_name
2168 entry.qualified_name = env.qualify_name(self.lambda_name)
2172 def declare_arguments(self, env):
2173 for arg in self.args:
2175 error(arg.pos, "Missing argument name")
2177 env.control_flow.set_state((), (arg.name, 'source'), 'arg')
2178 env.control_flow.set_state((), (arg.name, 'initialized'), True)
2179 if arg.needs_conversion:
2180 arg.entry = env.declare_var(arg.name, arg.type, arg.pos)
2181 if arg.type.is_pyobject:
2182 arg.entry.init = "0"
2183 arg.entry.init_to_none = 0
2185 arg.entry = self.declare_argument(env, arg)
2187 arg.entry.is_self_arg = arg.is_self_arg
2189 if arg.is_self_arg or arg.is_type_arg or \
2190 (arg.type.is_extension_type and not arg.hdr_type.is_extension_type):
2191 arg.entry.is_declared_generic = 1
2192 self.declare_python_arg(env, self.star_arg)
2193 self.declare_python_arg(env, self.starstar_arg)
2195 def declare_python_arg(self, env, arg):
2197 if env.directives['infer_types'] != False:
2198 type = PyrexTypes.unspecified_type
2200 type = py_object_type
2201 entry = env.declare_var(arg.name, type, arg.pos)
2204 entry.init_to_none = 0
2205 entry.xdecref_cleanup = 1
2207 env.control_flow.set_state((), (arg.name, 'initialized'), True)
2209 def analyse_expressions(self, env):
2210 self.local_scope.directives = env.directives
2211 self.analyse_default_values(env)
2212 if self.needs_assignment_synthesis(env):
2213 # Shouldn't we be doing this at the module level too?
2214 self.synthesize_assignment_node(env)
2216 def needs_assignment_synthesis(self, env, code=None):
2217 # Should enable for module level as well, that will require more testing...
2218 if env.is_module_scope:
2220 return env.directives['binding']
2222 return code.globalstate.directives['binding']
2223 return env.is_py_class_scope or env.is_closure_scope
2225 def synthesize_assignment_node(self, env):
2228 while genv.is_py_class_scope or genv.is_c_class_scope:
2229 genv = genv.outer_scope
2231 if genv.is_closure_scope:
2232 rhs = ExprNodes.InnerFunctionNode(
2233 self.pos, pymethdef_cname = self.entry.pymethdef_cname)
2235 rhs = ExprNodes.PyCFunctionNode(
2236 self.pos, pymethdef_cname = self.entry.pymethdef_cname, binding = env.directives['binding'])
2238 if env.is_py_class_scope:
2239 if not self.is_staticmethod and not self.is_classmethod:
2242 self.assmt = SingleAssignmentNode(self.pos,
2243 lhs = ExprNodes.NameNode(self.pos, name = self.name),
2245 self.assmt.analyse_declarations(env)
2246 self.assmt.analyse_expressions(env)
2248 def generate_function_header(self, code, with_pymethdef, proto_only=0):
2250 sig = self.entry.signature
2251 if sig.has_dummy_arg or self.self_in_stararg:
2252 arg_code_list.append(
2253 "PyObject *%s" % Naming.self_cname)
2254 for arg in self.args:
2255 if not arg.is_generic:
2256 if arg.is_self_arg or arg.is_type_arg:
2257 arg_code_list.append("PyObject *%s" % arg.hdr_cname)
2259 arg_code_list.append(
2260 arg.hdr_type.declaration_code(arg.hdr_cname))
2261 if not self.entry.is_special and sig.method_flags() == [TypeSlots.method_noargs]:
2262 arg_code_list.append("CYTHON_UNUSED PyObject *unused")
2263 if sig.has_generic_args:
2264 arg_code_list.append(
2265 "PyObject *%s, PyObject *%s"
2266 % (Naming.args_cname, Naming.kwds_cname))
2267 arg_code = ", ".join(arg_code_list)
2268 dc = self.return_type.declaration_code(self.entry.func_cname)
2269 mf = " ".join(self.modifiers).upper()
2271 header = "static %s%s(%s)" % (mf, dc, arg_code)
2272 code.putln("%s; /*proto*/" % header)
2275 if (Options.docstrings and self.entry.doc and
2276 not self.entry.scope.is_property_scope and
2277 (not self.entry.is_special or self.entry.wrapperbase_cname)):
2278 docstr = self.entry.doc
2279 if docstr.is_unicode:
2280 docstr = docstr.utf8encode()
2282 'static char %s[] = "%s";' % (
2283 self.entry.doc_cname,
2284 split_string_literal(escape_byte_string(docstr))))
2285 if self.entry.is_special:
2287 "struct wrapperbase %s;" % self.entry.wrapperbase_cname)
2290 "static PyMethodDef %s = " %
2291 self.entry.pymethdef_cname)
2292 code.put_pymethoddef(self.entry, ";", allow_skip=False)
2293 code.putln("%s {" % header)
2295 def generate_argument_declarations(self, env, code):
2296 for arg in self.args:
2297 if arg.is_generic: # or arg.needs_conversion:
2298 if arg.needs_conversion:
2299 code.putln("PyObject *%s = 0;" % arg.hdr_cname)
2300 elif not arg.entry.in_closure:
2301 code.put_var_declaration(arg.entry)
2303 def generate_keyword_list(self, code):
2304 if self.signature_has_generic_args() and \
2305 self.signature_has_nongeneric_args():
2307 "static PyObject **%s[] = {" %
2308 Naming.pykwdlist_cname)
2309 for arg in self.args:
2311 pystring_cname = code.intern_identifier(arg.name)
2312 code.put('&%s,' % pystring_cname)
2315 def generate_argument_parsing_code(self, env, code):
2316 # Generate PyArg_ParseTuple call for generic
2317 # arguments, if any.
2318 if self.entry.signature.has_dummy_arg and not self.self_in_stararg:
2319 # get rid of unused argument warning
2320 code.putln("%s = %s;" % (Naming.self_cname, Naming.self_cname))
2322 old_error_label = code.new_error_label()
2323 our_error_label = code.error_label
2324 end_label = code.new_label("argument_unpacking_done")
2326 has_kwonly_args = self.num_kwonly_args > 0
2327 has_star_or_kw_args = self.star_arg is not None \
2328 or self.starstar_arg is not None or has_kwonly_args
2330 for arg in self.args:
2331 if not arg.type.is_pyobject:
2332 done = arg.type.create_from_py_utility_code(env)
2333 if not done: pass # will fail later
2335 if not self.signature_has_generic_args():
2336 if has_star_or_kw_args:
2337 error(self.pos, "This method cannot have * or keyword arguments")
2338 self.generate_argument_conversion_code(code)
2340 elif not self.signature_has_nongeneric_args():
2341 # func(*args) or func(**kw) or func(*args, **kw)
2342 self.generate_stararg_copy_code(code)
2345 positional_args = []
2347 for arg in self.args:
2348 arg_entry = arg.entry
2351 if not arg.is_self_arg and not arg.is_type_arg:
2353 kw_only_args.append(arg)
2355 positional_args.append(arg)
2357 kw_only_args.append(arg)
2358 elif not arg.is_self_arg and not arg.is_type_arg:
2359 positional_args.append(arg)
2361 self.generate_tuple_and_keyword_parsing_code(
2362 positional_args, kw_only_args, end_label, code)
2364 code.error_label = old_error_label
2365 if code.label_used(our_error_label):
2366 if not code.label_used(end_label):
2367 code.put_goto(end_label)
2368 code.put_label(our_error_label)
2369 if has_star_or_kw_args:
2370 self.generate_arg_decref(self.star_arg, code)
2371 if self.starstar_arg:
2372 if self.starstar_arg.entry.xdecref_cleanup:
2373 code.put_var_xdecref(self.starstar_arg.entry)
2375 code.put_var_decref(self.starstar_arg.entry)
2376 code.putln('__Pyx_AddTraceback("%s");' % self.entry.qualified_name)
2377 # The arguments are put into the closure one after the
2378 # other, so when type errors are found, all references in
2379 # the closure instance must be properly ref-counted to
2380 # facilitate generic closure instance deallocation. In
2381 # the case of an argument type error, it's best to just
2382 # DECREF+clear the already handled references, as this
2383 # frees their references as early as possible.
2384 for arg in self.args:
2385 if arg.type.is_pyobject and arg.entry.in_closure:
2386 code.put_var_xdecref_clear(arg.entry)
2387 if self.needs_closure:
2388 code.put_decref(Naming.cur_scope_cname, self.local_scope.scope_class.type)
2389 code.put_finish_refcount_context()
2390 code.putln("return %s;" % self.error_value())
2391 if code.label_used(end_label):
2392 code.put_label(end_label)
2394 def generate_arg_assignment(self, arg, item, code):
2395 if arg.type.is_pyobject:
2397 item = PyrexTypes.typecast(arg.type, PyrexTypes.py_object_type, item)
2399 code.putln("%s = %s;" % (entry.cname, item))
2400 if entry.in_closure:
2401 code.put_var_incref(entry)
2403 func = arg.type.from_py_function
2405 code.putln("%s = %s(%s); %s" % (
2409 code.error_goto_if(arg.type.error_condition(arg.entry.cname), arg.pos)))
2411 error(arg.pos, "Cannot convert Python object argument to type '%s'" % arg.type)
2413 def generate_arg_xdecref(self, arg, code):
2415 code.put_var_xdecref(arg.entry)
2417 def generate_arg_decref(self, arg, code):
2419 code.put_var_decref(arg.entry)
2421 def generate_stararg_copy_code(self, code):
2422 if not self.star_arg:
2423 code.globalstate.use_utility_code(raise_argtuple_invalid_utility_code)
2424 code.putln("if (unlikely(PyTuple_GET_SIZE(%s) > 0)) {" %
2426 code.put('__Pyx_RaiseArgtupleInvalid("%s", 1, 0, 0, PyTuple_GET_SIZE(%s)); return %s;' % (
2427 self.name, Naming.args_cname, self.error_value()))
2430 code.globalstate.use_utility_code(keyword_string_check_utility_code)
2432 if self.starstar_arg:
2434 kwarg_check = "unlikely(%s)" % Naming.kwds_cname
2436 kwarg_check = "%s" % Naming.kwds_cname
2438 kwarg_check = "unlikely(%s) && unlikely(PyDict_Size(%s) > 0)" % (
2439 Naming.kwds_cname, Naming.kwds_cname)
2441 "if (%s && unlikely(!__Pyx_CheckKeywordStrings(%s, \"%s\", %d))) return %s;" % (
2442 kwarg_check, Naming.kwds_cname, self.name,
2443 bool(self.starstar_arg), self.error_value()))
2445 if self.starstar_arg:
2446 code.putln("%s = (%s) ? PyDict_Copy(%s) : PyDict_New();" % (
2447 self.starstar_arg.entry.cname,
2450 code.putln("if (unlikely(!%s)) return %s;" % (
2451 self.starstar_arg.entry.cname, self.error_value()))
2452 self.starstar_arg.entry.xdecref_cleanup = 0
2453 code.put_gotref(self.starstar_arg.entry.cname)
2455 if self.self_in_stararg:
2456 # need to create a new tuple with 'self' inserted as first item
2457 code.put("%s = PyTuple_New(PyTuple_GET_SIZE(%s)+1); if (unlikely(!%s)) " % (
2458 self.star_arg.entry.cname,
2460 self.star_arg.entry.cname))
2461 if self.starstar_arg:
2463 code.put_decref_clear(self.starstar_arg.entry.cname, py_object_type)
2464 code.putln("return %s;" % self.error_value())
2467 code.putln("return %s;" % self.error_value())
2468 code.put_gotref(self.star_arg.entry.cname)
2469 code.put_incref(Naming.self_cname, py_object_type)
2470 code.put_giveref(Naming.self_cname)
2471 code.putln("PyTuple_SET_ITEM(%s, 0, %s);" % (
2472 self.star_arg.entry.cname, Naming.self_cname))
2473 temp = code.funcstate.allocate_temp(PyrexTypes.c_py_ssize_t_type, manage_ref=False)
2474 code.putln("for (%s=0; %s < PyTuple_GET_SIZE(%s); %s++) {" % (
2475 temp, temp, Naming.args_cname, temp))
2476 code.putln("PyObject* item = PyTuple_GET_ITEM(%s, %s);" % (
2477 Naming.args_cname, temp))
2478 code.put_incref("item", py_object_type)
2479 code.put_giveref("item")
2480 code.putln("PyTuple_SET_ITEM(%s, %s+1, item);" % (
2481 self.star_arg.entry.cname, temp))
2483 code.funcstate.release_temp(temp)
2484 self.star_arg.entry.xdecref_cleanup = 0
2486 code.put_incref(Naming.args_cname, py_object_type)
2487 code.putln("%s = %s;" % (
2488 self.star_arg.entry.cname,
2490 self.star_arg.entry.xdecref_cleanup = 0
2492 def generate_tuple_and_keyword_parsing_code(self, positional_args,
2493 kw_only_args, success_label, code):
2494 argtuple_error_label = code.new_label("argtuple_error")
2496 min_positional_args = self.num_required_args - self.num_required_kw_args
2497 if len(self.args) > 0 and (self.args[0].is_self_arg or self.args[0].is_type_arg):
2498 min_positional_args -= 1
2499 max_positional_args = len(positional_args)
2500 has_fixed_positional_count = not self.star_arg and \
2501 min_positional_args == max_positional_args
2503 code.globalstate.use_utility_code(raise_double_keywords_utility_code)
2504 code.globalstate.use_utility_code(raise_argtuple_invalid_utility_code)
2505 if self.num_required_kw_args:
2506 code.globalstate.use_utility_code(raise_keyword_required_utility_code)
2508 if self.starstar_arg or self.star_arg:
2509 self.generate_stararg_init_code(max_positional_args, code)
2511 # --- optimised code when we receive keyword arguments
2512 if self.num_required_kw_args:
2513 likely_hint = "likely"
2515 likely_hint = "unlikely"
2516 code.putln("if (%s(%s)) {" % (likely_hint, Naming.kwds_cname))
2517 self.generate_keyword_unpacking_code(
2518 min_positional_args, max_positional_args,
2519 has_fixed_positional_count,
2520 positional_args, kw_only_args, argtuple_error_label, code)
2522 # --- optimised code when we do not receive any keyword arguments
2523 if (self.num_required_kw_args and min_positional_args > 0) or min_positional_args == max_positional_args:
2524 # Python raises arg tuple related errors first, so we must
2525 # check the length here
2526 if min_positional_args == max_positional_args and not self.star_arg:
2530 code.putln('} else if (PyTuple_GET_SIZE(%s) %s %d) {' % (
2531 Naming.args_cname, compare, min_positional_args))
2532 code.put_goto(argtuple_error_label)
2534 if self.num_required_kw_args:
2535 # pure error case: keywords required but not passed
2536 if max_positional_args > min_positional_args and not self.star_arg:
2537 code.putln('} else if (PyTuple_GET_SIZE(%s) > %d) {' % (
2538 Naming.args_cname, max_positional_args))
2539 code.put_goto(argtuple_error_label)
2540 code.putln('} else {')
2541 for i, arg in enumerate(kw_only_args):
2543 pystring_cname = code.intern_identifier(arg.name)
2544 # required keyword-only argument missing
2545 code.put('__Pyx_RaiseKeywordRequired("%s", %s); ' % (
2548 code.putln(code.error_goto(self.pos))
2551 elif min_positional_args == max_positional_args:
2552 # parse the exact number of positional arguments from the
2554 code.putln('} else {')
2555 for i, arg in enumerate(positional_args):
2556 item = "PyTuple_GET_ITEM(%s, %d)" % (Naming.args_cname, i)
2557 self.generate_arg_assignment(arg, item, code)
2558 self.generate_arg_default_assignments(code)
2561 # parse the positional arguments from the variable length
2563 code.putln('} else {')
2564 self.generate_arg_default_assignments(code)
2565 code.putln('switch (PyTuple_GET_SIZE(%s)) {' % Naming.args_cname)
2567 code.putln('default:')
2568 reversed_args = list(enumerate(positional_args))[::-1]
2569 for i, arg in reversed_args:
2570 if i >= min_positional_args-1:
2571 if min_positional_args > 1:
2572 code.putln('case %2d:' % (i+1)) # pure code beautification
2574 code.put('case %2d: ' % (i+1))
2575 item = "PyTuple_GET_ITEM(%s, %d)" % (Naming.args_cname, i)
2576 self.generate_arg_assignment(arg, item, code)
2577 if min_positional_args == 0:
2578 code.put('case 0: ')
2579 code.putln('break;')
2581 if min_positional_args:
2582 for i in range(min_positional_args-1, -1, -1):
2583 code.putln('case %2d:' % i)
2584 code.put_goto(argtuple_error_label)
2586 code.put('default: ')
2587 code.put_goto(argtuple_error_label)
2592 if code.label_used(argtuple_error_label):
2593 code.put_goto(success_label)
2594 code.put_label(argtuple_error_label)
2595 code.put('__Pyx_RaiseArgtupleInvalid("%s", %d, %d, %d, PyTuple_GET_SIZE(%s)); ' % (
2596 self.name, has_fixed_positional_count,
2597 min_positional_args, max_positional_args,
2599 code.putln(code.error_goto(self.pos))
2601 def generate_arg_default_assignments(self, code):
2602 for arg in self.args:
2603 if arg.is_generic and arg.default:
2607 arg.calculate_default_value_code(code)))
2609 def generate_stararg_init_code(self, max_positional_args, code):
2610 if self.starstar_arg:
2611 self.starstar_arg.entry.xdecref_cleanup = 0
2612 code.putln('%s = PyDict_New(); if (unlikely(!%s)) return %s;' % (
2613 self.starstar_arg.entry.cname,
2614 self.starstar_arg.entry.cname,
2615 self.error_value()))
2616 code.put_gotref(self.starstar_arg.entry.cname)
2618 self.star_arg.entry.xdecref_cleanup = 0
2619 code.putln('if (PyTuple_GET_SIZE(%s) > %d) {' % (
2621 max_positional_args))
2622 code.put('%s = PyTuple_GetSlice(%s, %d, PyTuple_GET_SIZE(%s)); ' % (
2623 self.star_arg.entry.cname, Naming.args_cname,
2624 max_positional_args, Naming.args_cname))
2625 code.put_gotref(self.star_arg.entry.cname)
2626 if self.starstar_arg:
2628 code.putln("if (unlikely(!%s)) {" % self.star_arg.entry.cname)
2629 code.put_decref(self.starstar_arg.entry.cname, py_object_type)
2630 code.putln('return %s;' % self.error_value())
2633 code.putln("if (unlikely(!%s)) return %s;" % (
2634 self.star_arg.entry.cname, self.error_value()))
2635 code.putln('} else {')
2636 code.put("%s = %s; " % (self.star_arg.entry.cname, Naming.empty_tuple))
2637 code.put_incref(Naming.empty_tuple, py_object_type)
2640 def generate_keyword_unpacking_code(self, min_positional_args, max_positional_args,
2641 has_fixed_positional_count, positional_args,
2642 kw_only_args, argtuple_error_label, code):
2643 all_args = tuple(positional_args) + tuple(kw_only_args)
2644 max_args = len(all_args)
2646 code.putln("Py_ssize_t kw_args = PyDict_Size(%s);" %
2648 # the 'values' array collects borrowed references to arguments
2649 # before doing any type coercion etc.
2650 code.putln("PyObject* values[%d] = {%s};" % (
2651 max_args, ','.join('0'*max_args)))
2653 # assign borrowed Python default values to the values array,
2654 # so that they can be overwritten by received arguments below
2655 for i, arg in enumerate(all_args):
2656 if arg.default and arg.type.is_pyobject:
2657 default_value = arg.calculate_default_value_code(code)
2658 code.putln('values[%d] = %s;' % (i, arg.type.as_pyobject(default_value)))
2660 # parse the args tuple and check that it's not too long
2661 code.putln('switch (PyTuple_GET_SIZE(%s)) {' % Naming.args_cname)
2663 code.putln('default:')
2664 for i in range(max_positional_args-1, -1, -1):
2665 code.put('case %2d: ' % (i+1))
2666 code.putln("values[%d] = PyTuple_GET_ITEM(%s, %d);" % (
2667 i, Naming.args_cname, i))
2668 code.putln('case 0: break;')
2669 if not self.star_arg:
2670 code.put('default: ') # more arguments than allowed
2671 code.put_goto(argtuple_error_label)
2674 # now fill up the positional/required arguments with values
2676 if self.num_required_args or max_positional_args > 0:
2677 last_required_arg = -1
2678 for i, arg in enumerate(all_args):
2680 last_required_arg = i
2681 if last_required_arg < max_positional_args:
2682 last_required_arg = max_positional_args-1
2683 num_required_args = self.num_required_args
2684 if max_positional_args > 0:
2685 code.putln('switch (PyTuple_GET_SIZE(%s)) {' % Naming.args_cname)
2686 for i, arg in enumerate(all_args[:last_required_arg+1]):
2687 if max_positional_args > 0 and i <= max_positional_args:
2688 if self.star_arg and i == max_positional_args:
2689 code.putln('default:')
2691 code.putln('case %2d:' % i)
2692 pystring_cname = code.intern_identifier(arg.name)
2695 # handled separately below
2697 code.putln('if (kw_args > 0) {')
2698 code.putln('PyObject* value = PyDict_GetItem(%s, %s);' % (
2699 Naming.kwds_cname, pystring_cname))
2700 code.putln('if (value) { values[%d] = value; kw_args--; }' % i)
2703 num_required_args -= 1
2704 code.putln('values[%d] = PyDict_GetItem(%s, %s);' % (
2705 i, Naming.kwds_cname, pystring_cname))
2706 code.putln('if (likely(values[%d])) kw_args--;' % i);
2707 if i < min_positional_args:
2709 # special case: we know arg 0 is missing
2711 code.put_goto(argtuple_error_label)
2713 # print the correct number of values (args or
2714 # kwargs) that were passed into positional
2715 # arguments up to this point
2716 code.putln('else {')
2717 code.put('__Pyx_RaiseArgtupleInvalid("%s", %d, %d, %d, %d); ' % (
2718 self.name, has_fixed_positional_count,
2719 min_positional_args, max_positional_args, i))
2720 code.putln(code.error_goto(self.pos))
2723 code.putln('else {')
2724 code.put('__Pyx_RaiseKeywordRequired("%s", %s); ' %(
2725 self.name, pystring_cname))
2726 code.putln(code.error_goto(self.pos))
2728 if max_positional_args > 0:
2731 if kw_only_args and not self.starstar_arg:
2732 # unpack optional keyword-only arguments
2733 # checking for interned strings in a dict is faster than iterating
2734 # but it's too likely that we must iterate if we expect **kwargs
2736 for i, arg in enumerate(all_args[max_positional_args:]):
2737 if not arg.kw_only or not arg.default:
2739 optional_args.append((i+max_positional_args, arg))
2741 # this mimics an unrolled loop so that we can "break" out of it
2742 code.putln('while (kw_args > 0) {')
2743 code.putln('PyObject* value;')
2744 for i, arg in optional_args:
2745 pystring_cname = code.intern_identifier(arg.name)
2747 'value = PyDict_GetItem(%s, %s);' % (
2748 Naming.kwds_cname, pystring_cname))
2750 'if (value) { values[%d] = value; if (!(--kw_args)) break; }' % i)
2751 code.putln('break;')
2754 code.putln('if (unlikely(kw_args > 0)) {')
2755 # non-positional/-required kw args left in dict: default args,
2756 # kw-only args, **kwargs or error
2758 # This is sort of a catch-all: except for checking required
2759 # arguments, this will always do the right thing for unpacking
2760 # keyword arguments, so that we can concentrate on optimising
2761 # common cases above.
2762 if max_positional_args == 0:
2765 code.putln("const Py_ssize_t used_pos_args = (PyTuple_GET_SIZE(%s) < %d) ? PyTuple_GET_SIZE(%s) : %d;" % (
2766 Naming.args_cname, max_positional_args,
2767 Naming.args_cname, max_positional_args))
2768 pos_arg_count = "used_pos_args"
2770 pos_arg_count = "PyTuple_GET_SIZE(%s)" % Naming.args_cname
2771 code.globalstate.use_utility_code(parse_keywords_utility_code)
2773 'if (unlikely(__Pyx_ParseOptionalKeywords(%s, %s, %s, values, %s, "%s") < 0)) ' % (
2775 Naming.pykwdlist_cname,
2776 self.starstar_arg and self.starstar_arg.entry.cname or '0',
2779 code.putln(code.error_goto(self.pos))
2782 # convert arg values to their final type and assign them
2783 for i, arg in enumerate(all_args):
2784 if arg.default and not arg.type.is_pyobject:
2785 code.putln("if (values[%d]) {" % i)
2786 self.generate_arg_assignment(arg, "values[%d]" % i, code)
2787 if arg.default and not arg.type.is_pyobject:
2788 code.putln('} else {')
2792 arg.calculate_default_value_code(code)))
2795 def generate_argument_conversion_code(self, code):
2796 # Generate code to convert arguments from signature type to
2797 # declared type, if needed. Also copies signature arguments
2798 # into closure fields.
2799 for arg in self.args:
2800 if arg.needs_conversion:
2801 self.generate_arg_conversion(arg, code)
2802 elif arg.entry.in_closure:
2803 code.putln('%s = %s;' % (arg.entry.cname, arg.hdr_cname))
2804 if arg.type.is_pyobject:
2805 code.put_var_incref(arg.entry)
2807 def generate_arg_conversion(self, arg, code):
2808 # Generate conversion code for one argument.
2809 old_type = arg.hdr_type
2811 if old_type.is_pyobject:
2813 code.putln("if (%s) {" % arg.hdr_cname)
2815 code.putln("assert(%s); {" % arg.hdr_cname)
2816 self.generate_arg_conversion_from_pyobject(arg, code)
2818 elif new_type.is_pyobject:
2819 self.generate_arg_conversion_to_pyobject(arg, code)
2821 if new_type.assignable_from(old_type):
2823 "%s = %s;" % (arg.entry.cname, arg.hdr_cname))
2826 "Cannot convert 1 argument from '%s' to '%s'" %
2827 (old_type, new_type))
2829 def generate_arg_conversion_from_pyobject(self, arg, code):
2831 func = new_type.from_py_function
2832 # copied from CoerceFromPyTypeNode
2834 lhs = arg.entry.cname
2835 rhs = "%s(%s)" % (func, arg.hdr_cname)
2836 if new_type.is_enum:
2837 rhs = PyrexTypes.typecast(new_type, PyrexTypes.c_long_type, rhs)
2838 code.putln("%s = %s; %s" % (
2841 code.error_goto_if(new_type.error_condition(arg.entry.cname), arg.pos)))
2844 "Cannot convert Python object argument to type '%s'"
2847 def generate_arg_conversion_to_pyobject(self, arg, code):
2848 old_type = arg.hdr_type
2849 func = old_type.to_py_function
2851 code.putln("%s = %s(%s); %s" % (
2855 code.error_goto_if_null(arg.entry.cname, arg.pos)))
2856 code.put_var_gotref(arg.entry)
2859 "Cannot convert argument of type '%s' to Python object"
2862 def generate_argument_type_tests(self, code):
2863 # Generate type tests for args whose signature
2864 # type is PyObject * and whose declared type is
2865 # a subtype thereof.
2866 for arg in self.args:
2867 if arg.needs_type_test:
2868 self.generate_arg_type_test(arg, code)
2869 elif not arg.accept_none and arg.type.is_pyobject:
2870 self.generate_arg_none_check(arg, code)
2872 def error_value(self):
2873 return self.entry.signature.error_value
2875 def caller_will_check_exceptions(self):
2878 class OverrideCheckNode(StatNode):
2879 # A Node for dispatching to the def method if it
2888 child_attrs = ['body']
2892 def analyse_expressions(self, env):
2893 self.args = env.arg_entries
2894 if self.py_func.is_module_scope:
2899 self.func_node = ExprNodes.RawCNameExprNode(self.pos, py_object_type)
2900 call_tuple = ExprNodes.TupleNode(self.pos, args=[ExprNodes.NameNode(self.pos, name=arg.name) for arg in self.args[first_arg:]])
2901 call_node = ExprNodes.SimpleCallNode(self.pos,
2902 function=self.func_node,
2903 args=[ExprNodes.NameNode(self.pos, name=arg.name) for arg in self.args[first_arg:]])
2904 self.body = ReturnStatNode(self.pos, value=call_node)
2905 self.body.analyse_expressions(env)
2907 def generate_execution_code(self, code):
2908 interned_attr_cname = code.intern_identifier(self.py_func.entry.name)
2909 # Check to see if we are an extension type
2910 if self.py_func.is_module_scope:
2911 self_arg = "((PyObject *)%s)" % Naming.module_cname
2913 self_arg = "((PyObject *)%s)" % self.args[0].cname
2914 code.putln("/* Check if called by wrapper */")
2915 code.putln("if (unlikely(%s)) ;" % Naming.skip_dispatch_cname)
2916 code.putln("/* Check if overriden in Python */")
2917 if self.py_func.is_module_scope:
2918 code.putln("else {")
2920 code.putln("else if (unlikely(Py_TYPE(%s)->tp_dictoffset != 0)) {" % self_arg)
2921 func_node_temp = code.funcstate.allocate_temp(py_object_type, manage_ref=True)
2922 self.func_node.set_cname(func_node_temp)
2923 # need to get attribute manually--scope would return cdef method
2924 err = code.error_goto_if_null(func_node_temp, self.pos)
2925 code.putln("%s = PyObject_GetAttr(%s, %s); %s" % (
2926 func_node_temp, self_arg, interned_attr_cname, err))
2927 code.put_gotref(func_node_temp)
2928 is_builtin_function_or_method = "PyCFunction_Check(%s)" % func_node_temp
2929 is_overridden = "(PyCFunction_GET_FUNCTION(%s) != (void *)&%s)" % (
2930 func_node_temp, self.py_func.entry.func_cname)
2931 code.putln("if (!%s || %s) {" % (is_builtin_function_or_method, is_overridden))
2932 self.body.generate_execution_code(code)
2934 code.put_decref_clear(func_node_temp, PyrexTypes.py_object_type)
2935 code.funcstate.release_temp(func_node_temp)
2938 class ClassDefNode(StatNode, BlockNode):
2941 class PyClassDefNode(ClassDefNode):
2942 # A Python class definition.
2944 # name EncodedString Name of the class
2945 # doc string or None
2946 # body StatNode Attribute definition code
2947 # entry Symtab.Entry
2948 # scope PyClassScope
2949 # decorators [DecoratorNode] list of decorators or None
2951 # The following subnodes are constructed internally:
2953 # dict DictNode Class dictionary or Py3 namespace
2954 # classobj ClassNode Class object
2955 # target NameNode Variable to assign class object to
2957 child_attrs = ["body", "dict", "metaclass", "mkw", "bases", "classobj", "target"]
2959 py3_style_class = False # Python3 style class (bases+kwargs)
2961 def __init__(self, pos, name, bases, doc, body, decorators = None,
2962 keyword_args = None, starstar_arg = None):
2963 StatNode.__init__(self, pos)
2967 self.decorators = decorators
2969 if self.doc and Options.docstrings:
2970 doc = embed_position(self.pos, self.doc)
2971 doc_node = ExprNodes.StringNode(pos, value = doc)
2974 if keyword_args or starstar_arg:
2975 self.py3_style_class = True
2977 self.metaclass = None
2978 if keyword_args and not starstar_arg:
2979 for i, item in list(enumerate(keyword_args.key_value_pairs))[::-1]:
2980 if item.key.value == 'metaclass':
2981 if self.metaclass is not None:
2982 error(item.pos, "keyword argument 'metaclass' passed multiple times")
2983 # special case: we already know the metaclass,
2984 # so we don't need to do the "build kwargs,
2985 # find metaclass" dance at runtime
2986 self.metaclass = item.value
2987 del keyword_args.key_value_pairs[i]
2988 if starstar_arg or (keyword_args and keyword_args.key_value_pairs):
2989 self.mkw = ExprNodes.KeywordArgsNode(
2990 pos, keyword_args = keyword_args, starstar_arg = starstar_arg)
2992 self.mkw = ExprNodes.NullNode(pos)
2993 if self.metaclass is None:
2994 self.metaclass = ExprNodes.PyClassMetaclassNode(
2995 pos, mkw = self.mkw, bases = self.bases)
2996 self.dict = ExprNodes.PyClassNamespaceNode(pos, name = name,
2997 doc = doc_node, metaclass = self.metaclass, bases = self.bases,
2999 self.classobj = ExprNodes.Py3ClassNode(pos, name = name,
3000 bases = self.bases, dict = self.dict, doc = doc_node,
3001 metaclass = self.metaclass, mkw = self.mkw)
3003 self.dict = ExprNodes.DictNode(pos, key_value_pairs = [])
3004 self.metaclass = None
3007 self.classobj = ExprNodes.ClassNode(pos, name = name,
3008 bases = bases, dict = self.dict, doc = doc_node)
3009 self.target = ExprNodes.NameNode(pos, name = name)
3011 def as_cclass(self):
3013 Return this node as if it were declared as an extension class
3015 if self.py3_style_class:
3016 error(self.classobj.pos, "Python3 style class could not be represented as C class")
3018 bases = self.classobj.bases.args
3020 base_class_name = None
3021 base_class_module = None
3022 elif len(bases) == 1:
3025 from ExprNodes import AttributeNode, NameNode
3026 while isinstance(base, AttributeNode):
3027 path.insert(0, base.attribute)
3029 if isinstance(base, NameNode):
3030 path.insert(0, base.name)
3031 base_class_name = path[-1]
3033 base_class_module = u'.'.join(path[:-1])
3035 base_class_module = None
3037 error(self.classobj.bases.args.pos, "Invalid base class")
3039 error(self.classobj.bases.args.pos, "C class may only have one base class")
3042 return CClassDefNode(self.pos,
3043 visibility = 'private',
3045 class_name = self.name,
3046 base_class_module = base_class_module,
3047 base_class_name = base_class_name,
3048 decorators = self.decorators,
3053 def create_scope(self, env):
3055 while genv.is_py_class_scope or genv.is_c_class_scope:
3056 genv = genv.outer_scope
3057 cenv = self.scope = PyClassScope(name = self.name, outer_scope = genv)
3060 def analyse_declarations(self, env):
3061 self.target.analyse_target_declaration(env)
3062 cenv = self.create_scope(env)
3063 cenv.directives = env.directives
3064 cenv.class_obj_cname = self.target.entry.cname
3065 self.body.analyse_declarations(cenv)
3067 def analyse_expressions(self, env):
3068 if self.py3_style_class:
3069 self.bases.analyse_expressions(env)
3070 self.metaclass.analyse_expressions(env)
3071 self.mkw.analyse_expressions(env)
3072 self.dict.analyse_expressions(env)
3073 self.classobj.analyse_expressions(env)
3074 genv = env.global_scope()
3076 self.body.analyse_expressions(cenv)
3077 self.target.analyse_target_expression(env, self.classobj)
3079 def generate_function_definitions(self, env, code):
3080 self.body.generate_function_definitions(self.scope, code)
3082 def generate_execution_code(self, code):
3083 code.pyclass_stack.append(self)
3085 if self.py3_style_class:
3086 self.bases.generate_evaluation_code(code)
3087 self.mkw.generate_evaluation_code(code)
3088 self.metaclass.generate_evaluation_code(code)
3089 self.dict.generate_evaluation_code(code)
3090 cenv.namespace_cname = cenv.class_obj_cname = self.dict.result()
3091 self.body.generate_execution_code(code)
3092 self.classobj.generate_evaluation_code(code)
3093 cenv.namespace_cname = cenv.class_obj_cname = self.classobj.result()
3094 self.target.generate_assignment_code(self.classobj, code)
3095 self.dict.generate_disposal_code(code)
3096 self.dict.free_temps(code)
3097 if self.py3_style_class:
3098 self.mkw.generate_disposal_code(code)
3099 self.mkw.free_temps(code)
3100 self.metaclass.generate_disposal_code(code)
3101 self.metaclass.free_temps(code)
3102 self.bases.generate_disposal_code(code)
3103 self.bases.free_temps(code)
3104 code.pyclass_stack.pop()
3106 class CClassDefNode(ClassDefNode):
3107 # An extension type definition.
3109 # visibility 'private' or 'public' or 'extern'
3110 # typedef_flag boolean
3112 # module_name string or None For import of extern type objects
3113 # class_name string Unqualified name of class
3114 # as_name string or None Name to declare as in this scope
3115 # base_class_module string or None Module containing the base class
3116 # base_class_name string or None Name of the base class
3117 # objstruct_name string or None Specified C name of object struct
3118 # typeobj_name string or None Specified C name of type object
3119 # in_pxd boolean Is in a .pxd file
3120 # decorators [DecoratorNode] list of decorators or None
3121 # doc string or None
3122 # body StatNode or None
3123 # entry Symtab.Entry
3124 # base_type PyExtensionType or None
3125 # buffer_defaults_node DictNode or None Declares defaults for a buffer
3126 # buffer_defaults_pos
3128 child_attrs = ["body"]
3129 buffer_defaults_node = None
3130 buffer_defaults_pos = None
3131 typedef_flag = False
3133 objstruct_name = None
3137 def analyse_declarations(self, env):
3138 #print "CClassDefNode.analyse_declarations:", self.class_name
3139 #print "...visibility =", self.visibility
3140 #print "...module_name =", self.module_name
3143 if self.buffer_defaults_node:
3144 buffer_defaults = Buffer.analyse_buffer_options(self.buffer_defaults_pos,
3145 env, [], self.buffer_defaults_node,
3146 need_complete=False)
3148 buffer_defaults = None
3150 if env.in_cinclude and not self.objstruct_name:
3151 error(self.pos, "Object struct name specification required for "
3152 "C class defined in 'extern from' block")
3153 self.base_type = None
3154 # Now that module imports are cached, we need to
3155 # import the modules for extern classes.
3156 if self.module_name:
3158 for module in env.cimported_modules:
3159 if module.name == self.module_name:
3160 self.module = module
3161 if self.module is None:
3162 self.module = ModuleScope(self.module_name, None, env.context)
3163 self.module.has_extern_class = 1
3164 env.add_imported_module(self.module)
3166 if self.base_class_name:
3167 if self.base_class_module:
3168 base_class_scope = env.find_module(self.base_class_module, self.pos)
3170 base_class_scope = env
3171 if self.base_class_name == 'object':
3172 # extension classes are special and don't need to inherit from object
3173 if base_class_scope is None or base_class_scope.lookup('object') is None:
3174 self.base_class_name = None
3175 self.base_class_module = None
3176 base_class_scope = None
3177 if base_class_scope:
3178 base_class_entry = base_class_scope.find(self.base_class_name, self.pos)
3179 if base_class_entry:
3180 if not base_class_entry.is_type:
3181 error(self.pos, "'%s' is not a type name" % self.base_class_name)
3182 elif not base_class_entry.type.is_extension_type:
3183 error(self.pos, "'%s' is not an extension type" % self.base_class_name)
3184 elif not base_class_entry.type.is_complete():
3185 error(self.pos, "Base class '%s' of type '%s' is incomplete" % (
3186 self.base_class_name, self.class_name))
3187 elif base_class_entry.type.scope and base_class_entry.type.scope.directives and \
3188 base_class_entry.type.scope.directives['final']:
3189 error(self.pos, "Base class '%s' of type '%s' is final" % (
3190 self.base_class_name, self.class_name))
3192 self.base_type = base_class_entry.type
3193 has_body = self.body is not None
3194 if self.module_name and self.visibility != 'extern':
3195 module_path = self.module_name.split(".")
3196 home_scope = env.find_imported_module(module_path, self.pos)
3202 if self.visibility == 'extern':
3203 if self.module_name == '__builtin__' and self.class_name in Builtin.builtin_types:
3204 warning(self.pos, "%s already a builtin Cython type" % self.class_name, 1)
3206 self.entry = home_scope.declare_c_class(
3207 name = self.class_name,
3209 defining = has_body and self.in_pxd,
3210 implementing = has_body and not self.in_pxd,
3211 module_name = self.module_name,
3212 base_type = self.base_type,
3213 objstruct_cname = self.objstruct_name,
3214 typeobj_cname = self.typeobj_name,
3215 visibility = self.visibility,
3216 typedef_flag = self.typedef_flag,
3218 buffer_defaults = buffer_defaults)
3219 if home_scope is not env and self.visibility == 'extern':
3220 env.add_imported_entry(self.class_name, self.entry, self.pos)
3221 self.scope = scope = self.entry.type.scope
3222 if scope is not None:
3223 scope.directives = env.directives
3225 if self.doc and Options.docstrings:
3226 scope.doc = embed_position(self.pos, self.doc)
3229 self.body.analyse_declarations(scope)
3233 scope.implemented = 1
3234 env.allocate_vtable_names(self.entry)
3236 def analyse_expressions(self, env):
3238 scope = self.entry.type.scope
3239 self.body.analyse_expressions(scope)
3241 def generate_function_definitions(self, env, code):
3243 self.body.generate_function_definitions(
3244 self.entry.type.scope, code)
3246 def generate_execution_code(self, code):
3247 # This is needed to generate evaluation code for
3248 # default values of method arguments.
3250 self.body.generate_execution_code(code)
3252 def annotate(self, code):
3254 self.body.annotate(code)
3257 class PropertyNode(StatNode):
3258 # Definition of a property in an extension type.
3261 # doc EncodedString or None Doc string
3264 child_attrs = ["body"]
3266 def analyse_declarations(self, env):
3267 entry = env.declare_property(self.name, self.doc, self.pos)
3269 entry.scope.directives = env.directives
3270 self.body.analyse_declarations(entry.scope)
3272 def analyse_expressions(self, env):
3273 self.body.analyse_expressions(env)
3275 def generate_function_definitions(self, env, code):
3276 self.body.generate_function_definitions(env, code)
3278 def generate_execution_code(self, code):
3281 def annotate(self, code):
3282 self.body.annotate(code)
3285 class GlobalNode(StatNode):
3286 # Global variable declaration.
3292 def analyse_declarations(self, env):
3293 for name in self.names:
3294 env.declare_global(name, self.pos)
3296 def analyse_expressions(self, env):
3299 def generate_execution_code(self, code):
3303 class ExprStatNode(StatNode):
3304 # Expression used as a statement.
3308 child_attrs = ["expr"]
3310 def analyse_declarations(self, env):
3312 if isinstance(self.expr, ExprNodes.GeneralCallNode):
3313 func = self.expr.function.as_cython_attribute()
3314 if func == u'declare':
3315 args, kwds = self.expr.explicit_args_kwds()
3317 error(self.expr.pos, "Variable names must be specified.")
3318 for var, type_node in kwds.key_value_pairs:
3319 type = type_node.analyse_as_type(env)
3321 error(type_node.pos, "Unknown type")
3323 env.declare_var(var.value, type, var.pos, is_cdef = True)
3324 self.__class__ = PassStatNode
3326 def analyse_expressions(self, env):
3327 self.expr.analyse_expressions(env)
3329 def generate_execution_code(self, code):
3330 self.expr.generate_evaluation_code(code)
3331 if not self.expr.is_temp and self.expr.result():
3332 code.putln("%s;" % self.expr.result())
3333 self.expr.generate_disposal_code(code)
3334 self.expr.free_temps(code)
3336 def generate_function_definitions(self, env, code):
3337 self.expr.generate_function_definitions(env, code)
3339 def annotate(self, code):
3340 self.expr.annotate(code)
3343 class AssignmentNode(StatNode):
3344 # Abstract base class for assignment nodes.
3346 # The analyse_expressions and generate_execution_code
3347 # phases of assignments are split into two sub-phases
3348 # each, to enable all the right hand sides of a
3349 # parallel assignment to be evaluated before assigning
3350 # to any of the left hand sides.
3352 def analyse_expressions(self, env):
3353 self.analyse_types(env)
3355 # def analyse_expressions(self, env):
3356 # self.analyse_expressions_1(env)
3357 # self.analyse_expressions_2(env)
3359 def generate_execution_code(self, code):
3360 self.generate_rhs_evaluation_code(code)
3361 self.generate_assignment_code(code)
3364 class SingleAssignmentNode(AssignmentNode):
3365 # The simplest case:
3369 # lhs ExprNode Left hand side
3370 # rhs ExprNode Right hand side
3371 # first bool Is this guaranteed the first assignment to lhs?
3373 child_attrs = ["lhs", "rhs"]
3375 declaration_only = False
3377 def analyse_declarations(self, env):
3380 # handle declarations of the form x = cython.foo()
3381 if isinstance(self.rhs, ExprNodes.CallNode):
3382 func_name = self.rhs.function.as_cython_attribute()
3384 args, kwds = self.rhs.explicit_args_kwds()
3386 if func_name in ['declare', 'typedef']:
3387 if len(args) > 2 or kwds is not None:
3388 error(self.rhs.pos, "Can only declare one type at a time.")
3390 type = args[0].analyse_as_type(env)
3392 error(args[0].pos, "Unknown type")
3395 if func_name == 'declare':
3396 if isinstance(lhs, ExprNodes.NameNode):
3397 vars = [(lhs.name, lhs.pos)]
3398 elif isinstance(lhs, ExprNodes.TupleNode):
3399 vars = [(var.name, var.pos) for var in lhs.args]
3401 error(lhs.pos, "Invalid declaration")
3403 for var, pos in vars:
3404 env.declare_var(var, type, pos, is_cdef = True)
3409 self.declaration_only = True
3411 self.declaration_only = True
3412 if not isinstance(lhs, ExprNodes.NameNode):
3413 error(lhs.pos, "Invalid declaration.")
3414 env.declare_typedef(lhs.name, type, self.pos, visibility='private')
3416 elif func_name in ['struct', 'union']:
3417 self.declaration_only = True
3418 if len(args) > 0 or kwds is None:
3419 error(self.rhs.pos, "Struct or union members must be given by name.")
3422 for member, type_node in kwds.key_value_pairs:
3423 type = type_node.analyse_as_type(env)
3425 error(type_node.pos, "Unknown type")
3427 members.append((member.value, type, member.pos))
3428 if len(members) < len(kwds.key_value_pairs):
3430 if not isinstance(self.lhs, ExprNodes.NameNode):
3431 error(self.lhs.pos, "Invalid declaration.")
3432 name = self.lhs.name
3433 scope = StructOrUnionScope(name)
3434 env.declare_struct_or_union(name, func_name, scope, False, self.rhs.pos)
3435 for member, type, pos in members:
3436 scope.declare_var(member, type, pos)
3438 if self.declaration_only:
3441 self.lhs.analyse_target_declaration(env)
3443 def analyse_types(self, env, use_temp = 0):
3444 self.rhs.analyse_types(env)
3445 self.lhs.analyse_target_types(env)
3446 self.lhs.gil_assignment_check(env)
3447 self.rhs = self.rhs.coerce_to(self.lhs.type, env)
3449 self.rhs = self.rhs.coerce_to_temp(env)
3451 def generate_rhs_evaluation_code(self, code):
3452 self.rhs.generate_evaluation_code(code)
3454 def generate_assignment_code(self, code):
3455 self.lhs.generate_assignment_code(self.rhs, code)
3457 def generate_function_definitions(self, env, code):
3458 self.rhs.generate_function_definitions(env, code)
3460 def annotate(self, code):
3461 self.lhs.annotate(code)
3462 self.rhs.annotate(code)
3465 class CascadedAssignmentNode(AssignmentNode):
3466 # An assignment with multiple left hand sides:
3470 # lhs_list [ExprNode] Left hand sides
3471 # rhs ExprNode Right hand sides
3475 # coerced_rhs_list [ExprNode] RHS coerced to type of each LHS
3477 child_attrs = ["lhs_list", "rhs", "coerced_rhs_list"]
3478 coerced_rhs_list = None
3480 def analyse_declarations(self, env):
3481 for lhs in self.lhs_list:
3482 lhs.analyse_target_declaration(env)
3484 def analyse_types(self, env, use_temp = 0):
3485 self.rhs.analyse_types(env)
3486 if not self.rhs.is_simple():
3488 self.rhs = self.rhs.coerce_to_temp(env)
3490 self.rhs = self.rhs.coerce_to_simple(env)
3491 from ExprNodes import CloneNode
3492 self.coerced_rhs_list = []
3493 for lhs in self.lhs_list:
3494 lhs.analyse_target_types(env)
3495 lhs.gil_assignment_check(env)
3496 rhs = CloneNode(self.rhs)
3497 rhs = rhs.coerce_to(lhs.type, env)
3498 self.coerced_rhs_list.append(rhs)
3500 def generate_rhs_evaluation_code(self, code):
3501 self.rhs.generate_evaluation_code(code)
3503 def generate_assignment_code(self, code):
3504 for i in range(len(self.lhs_list)):
3505 lhs = self.lhs_list[i]
3506 rhs = self.coerced_rhs_list[i]
3507 rhs.generate_evaluation_code(code)
3508 lhs.generate_assignment_code(rhs, code)
3509 # Assignment has disposed of the cloned RHS
3510 self.rhs.generate_disposal_code(code)
3511 self.rhs.free_temps(code)
3513 def generate_function_definitions(self, env, code):
3514 self.rhs.generate_function_definitions(env, code)
3516 def annotate(self, code):
3517 for i in range(len(self.lhs_list)):
3518 lhs = self.lhs_list[i].annotate(code)
3519 rhs = self.coerced_rhs_list[i].annotate(code)
3520 self.rhs.annotate(code)
3523 class ParallelAssignmentNode(AssignmentNode):
3524 # A combined packing/unpacking assignment:
3528 # This has been rearranged by the parser into
3530 # a = d ; b = e ; c = f
3532 # but we must evaluate all the right hand sides
3533 # before assigning to any of the left hand sides.
3535 # stats [AssignmentNode] The constituent assignments
3537 child_attrs = ["stats"]
3539 def analyse_declarations(self, env):
3540 for stat in self.stats:
3541 stat.analyse_declarations(env)
3543 def analyse_expressions(self, env):
3544 for stat in self.stats:
3545 stat.analyse_types(env, use_temp = 1)
3547 # def analyse_expressions(self, env):
3548 # for stat in self.stats:
3549 # stat.analyse_expressions_1(env, use_temp = 1)
3550 # for stat in self.stats:
3551 # stat.analyse_expressions_2(env)
3553 def generate_execution_code(self, code):
3554 for stat in self.stats:
3555 stat.generate_rhs_evaluation_code(code)
3556 for stat in self.stats:
3557 stat.generate_assignment_code(code)
3559 def generate_function_definitions(self, env, code):
3560 for stat in self.stats:
3561 stat.generate_function_definitions(env, code)
3563 def annotate(self, code):
3564 for stat in self.stats:
3568 class InPlaceAssignmentNode(AssignmentNode):
3569 # An in place arithmetic operand:
3575 # lhs ExprNode Left hand side
3576 # rhs ExprNode Right hand side
3577 # op char one of "+-*/%^&|"
3578 # dup (ExprNode) copy of lhs used for operation (auto-generated)
3580 # This code is a bit tricky because in order to obey Python
3581 # semantics the sub-expressions (e.g. indices) of the lhs must
3582 # not be evaluated twice. So we must re-use the values calculated
3583 # in evaluation phase for the assignment phase as well.
3584 # Fortunately, the type of the lhs node is fairly constrained
3585 # (it must be a NameNode, AttributeNode, or IndexNode).
3587 child_attrs = ["lhs", "rhs"]
3589 def analyse_declarations(self, env):
3590 self.lhs.analyse_target_declaration(env)
3592 def analyse_types(self, env):
3593 self.rhs.analyse_types(env)
3594 self.lhs.analyse_target_types(env)
3596 def generate_execution_code(self, code):
3598 self.rhs.generate_evaluation_code(code)
3599 self.lhs.generate_subexpr_evaluation_code(code)
3600 c_op = self.operator
3604 error(self.pos, "No C inplace power operator")
3605 if isinstance(self.lhs, ExprNodes.IndexNode) and self.lhs.is_buffer_access:
3606 if self.lhs.type.is_pyobject:
3607 error(self.pos, "In-place operators not allowed on object buffers in this release.")
3608 if c_op in ('/', '%') and self.lhs.type.is_int and not code.directives['cdivision']:
3609 error(self.pos, "In-place non-c divide operators not allowed on int buffers.")
3610 self.lhs.generate_buffer_setitem_code(self.rhs, code, c_op)
3613 # TODO: make sure overload is declared
3614 code.putln("%s %s= %s;" % (self.lhs.result(), c_op, self.rhs.result()))
3615 self.lhs.generate_subexpr_disposal_code(code)
3616 self.lhs.free_subexpr_temps(code)
3617 self.rhs.generate_disposal_code(code)
3618 self.rhs.free_temps(code)
3620 def annotate(self, code):
3621 self.lhs.annotate(code)
3622 self.rhs.annotate(code)
3624 def create_binop_node(self):
3626 return ExprNodes.binop_node(self.pos, self.operator, self.lhs, self.rhs)
3629 class PrintStatNode(StatNode):
3632 # arg_tuple TupleNode
3633 # stream ExprNode or None (stdout)
3634 # append_newline boolean
3636 child_attrs = ["arg_tuple", "stream"]
3638 def analyse_expressions(self, env):
3640 self.stream.analyse_expressions(env)
3641 self.stream = self.stream.coerce_to_pyobject(env)
3642 self.arg_tuple.analyse_expressions(env)
3643 self.arg_tuple = self.arg_tuple.coerce_to_pyobject(env)
3644 env.use_utility_code(printing_utility_code)
3645 if len(self.arg_tuple.args) == 1 and self.append_newline:
3646 env.use_utility_code(printing_one_utility_code)
3648 nogil_check = Node.gil_error
3649 gil_message = "Python print statement"
3651 def generate_execution_code(self, code):
3653 self.stream.generate_evaluation_code(code)
3654 stream_result = self.stream.py_result()
3657 if len(self.arg_tuple.args) == 1 and self.append_newline:
3658 arg = self.arg_tuple.args[0]
3659 arg.generate_evaluation_code(code)
3662 "if (__Pyx_PrintOne(%s, %s) < 0) %s" % (
3665 code.error_goto(self.pos)))
3666 arg.generate_disposal_code(code)
3667 arg.free_temps(code)
3669 self.arg_tuple.generate_evaluation_code(code)
3671 "if (__Pyx_Print(%s, %s, %d) < 0) %s" % (
3673 self.arg_tuple.py_result(),
3674 self.append_newline,
3675 code.error_goto(self.pos)))
3676 self.arg_tuple.generate_disposal_code(code)
3677 self.arg_tuple.free_temps(code)
3680 self.stream.generate_disposal_code(code)
3681 self.stream.free_temps(code)
3683 def generate_function_definitions(self, env, code):
3685 self.stream.generate_function_definitions(env, code)
3686 self.arg_tuple.generate_function_definitions(env, code)
3688 def annotate(self, code):
3690 self.stream.annotate(code)
3691 self.arg_tuple.annotate(code)
3694 class ExecStatNode(StatNode):
3699 child_attrs = ["args"]
3701 def analyse_expressions(self, env):
3702 for i, arg in enumerate(self.args):
3703 arg.analyse_expressions(env)
3704 arg = arg.coerce_to_pyobject(env)
3706 env.use_utility_code(Builtin.pyexec_utility_code)
3708 nogil_check = Node.gil_error
3709 gil_message = "Python exec statement"
3711 def generate_execution_code(self, code):
3713 for arg in self.args:
3714 arg.generate_evaluation_code(code)
3715 args.append( arg.py_result() )
3716 args = tuple(args + ['0', '0'][:3-len(args)])
3717 temp_result = code.funcstate.allocate_temp(PyrexTypes.py_object_type, manage_ref=True)
3718 code.putln("%s = __Pyx_PyRun(%s, %s, %s);" % (
3719 (temp_result,) + args))
3720 for arg in self.args:
3721 arg.generate_disposal_code(code)
3722 arg.free_temps(code)
3724 code.error_goto_if_null(temp_result, self.pos))
3725 code.put_gotref(temp_result)
3726 code.put_decref_clear(temp_result, py_object_type)
3727 code.funcstate.release_temp(temp_result)
3729 def annotate(self, code):
3730 for arg in self.args:
3734 class DelStatNode(StatNode):
3739 child_attrs = ["args"]
3741 def analyse_declarations(self, env):
3742 for arg in self.args:
3743 arg.analyse_target_declaration(env)
3745 def analyse_expressions(self, env):
3746 for arg in self.args:
3747 arg.analyse_target_expression(env, None)
3748 if arg.type.is_pyobject:
3750 elif arg.type.is_ptr and arg.type.base_type.is_cpp_class:
3752 elif arg.type.is_cpp_class:
3753 error(arg.pos, "Deletion of non-heap C++ object")
3755 error(arg.pos, "Deletion of non-Python, non-C++ object")
3756 #arg.release_target_temp(env)
3758 def nogil_check(self, env):
3759 for arg in self.args:
3760 if arg.type.is_pyobject:
3763 gil_message = "Deleting Python object"
3765 def generate_execution_code(self, code):
3766 for arg in self.args:
3767 if arg.type.is_pyobject:
3768 arg.generate_deletion_code(code)
3769 elif arg.type.is_ptr and arg.type.base_type.is_cpp_class:
3770 arg.generate_result_code(code)
3771 code.putln("delete %s;" % arg.result())
3772 # else error reported earlier
3774 def annotate(self, code):
3775 for arg in self.args:
3779 class PassStatNode(StatNode):
3784 def analyse_expressions(self, env):
3787 def generate_execution_code(self, code):
3791 class BreakStatNode(StatNode):
3795 def analyse_expressions(self, env):
3798 def generate_execution_code(self, code):
3799 if not code.break_label:
3800 error(self.pos, "break statement not inside loop")
3802 code.put_goto(code.break_label)
3805 class ContinueStatNode(StatNode):
3809 def analyse_expressions(self, env):
3812 def generate_execution_code(self, code):
3813 if code.funcstate.in_try_finally:
3814 error(self.pos, "continue statement inside try of try...finally")
3815 elif not code.continue_label:
3816 error(self.pos, "continue statement not inside loop")
3818 code.put_goto(code.continue_label)
3821 class ReturnStatNode(StatNode):
3824 # value ExprNode or None
3825 # return_type PyrexType
3827 child_attrs = ["value"]
3829 def analyse_expressions(self, env):
3830 return_type = env.return_type
3831 self.return_type = return_type
3833 error(self.pos, "Return not inside a function body")
3836 self.value.analyse_types(env)
3837 if return_type.is_void or return_type.is_returncode:
3838 error(self.value.pos,
3839 "Return with value in void function")
3841 self.value = self.value.coerce_to(env.return_type, env)
3843 if (not return_type.is_void
3844 and not return_type.is_pyobject
3845 and not return_type.is_returncode):
3846 error(self.pos, "Return value required")
3848 def nogil_check(self, env):
3849 if self.return_type.is_pyobject:
3852 gil_message = "Returning Python object"
3854 def generate_execution_code(self, code):
3855 code.mark_pos(self.pos)
3856 if not self.return_type:
3857 # error reported earlier
3859 if self.return_type.is_pyobject:
3860 code.put_xdecref(Naming.retval_cname,
3863 self.value.generate_evaluation_code(code)
3864 self.value.make_owned_reference(code)
3867 Naming.retval_cname,
3868 self.value.result_as(self.return_type)))
3869 self.value.generate_post_assignment_code(code)
3870 self.value.free_temps(code)
3872 if self.return_type.is_pyobject:
3873 code.put_init_to_py_none(Naming.retval_cname, self.return_type)
3874 elif self.return_type.is_returncode:
3877 Naming.retval_cname,
3878 self.return_type.default_value))
3879 for cname, type in code.funcstate.temps_holding_reference():
3880 code.put_decref_clear(cname, type)
3881 code.put_goto(code.return_label)
3883 def generate_function_definitions(self, env, code):
3884 if self.value is not None:
3885 self.value.generate_function_definitions(env, code)
3887 def annotate(self, code):
3889 self.value.annotate(code)
3892 class RaiseStatNode(StatNode):
3895 # exc_type ExprNode or None
3896 # exc_value ExprNode or None
3897 # exc_tb ExprNode or None
3899 child_attrs = ["exc_type", "exc_value", "exc_tb"]
3901 def analyse_expressions(self, env):
3903 self.exc_type.analyse_types(env)
3904 self.exc_type = self.exc_type.coerce_to_pyobject(env)
3906 self.exc_value.analyse_types(env)
3907 self.exc_value = self.exc_value.coerce_to_pyobject(env)
3909 self.exc_tb.analyse_types(env)
3910 self.exc_tb = self.exc_tb.coerce_to_pyobject(env)
3911 env.use_utility_code(raise_utility_code)
3913 nogil_check = Node.gil_error
3914 gil_message = "Raising exception"
3916 def generate_execution_code(self, code):
3918 self.exc_type.generate_evaluation_code(code)
3919 type_code = self.exc_type.py_result()
3923 self.exc_value.generate_evaluation_code(code)
3924 value_code = self.exc_value.py_result()
3928 self.exc_tb.generate_evaluation_code(code)
3929 tb_code = self.exc_tb.py_result()
3933 "__Pyx_Raise(%s, %s, %s);" % (
3937 for obj in (self.exc_type, self.exc_value, self.exc_tb):
3939 obj.generate_disposal_code(code)
3940 obj.free_temps(code)
3942 code.error_goto(self.pos))
3944 def generate_function_definitions(self, env, code):
3945 if self.exc_type is not None:
3946 self.exc_type.generate_function_definitions(env, code)
3947 if self.exc_value is not None:
3948 self.exc_value.generate_function_definitions(env, code)
3949 if self.exc_tb is not None:
3950 self.exc_tb.generate_function_definitions(env, code)
3952 def annotate(self, code):
3954 self.exc_type.annotate(code)
3956 self.exc_value.annotate(code)
3958 self.exc_tb.annotate(code)
3961 class ReraiseStatNode(StatNode):
3965 def analyse_expressions(self, env):
3966 env.use_utility_code(restore_exception_utility_code)
3968 nogil_check = Node.gil_error
3969 gil_message = "Raising exception"
3971 def generate_execution_code(self, code):
3972 vars = code.funcstate.exc_vars
3974 for varname in vars:
3975 code.put_giveref(varname)
3976 code.putln("__Pyx_ErrRestore(%s, %s, %s);" % tuple(vars))
3977 for varname in vars:
3978 code.put("%s = 0; " % varname)
3980 code.putln(code.error_goto(self.pos))
3982 error(self.pos, "Reraise not inside except clause")
3985 class AssertStatNode(StatNode):
3989 # value ExprNode or None
3991 child_attrs = ["cond", "value"]
3993 def analyse_expressions(self, env):
3994 self.cond = self.cond.analyse_boolean_expression(env)
3996 self.value.analyse_types(env)
3997 self.value = self.value.coerce_to_pyobject(env)
3999 nogil_check = Node.gil_error
4000 gil_message = "Raising exception"
4002 def generate_execution_code(self, code):
4003 code.putln("#ifndef CYTHON_WITHOUT_ASSERTIONS")
4004 self.cond.generate_evaluation_code(code)
4006 "if (unlikely(!%s)) {" %
4009 self.value.generate_evaluation_code(code)
4011 "PyErr_SetObject(PyExc_AssertionError, %s);" %
4012 self.value.py_result())
4013 self.value.generate_disposal_code(code)
4014 self.value.free_temps(code)
4017 "PyErr_SetNone(PyExc_AssertionError);")
4019 code.error_goto(self.pos))
4022 self.cond.generate_disposal_code(code)
4023 self.cond.free_temps(code)
4024 code.putln("#endif")
4026 def generate_function_definitions(self, env, code):
4027 self.cond.generate_function_definitions(env, code)
4028 if self.value is not None:
4029 self.value.generate_function_definitions(env, code)
4031 def annotate(self, code):
4032 self.cond.annotate(code)
4034 self.value.annotate(code)
4037 class IfStatNode(StatNode):
4040 # if_clauses [IfClauseNode]
4041 # else_clause StatNode or None
4043 child_attrs = ["if_clauses", "else_clause"]
4045 def analyse_control_flow(self, env):
4046 env.start_branching(self.pos)
4047 for if_clause in self.if_clauses:
4048 if_clause.analyse_control_flow(env)
4049 env.next_branch(if_clause.end_pos())
4050 if self.else_clause:
4051 self.else_clause.analyse_control_flow(env)
4052 env.finish_branching(self.end_pos())
4054 def analyse_declarations(self, env):
4055 for if_clause in self.if_clauses:
4056 if_clause.analyse_declarations(env)
4057 if self.else_clause:
4058 self.else_clause.analyse_declarations(env)
4060 def analyse_expressions(self, env):
4061 for if_clause in self.if_clauses:
4062 if_clause.analyse_expressions(env)
4063 if self.else_clause:
4064 self.else_clause.analyse_expressions(env)
4066 def generate_execution_code(self, code):
4067 code.mark_pos(self.pos)
4068 end_label = code.new_label()
4069 for if_clause in self.if_clauses:
4070 if_clause.generate_execution_code(code, end_label)
4071 if self.else_clause:
4072 code.putln("/*else*/ {")
4073 self.else_clause.generate_execution_code(code)
4075 code.put_label(end_label)
4077 def generate_function_definitions(self, env, code):
4078 for clause in self.if_clauses:
4079 clause.generate_function_definitions(env, code)
4080 if self.else_clause is not None:
4081 self.else_clause.generate_function_definitions(env, code)
4083 def annotate(self, code):
4084 for if_clause in self.if_clauses:
4085 if_clause.annotate(code)
4086 if self.else_clause:
4087 self.else_clause.annotate(code)
4090 class IfClauseNode(Node):
4091 # if or elif clause in an if statement
4093 # condition ExprNode
4096 child_attrs = ["condition", "body"]
4098 def analyse_control_flow(self, env):
4099 self.body.analyse_control_flow(env)
4101 def analyse_declarations(self, env):
4102 self.body.analyse_declarations(env)
4104 def analyse_expressions(self, env):
4106 self.condition.analyse_temp_boolean_expression(env)
4107 self.body.analyse_expressions(env)
4109 def get_constant_condition_result(self):
4110 if self.condition.has_constant_result():
4111 return bool(self.condition.constant_result)
4115 def generate_execution_code(self, code, end_label):
4116 self.condition.generate_evaluation_code(code)
4119 self.condition.result())
4120 self.condition.generate_disposal_code(code)
4121 self.condition.free_temps(code)
4122 self.body.generate_execution_code(code)
4123 code.put_goto(end_label)
4126 def generate_function_definitions(self, env, code):
4127 self.condition.generate_function_definitions(env, code)
4128 self.body.generate_function_definitions(env, code)
4130 def annotate(self, code):
4131 self.condition.annotate(code)
4132 self.body.annotate(code)
4135 class SwitchCaseNode(StatNode):
4136 # Generated in the optimization of an if-elif-else node
4138 # conditions [ExprNode]
4141 child_attrs = ['conditions', 'body']
4143 def generate_execution_code(self, code):
4144 for cond in self.conditions:
4145 code.mark_pos(cond.pos)
4146 cond.generate_evaluation_code(code)
4147 code.putln("case %s:" % cond.result())
4148 self.body.generate_execution_code(code)
4149 code.putln("break;")
4151 def generate_function_definitions(self, env, code):
4152 for cond in self.conditions:
4153 cond.generate_function_definitions(env, code)
4154 self.body.generate_function_definitions(env, code)
4156 def annotate(self, code):
4157 for cond in self.conditions:
4159 self.body.annotate(code)
4161 class SwitchStatNode(StatNode):
4162 # Generated in the optimization of an if-elif-else node
4165 # cases [SwitchCaseNode]
4166 # else_clause StatNode or None
4168 child_attrs = ['test', 'cases', 'else_clause']
4170 def generate_execution_code(self, code):
4171 self.test.generate_evaluation_code(code)
4172 code.putln("switch (%s) {" % self.test.result())
4173 for case in self.cases:
4174 case.generate_execution_code(code)
4175 if self.else_clause is not None:
4176 code.putln("default:")
4177 self.else_clause.generate_execution_code(code)
4178 code.putln("break;")
4181 def generate_function_definitions(self, env, code):
4182 self.test.generate_function_definitions(env, code)
4183 for case in self.cases:
4184 case.generate_function_definitions(env, code)
4185 if self.else_clause is not None:
4186 self.else_clause.generate_function_definitions(env, code)
4188 def annotate(self, code):
4189 self.test.annotate(code)
4190 for case in self.cases:
4192 if self.else_clause is not None:
4193 self.else_clause.annotate(code)
4195 class LoopNode(object):
4197 def analyse_control_flow(self, env):
4198 env.start_branching(self.pos)
4199 self.body.analyse_control_flow(env)
4200 env.next_branch(self.body.end_pos())
4201 if self.else_clause:
4202 self.else_clause.analyse_control_flow(env)
4203 env.finish_branching(self.end_pos())
4206 class WhileStatNode(LoopNode, StatNode):
4209 # condition ExprNode
4211 # else_clause StatNode
4213 child_attrs = ["condition", "body", "else_clause"]
4215 def analyse_declarations(self, env):
4216 self.body.analyse_declarations(env)
4217 if self.else_clause:
4218 self.else_clause.analyse_declarations(env)
4220 def analyse_expressions(self, env):
4222 self.condition.analyse_temp_boolean_expression(env)
4223 self.body.analyse_expressions(env)
4224 if self.else_clause:
4225 self.else_clause.analyse_expressions(env)
4227 def generate_execution_code(self, code):
4228 old_loop_labels = code.new_loop_labels()
4231 self.condition.generate_evaluation_code(code)
4232 self.condition.generate_disposal_code(code)
4235 self.condition.result())
4236 self.condition.free_temps(code)
4237 self.body.generate_execution_code(code)
4238 code.put_label(code.continue_label)
4240 break_label = code.break_label
4241 code.set_loop_labels(old_loop_labels)
4242 if self.else_clause:
4243 code.putln("/*else*/ {")
4244 self.else_clause.generate_execution_code(code)
4246 code.put_label(break_label)
4248 def generate_function_definitions(self, env, code):
4249 self.condition.generate_function_definitions(env, code)
4250 self.body.generate_function_definitions(env, code)
4251 if self.else_clause is not None:
4252 self.else_clause.generate_function_definitions(env, code)
4254 def annotate(self, code):
4255 self.condition.annotate(code)
4256 self.body.annotate(code)
4257 if self.else_clause:
4258 self.else_clause.annotate(code)
4261 def ForStatNode(pos, **kw):
4262 if 'iterator' in kw:
4263 return ForInStatNode(pos, **kw)
4265 return ForFromStatNode(pos, **kw)
4267 class ForInStatNode(LoopNode, StatNode):
4271 # iterator IteratorNode
4273 # else_clause StatNode
4274 # item NextNode used internally
4276 child_attrs = ["target", "iterator", "body", "else_clause"]
4279 def analyse_declarations(self, env):
4280 self.target.analyse_target_declaration(env)
4281 self.body.analyse_declarations(env)
4282 if self.else_clause:
4283 self.else_clause.analyse_declarations(env)
4285 def analyse_expressions(self, env):
4287 self.target.analyse_target_types(env)
4288 self.iterator.analyse_expressions(env)
4289 self.item = ExprNodes.NextNode(self.iterator, env)
4290 self.item = self.item.coerce_to(self.target.type, env)
4291 self.body.analyse_expressions(env)
4292 if self.else_clause:
4293 self.else_clause.analyse_expressions(env)
4295 def generate_execution_code(self, code):
4296 old_loop_labels = code.new_loop_labels()
4297 self.iterator.allocate_counter_temp(code)
4298 self.iterator.generate_evaluation_code(code)
4301 self.item.generate_evaluation_code(code)
4302 self.target.generate_assignment_code(self.item, code)
4303 self.body.generate_execution_code(code)
4304 code.put_label(code.continue_label)
4307 break_label = code.break_label
4308 code.set_loop_labels(old_loop_labels)
4310 if self.else_clause:
4311 # in nested loops, the 'else' block can contain a
4312 # 'continue' statement for the outer loop, but we may need
4313 # to generate cleanup code before taking that path, so we
4315 orig_continue_label = code.continue_label
4316 code.continue_label = code.new_label('outer_continue')
4318 code.putln("/*else*/ {")
4319 self.else_clause.generate_execution_code(code)
4322 if code.label_used(code.continue_label):
4323 code.put_goto(break_label)
4324 code.put_label(code.continue_label)
4325 self.iterator.generate_disposal_code(code)
4326 code.put_goto(orig_continue_label)
4327 code.set_loop_labels(old_loop_labels)
4329 if code.label_used(break_label):
4330 code.put_label(break_label)
4331 self.iterator.release_counter_temp(code)
4332 self.iterator.generate_disposal_code(code)
4333 self.iterator.free_temps(code)
4335 def generate_function_definitions(self, env, code):
4336 self.target.generate_function_definitions(env, code)
4337 self.iterator.generate_function_definitions(env, code)
4338 self.body.generate_function_definitions(env, code)
4339 if self.else_clause is not None:
4340 self.else_clause.generate_function_definitions(env, code)
4342 def annotate(self, code):
4343 self.target.annotate(code)
4344 self.iterator.annotate(code)
4345 self.body.annotate(code)
4346 if self.else_clause:
4347 self.else_clause.annotate(code)
4348 self.item.annotate(code)
4351 class ForFromStatNode(LoopNode, StatNode):
4352 # for name from expr rel name rel expr
4359 # step ExprNode or None
4361 # else_clause StatNode or None
4367 # loopvar_node ExprNode (usually a NameNode or temp node)
4368 # py_loopvar_node PyTempNode or None
4369 child_attrs = ["target", "bound1", "bound2", "step", "body", "else_clause"]
4371 is_py_target = False
4373 py_loopvar_node = None
4376 gil_message = "For-loop using object bounds or target"
4378 def nogil_check(self, env):
4379 for x in (self.target, self.bound1, self.bound2):
4380 if x.type.is_pyobject:
4383 def analyse_declarations(self, env):
4384 self.target.analyse_target_declaration(env)
4385 self.body.analyse_declarations(env)
4386 if self.else_clause:
4387 self.else_clause.analyse_declarations(env)
4389 def analyse_expressions(self, env):
4391 self.target.analyse_target_types(env)
4392 self.bound1.analyse_types(env)
4393 self.bound2.analyse_types(env)
4394 if self.step is not None:
4395 if isinstance(self.step, ExprNodes.UnaryMinusNode):
4396 warning(self.step.pos, "Probable infinite loop in for-from-by statment. Consider switching the directions of the relations.", 2)
4397 self.step.analyse_types(env)
4399 target_type = self.target.type
4400 if self.target.type.is_numeric:
4401 loop_type = self.target.type
4403 loop_type = PyrexTypes.c_int_type
4404 if not self.bound1.type.is_pyobject:
4405 loop_type = PyrexTypes.widest_numeric_type(loop_type, self.bound1.type)
4406 if not self.bound2.type.is_pyobject:
4407 loop_type = PyrexTypes.widest_numeric_type(loop_type, self.bound2.type)
4408 if self.step is not None and not self.step.type.is_pyobject:
4409 loop_type = PyrexTypes.widest_numeric_type(loop_type, self.step.type)
4410 self.bound1 = self.bound1.coerce_to(loop_type, env)
4411 self.bound2 = self.bound2.coerce_to(loop_type, env)
4412 if not self.bound2.is_literal:
4413 self.bound2 = self.bound2.coerce_to_temp(env)
4414 if self.step is not None:
4415 self.step = self.step.coerce_to(loop_type, env)
4416 if not self.step.is_literal:
4417 self.step = self.step.coerce_to_temp(env)
4419 target_type = self.target.type
4420 if not (target_type.is_pyobject or target_type.is_numeric):
4421 error(self.target.pos,
4422 "for-from loop variable must be c numeric type or Python object")
4423 if target_type.is_numeric:
4424 self.is_py_target = False
4425 if isinstance(self.target, ExprNodes.IndexNode) and self.target.is_buffer_access:
4426 raise error(self.pos, "Buffer indexing not allowed as for loop target.")
4427 self.loopvar_node = self.target
4428 self.py_loopvar_node = None
4430 self.is_py_target = True
4431 c_loopvar_node = ExprNodes.TempNode(self.pos, loop_type, env)
4432 self.loopvar_node = c_loopvar_node
4433 self.py_loopvar_node = \
4434 ExprNodes.CloneNode(c_loopvar_node).coerce_to_pyobject(env)
4435 self.body.analyse_expressions(env)
4436 if self.else_clause:
4437 self.else_clause.analyse_expressions(env)
4439 def generate_execution_code(self, code):
4440 old_loop_labels = code.new_loop_labels()
4441 from_range = self.from_range
4442 self.bound1.generate_evaluation_code(code)
4443 self.bound2.generate_evaluation_code(code)
4444 offset, incop = self.relation_table[self.relation1]
4445 if self.step is not None:
4446 self.step.generate_evaluation_code(code)
4447 step = self.step.result()
4448 incop = "%s=%s" % (incop[0], step)
4450 if isinstance(self.loopvar_node, ExprNodes.TempNode):
4451 self.loopvar_node.allocate(code)
4452 if isinstance(self.py_loopvar_node, ExprNodes.TempNode):
4453 self.py_loopvar_node.allocate(code)
4455 loopvar_name = code.funcstate.allocate_temp(self.target.type, False)
4457 loopvar_name = self.loopvar_node.result()
4459 "for (%s = %s%s; %s %s %s; %s%s) {" % (
4461 self.bound1.result(), offset,
4462 loopvar_name, self.relation2, self.bound2.result(),
4463 loopvar_name, incop))
4464 if self.py_loopvar_node:
4465 self.py_loopvar_node.generate_evaluation_code(code)
4466 self.target.generate_assignment_code(self.py_loopvar_node, code)
4468 code.putln("%s = %s;" % (
4469 self.target.result(), loopvar_name))
4470 self.body.generate_execution_code(code)
4471 code.put_label(code.continue_label)
4472 if self.py_loopvar_node:
4473 # This mess is to make for..from loops with python targets behave
4474 # exactly like those with C targets with regards to re-assignment
4475 # of the loop variable.
4477 if self.target.entry.is_pyglobal:
4478 # We know target is a NameNode, this is the only ugly case.
4479 target_node = ExprNodes.PyTempNode(self.target.pos, None)
4480 target_node.allocate(code)
4481 interned_cname = code.intern_identifier(self.target.entry.name)
4482 code.globalstate.use_utility_code(ExprNodes.get_name_interned_utility_code)
4483 code.putln("%s = __Pyx_GetName(%s, %s); %s" % (
4484 target_node.result(),
4485 Naming.module_cname,
4487 code.error_goto_if_null(target_node.result(), self.target.pos)))
4488 code.put_gotref(target_node.result())
4490 target_node = self.target
4491 from_py_node = ExprNodes.CoerceFromPyTypeNode(self.loopvar_node.type, target_node, None)
4492 from_py_node.temp_code = loopvar_name
4493 from_py_node.generate_result_code(code)
4494 if self.target.entry.is_pyglobal:
4495 code.put_decref(target_node.result(), target_node.type)
4496 target_node.release(code)
4498 if self.py_loopvar_node:
4499 # This is potentially wasteful, but we don't want the semantics to
4500 # depend on whether or not the loop is a python type.
4501 self.py_loopvar_node.generate_evaluation_code(code)
4502 self.target.generate_assignment_code(self.py_loopvar_node, code)
4504 code.funcstate.release_temp(loopvar_name)
4505 break_label = code.break_label
4506 code.set_loop_labels(old_loop_labels)
4507 if self.else_clause:
4508 code.putln("/*else*/ {")
4509 self.else_clause.generate_execution_code(code)
4511 code.put_label(break_label)
4512 self.bound1.generate_disposal_code(code)
4513 self.bound1.free_temps(code)
4514 self.bound2.generate_disposal_code(code)
4515 self.bound2.free_temps(code)
4516 if isinstance(self.loopvar_node, ExprNodes.TempNode):
4517 self.loopvar_node.release(code)
4518 if isinstance(self.py_loopvar_node, ExprNodes.TempNode):
4519 self.py_loopvar_node.release(code)
4520 if self.step is not None:
4521 self.step.generate_disposal_code(code)
4522 self.step.free_temps(code)
4525 # {relop : (initial offset, increment op)}
4532 def generate_function_definitions(self, env, code):
4533 self.target.generate_function_definitions(env, code)
4534 self.bound1.generate_function_definitions(env, code)
4535 self.bound2.generate_function_definitions(env, code)
4536 if self.step is not None:
4537 self.step.generate_function_definitions(env, code)
4538 self.body.generate_function_definitions(env, code)
4539 if self.else_clause is not None:
4540 self.else_clause.generate_function_definitions(env, code)
4542 def annotate(self, code):
4543 self.target.annotate(code)
4544 self.bound1.annotate(code)
4545 self.bound2.annotate(code)
4547 self.step.annotate(code)
4548 self.body.annotate(code)
4549 if self.else_clause:
4550 self.else_clause.annotate(code)
4553 class WithStatNode(StatNode):
4555 Represents a Python with statement.
4557 This is only used at parse tree level; and is not present in
4558 analysis or generation phases.
4560 # manager The with statement manager object
4561 # target Node (lhs expression)
4563 child_attrs = ["manager", "target", "body"]
4565 class TryExceptStatNode(StatNode):
4566 # try .. except statement
4569 # except_clauses [ExceptClauseNode]
4570 # else_clause StatNode or None
4572 child_attrs = ["body", "except_clauses", "else_clause"]
4574 def analyse_control_flow(self, env):
4575 env.start_branching(self.pos)
4576 self.body.analyse_control_flow(env)
4577 successful_try = env.control_flow # grab this for later
4578 env.next_branch(self.body.end_pos())
4579 env.finish_branching(self.body.end_pos())
4581 env.start_branching(self.except_clauses[0].pos)
4582 for except_clause in self.except_clauses:
4583 except_clause.analyse_control_flow(env)
4584 env.next_branch(except_clause.end_pos())
4586 # the else cause it executed only when the try clause finishes
4587 env.control_flow.incoming = successful_try
4588 if self.else_clause:
4589 self.else_clause.analyse_control_flow(env)
4590 env.finish_branching(self.end_pos())
4592 def analyse_declarations(self, env):
4593 self.body.analyse_declarations(env)
4594 for except_clause in self.except_clauses:
4595 except_clause.analyse_declarations(env)
4596 if self.else_clause:
4597 self.else_clause.analyse_declarations(env)
4598 env.use_utility_code(reset_exception_utility_code)
4600 def analyse_expressions(self, env):
4601 self.body.analyse_expressions(env)
4602 default_clause_seen = 0
4603 for except_clause in self.except_clauses:
4604 except_clause.analyse_expressions(env)
4605 if default_clause_seen:
4606 error(except_clause.pos, "default 'except:' must be last")
4607 if not except_clause.pattern:
4608 default_clause_seen = 1
4609 self.has_default_clause = default_clause_seen
4610 if self.else_clause:
4611 self.else_clause.analyse_expressions(env)
4613 nogil_check = Node.gil_error
4614 gil_message = "Try-except statement"
4616 def generate_execution_code(self, code):
4617 old_return_label = code.return_label
4618 old_break_label = code.break_label
4619 old_continue_label = code.continue_label
4620 old_error_label = code.new_error_label()
4621 our_error_label = code.error_label
4622 except_end_label = code.new_label('exception_handled')
4623 except_error_label = code.new_label('except_error')
4624 except_return_label = code.new_label('except_return')
4625 try_return_label = code.new_label('try_return')
4626 try_break_label = code.new_label('try_break')
4627 try_continue_label = code.new_label('try_continue')
4628 try_end_label = code.new_label('try_end')
4631 code.putln("PyObject %s;" %
4632 ', '.join(['*%s' % var for var in Naming.exc_save_vars]))
4633 code.putln("__Pyx_ExceptionSave(%s);" %
4634 ', '.join(['&%s' % var for var in Naming.exc_save_vars]))
4635 for var in Naming.exc_save_vars:
4636 code.put_xgotref(var)
4639 code.return_label = try_return_label
4640 code.break_label = try_break_label
4641 code.continue_label = try_continue_label
4642 self.body.generate_execution_code(code)
4645 temps_to_clean_up = code.funcstate.all_free_managed_temps()
4646 code.error_label = except_error_label
4647 code.return_label = except_return_label
4648 if self.else_clause:
4651 self.else_clause.generate_execution_code(code)
4654 for var in Naming.exc_save_vars:
4655 code.put_xdecref_clear(var, py_object_type)
4656 code.put_goto(try_end_label)
4657 if code.label_used(try_return_label):
4658 code.put_label(try_return_label)
4659 for var in Naming.exc_save_vars: code.put_xgiveref(var)
4660 code.putln("__Pyx_ExceptionReset(%s);" %
4661 ', '.join(Naming.exc_save_vars))
4662 code.put_goto(old_return_label)
4663 code.put_label(our_error_label)
4664 for temp_name, type in temps_to_clean_up:
4665 code.put_xdecref_clear(temp_name, type)
4666 for except_clause in self.except_clauses:
4667 except_clause.generate_handling_code(code, except_end_label)
4669 error_label_used = code.label_used(except_error_label)
4670 if error_label_used or not self.has_default_clause:
4671 if error_label_used:
4672 code.put_label(except_error_label)
4673 for var in Naming.exc_save_vars: code.put_xgiveref(var)
4674 code.putln("__Pyx_ExceptionReset(%s);" %
4675 ', '.join(Naming.exc_save_vars))
4676 code.put_goto(old_error_label)
4678 for exit_label, old_label in zip(
4679 [try_break_label, try_continue_label, except_return_label],
4680 [old_break_label, old_continue_label, old_return_label]):
4682 if code.label_used(exit_label):
4683 code.put_label(exit_label)
4684 for var in Naming.exc_save_vars: code.put_xgiveref(var)
4685 code.putln("__Pyx_ExceptionReset(%s);" %
4686 ', '.join(Naming.exc_save_vars))
4687 code.put_goto(old_label)
4689 if code.label_used(except_end_label):
4690 code.put_label(except_end_label)
4691 for var in Naming.exc_save_vars: code.put_xgiveref(var)
4692 code.putln("__Pyx_ExceptionReset(%s);" %
4693 ', '.join(Naming.exc_save_vars))
4694 code.put_label(try_end_label)
4697 code.return_label = old_return_label
4698 code.break_label = old_break_label
4699 code.continue_label = old_continue_label
4700 code.error_label = old_error_label
4702 def generate_function_definitions(self, env, code):
4703 self.body.generate_function_definitions(env, code)
4704 for except_clause in self.except_clauses:
4705 except_clause.generate_function_definitions(env, code)
4706 if self.else_clause is not None:
4707 self.else_clause.generate_function_definitions(env, code)
4709 def annotate(self, code):
4710 self.body.annotate(code)
4711 for except_node in self.except_clauses:
4712 except_node.annotate(code)
4713 if self.else_clause:
4714 self.else_clause.annotate(code)
4717 class ExceptClauseNode(Node):
4718 # Part of try ... except statement.
4720 # pattern [ExprNode]
4721 # target ExprNode or None
4723 # excinfo_target NameNode or None optional target for exception info
4724 # match_flag string result of exception match
4725 # exc_value ExcValueNode used internally
4726 # function_name string qualified name of enclosing function
4727 # exc_vars (string * 3) local exception variables
4729 # excinfo_target is never set by the parser, but can be set by a transform
4730 # in order to extract more extensive information about the exception as a
4731 # sys.exc_info()-style tuple into a target variable
4733 child_attrs = ["pattern", "target", "body", "exc_value", "excinfo_target"]
4736 excinfo_target = None
4738 def analyse_declarations(self, env):
4740 self.target.analyse_target_declaration(env)
4741 if self.excinfo_target is not None:
4742 self.excinfo_target.analyse_target_declaration(env)
4743 self.body.analyse_declarations(env)
4745 def analyse_expressions(self, env):
4747 genv = env.global_scope()
4748 self.function_name = env.qualified_name
4750 # normalise/unpack self.pattern into a list
4751 for i, pattern in enumerate(self.pattern):
4752 pattern.analyse_expressions(env)
4753 self.pattern[i] = pattern.coerce_to_pyobject(env)
4756 self.exc_value = ExprNodes.ExcValueNode(self.pos, env)
4757 self.target.analyse_target_expression(env, self.exc_value)
4758 if self.excinfo_target is not None:
4760 self.excinfo_tuple = ExprNodes.TupleNode(pos=self.pos, args=[
4761 ExprNodes.ExcValueNode(pos=self.pos, env=env) for x in range(3)])
4762 self.excinfo_tuple.analyse_expressions(env)
4763 self.excinfo_target.analyse_target_expression(env, self.excinfo_tuple)
4765 self.body.analyse_expressions(env)
4767 def generate_handling_code(self, code, end_label):
4768 code.mark_pos(self.pos)
4771 for pattern in self.pattern:
4772 pattern.generate_evaluation_code(code)
4773 exc_tests.append("PyErr_ExceptionMatches(%s)" % pattern.py_result())
4775 match_flag = code.funcstate.allocate_temp(PyrexTypes.c_int_type, False)
4777 "%s = %s;" % (match_flag, ' || '.join(exc_tests)))
4778 for pattern in self.pattern:
4779 pattern.generate_disposal_code(code)
4780 pattern.free_temps(code)
4784 code.funcstate.release_temp(match_flag)
4786 code.putln("/*except:*/ {")
4788 if not getattr(self.body, 'stats', True) and \
4789 self.excinfo_target is None and self.target is None:
4790 # most simple case: no exception variable, empty body (pass)
4791 # => reset the exception state, done
4792 code.putln("PyErr_Restore(0,0,0);")
4793 code.put_goto(end_label)
4797 exc_vars = [code.funcstate.allocate_temp(py_object_type,
4800 code.putln('__Pyx_AddTraceback("%s");' % self.function_name)
4801 # We always have to fetch the exception value even if
4802 # there is no target, because this also normalises the
4803 # exception and stores it in the thread state.
4804 code.globalstate.use_utility_code(get_exception_utility_code)
4805 exc_args = "&%s, &%s, &%s" % tuple(exc_vars)
4806 code.putln("if (__Pyx_GetException(%s) < 0) %s" % (exc_args,
4807 code.error_goto(self.pos)))
4811 self.exc_value.set_var(exc_vars[1])
4812 self.exc_value.generate_evaluation_code(code)
4813 self.target.generate_assignment_code(self.exc_value, code)
4814 if self.excinfo_target is not None:
4815 for tempvar, node in zip(exc_vars, self.excinfo_tuple.args):
4816 node.set_var(tempvar)
4817 self.excinfo_tuple.generate_evaluation_code(code)
4818 self.excinfo_target.generate_assignment_code(self.excinfo_tuple, code)
4820 old_break_label, old_continue_label = code.break_label, code.continue_label
4821 code.break_label = code.new_label('except_break')
4822 code.continue_label = code.new_label('except_continue')
4824 old_exc_vars = code.funcstate.exc_vars
4825 code.funcstate.exc_vars = exc_vars
4826 self.body.generate_execution_code(code)
4827 code.funcstate.exc_vars = old_exc_vars
4828 for var in exc_vars:
4829 code.putln("__Pyx_DECREF(%s); %s = 0;" % (var, var))
4830 code.put_goto(end_label)
4832 if code.label_used(code.break_label):
4833 code.put_label(code.break_label)
4834 for var in exc_vars:
4835 code.putln("__Pyx_DECREF(%s); %s = 0;" % (var, var))
4836 code.put_goto(old_break_label)
4837 code.break_label = old_break_label
4839 if code.label_used(code.continue_label):
4840 code.put_label(code.continue_label)
4841 for var in exc_vars:
4842 code.putln("__Pyx_DECREF(%s); %s = 0;" % (var, var))
4843 code.put_goto(old_continue_label)
4844 code.continue_label = old_continue_label
4846 for temp in exc_vars:
4847 code.funcstate.release_temp(temp)
4852 def generate_function_definitions(self, env, code):
4853 if self.target is not None:
4854 self.target.generate_function_definitions(env, code)
4855 self.body.generate_function_definitions(env, code)
4857 def annotate(self, code):
4859 for pattern in self.pattern:
4860 pattern.annotate(code)
4862 self.target.annotate(code)
4863 self.body.annotate(code)
4866 class TryFinallyStatNode(StatNode):
4867 # try ... finally statement
4870 # finally_clause StatNode
4872 # The plan is that we funnel all continue, break
4873 # return and error gotos into the beginning of the
4874 # finally block, setting a variable to remember which
4875 # one we're doing. At the end of the finally block, we
4876 # switch on the variable to figure out where to go.
4877 # In addition, if we're doing an error, we save the
4878 # exception on entry to the finally block and restore
4881 child_attrs = ["body", "finally_clause"]
4883 preserve_exception = 1
4885 disallow_continue_in_try_finally = 0
4886 # There doesn't seem to be any point in disallowing
4887 # continue in the try block, since we have no problem
4890 def create_analysed(pos, env, body, finally_clause):
4891 node = TryFinallyStatNode(pos, body=body, finally_clause=finally_clause)
4893 create_analysed = staticmethod(create_analysed)
4895 def analyse_control_flow(self, env):
4896 env.start_branching(self.pos)
4897 self.body.analyse_control_flow(env)
4898 env.next_branch(self.body.end_pos())
4899 env.finish_branching(self.body.end_pos())
4900 self.finally_clause.analyse_control_flow(env)
4902 def analyse_declarations(self, env):
4903 self.body.analyse_declarations(env)
4904 self.finally_clause.analyse_declarations(env)
4906 def analyse_expressions(self, env):
4907 self.body.analyse_expressions(env)
4908 self.finally_clause.analyse_expressions(env)
4910 nogil_check = Node.gil_error
4911 gil_message = "Try-finally statement"
4913 def generate_execution_code(self, code):
4914 old_error_label = code.error_label
4915 old_labels = code.all_new_labels()
4916 new_labels = code.get_all_labels()
4917 new_error_label = code.error_label
4918 catch_label = code.new_label()
4921 if self.disallow_continue_in_try_finally:
4922 was_in_try_finally = code.funcstate.in_try_finally
4923 code.funcstate.in_try_finally = 1
4924 self.body.generate_execution_code(code)
4925 if self.disallow_continue_in_try_finally:
4926 code.funcstate.in_try_finally = was_in_try_finally
4929 temps_to_clean_up = code.funcstate.all_free_managed_temps()
4930 code.mark_pos(self.finally_clause.pos)
4934 error_label_used = 0
4935 for i, new_label in enumerate(new_labels):
4936 if new_label in code.labels_used:
4937 cases_used.append(i)
4938 if new_label == new_error_label:
4939 error_label_used = 1
4940 error_label_case = i
4944 if error_label_used and self.preserve_exception:
4946 "PyObject *%s, *%s, *%s;" % Naming.exc_vars)
4948 "int %s;" % Naming.exc_lineno_name)
4949 exc_var_init_zero = ''.join(["%s = 0; " % var for var in Naming.exc_vars])
4950 exc_var_init_zero += '%s = 0;' % Naming.exc_lineno_name
4951 code.putln(exc_var_init_zero)
4953 exc_var_init_zero = None
4954 code.use_label(catch_label)
4956 "__pyx_why = 0; goto %s;" % catch_label)
4957 for i in cases_used:
4958 new_label = new_labels[i]
4959 #if new_label and new_label != "<try>":
4960 if new_label == new_error_label and self.preserve_exception:
4961 self.put_error_catcher(code,
4962 new_error_label, i+1, catch_label, temps_to_clean_up)
4964 code.put('%s: ' % new_label)
4965 if exc_var_init_zero:
4966 code.putln(exc_var_init_zero)
4967 code.putln("__pyx_why = %s; goto %s;" % (
4970 code.put_label(catch_label)
4971 code.set_all_labels(old_labels)
4972 if error_label_used:
4973 code.new_error_label()
4974 finally_error_label = code.error_label
4975 self.finally_clause.generate_execution_code(code)
4976 if error_label_used:
4977 if finally_error_label in code.labels_used and self.preserve_exception:
4978 over_label = code.new_label()
4979 code.put_goto(over_label);
4980 code.put_label(finally_error_label)
4981 code.putln("if (__pyx_why == %d) {" % (error_label_case + 1))
4982 for var in Naming.exc_vars:
4983 code.putln("Py_XDECREF(%s);" % var)
4985 code.put_goto(old_error_label)
4986 code.put_label(over_label)
4987 code.error_label = old_error_label
4990 "switch (__pyx_why) {")
4991 for i in cases_used:
4992 old_label = old_labels[i]
4993 if old_label == old_error_label and self.preserve_exception:
4994 self.put_error_uncatcher(code, i+1, old_error_label)
4996 code.use_label(old_label)
4998 "case %s: goto %s;" % (
5006 def generate_function_definitions(self, env, code):
5007 self.body.generate_function_definitions(env, code)
5008 self.finally_clause.generate_function_definitions(env, code)
5010 def put_error_catcher(self, code, error_label, i, catch_label, temps_to_clean_up):
5011 code.globalstate.use_utility_code(restore_exception_utility_code)
5018 for temp_name, type in temps_to_clean_up:
5019 code.put_xdecref_clear(temp_name, type)
5021 "__Pyx_ErrFetch(&%s, &%s, &%s);" %
5025 Naming.exc_lineno_name, Naming.lineno_cname))
5026 code.put_goto(catch_label)
5029 def put_error_uncatcher(self, code, i, error_label):
5030 code.globalstate.use_utility_code(restore_exception_utility_code)
5035 "__Pyx_ErrRestore(%s, %s, %s);" %
5039 Naming.lineno_cname, Naming.exc_lineno_name))
5040 for var in Naming.exc_vars:
5044 code.put_goto(error_label)
5048 def annotate(self, code):
5049 self.body.annotate(code)
5050 self.finally_clause.annotate(code)
5053 class GILStatNode(TryFinallyStatNode):
5054 # 'with gil' or 'with nogil' statement
5056 # state string 'gil' or 'nogil'
5060 preserve_exception = 0
5062 def __init__(self, pos, state, body):
5064 TryFinallyStatNode.__init__(self, pos,
5066 finally_clause = GILExitNode(pos, state = state))
5068 def analyse_expressions(self, env):
5069 env.use_utility_code(force_init_threads_utility_code)
5070 was_nogil = env.nogil
5072 TryFinallyStatNode.analyse_expressions(self, env)
5073 env.nogil = was_nogil
5077 def generate_execution_code(self, code):
5078 code.mark_pos(self.pos)
5080 if self.state == 'gil':
5081 code.putln("#ifdef WITH_THREAD")
5082 code.putln("PyGILState_STATE _save = PyGILState_Ensure();")
5083 code.putln("#endif")
5085 code.putln("#ifdef WITH_THREAD")
5086 code.putln("PyThreadState *_save;")
5087 code.putln("#endif")
5088 code.putln("Py_UNBLOCK_THREADS")
5089 TryFinallyStatNode.generate_execution_code(self, code)
5093 class GILExitNode(StatNode):
5094 # Used as the 'finally' block in a GILStatNode
5096 # state string 'gil' or 'nogil'
5100 def analyse_expressions(self, env):
5103 def generate_execution_code(self, code):
5104 if self.state == 'gil':
5105 code.putln("#ifdef WITH_THREAD")
5106 code.putln("PyGILState_Release(_save);")
5107 code.putln("#endif")
5109 code.putln("Py_BLOCK_THREADS")
5112 class CImportStatNode(StatNode):
5115 # module_name string Qualified name of module being imported
5116 # as_name string or None Name specified in "as" clause, if any
5120 def analyse_declarations(self, env):
5121 if not env.is_module_scope:
5122 error(self.pos, "cimport only allowed at module level")
5124 module_scope = env.find_module(self.module_name, self.pos)
5125 if "." in self.module_name:
5126 names = [EncodedString(name) for name in self.module_name.split(".")]
5128 top_module_scope = env.context.find_submodule(top_name)
5129 module_scope = top_module_scope
5130 for name in names[1:]:
5131 submodule_scope = module_scope.find_submodule(name)
5132 module_scope.declare_module(name, submodule_scope, self.pos)
5133 module_scope = submodule_scope
5135 env.declare_module(self.as_name, module_scope, self.pos)
5137 env.declare_module(top_name, top_module_scope, self.pos)
5139 name = self.as_name or self.module_name
5140 env.declare_module(name, module_scope, self.pos)
5142 def analyse_expressions(self, env):
5145 def generate_execution_code(self, code):
5149 class FromCImportStatNode(StatNode):
5150 # from ... cimport statement
5152 # module_name string Qualified name of module
5153 # imported_names [(pos, name, as_name, kind)] Names to be imported
5157 def analyse_declarations(self, env):
5158 if not env.is_module_scope:
5159 error(self.pos, "cimport only allowed at module level")
5161 module_scope = env.find_module(self.module_name, self.pos)
5162 env.add_imported_module(module_scope)
5163 for pos, name, as_name, kind in self.imported_names:
5165 for local_name, entry in module_scope.entries.items():
5166 env.add_imported_entry(local_name, entry, pos)
5168 entry = module_scope.lookup(name)
5170 if kind and not self.declaration_matches(entry, kind):
5171 entry.redeclared(pos)
5173 if kind == 'struct' or kind == 'union':
5174 entry = module_scope.declare_struct_or_union(name,
5175 kind = kind, scope = None, typedef_flag = 0, pos = pos)
5176 elif kind == 'class':
5177 entry = module_scope.declare_c_class(name, pos = pos,
5178 module_name = self.module_name)
5180 submodule_scope = env.context.find_module(name, relative_to = module_scope, pos = self.pos)
5181 if submodule_scope.parent_module is module_scope:
5182 env.declare_module(as_name or name, submodule_scope, self.pos)
5184 error(pos, "Name '%s' not declared in module '%s'"
5185 % (name, self.module_name))
5188 local_name = as_name or name
5189 env.add_imported_entry(local_name, entry, pos)
5191 def declaration_matches(self, entry, kind):
5192 if not entry.is_type:
5196 if not type.is_extension_type:
5199 if not type.is_struct_or_union:
5201 if kind != type.kind:
5205 def analyse_expressions(self, env):
5208 def generate_execution_code(self, code):
5212 class FromImportStatNode(StatNode):
5213 # from ... import statement
5216 # items [(string, NameNode)]
5217 # interned_items [(string, NameNode, ExprNode)]
5218 # item PyTempNode used internally
5219 # import_star boolean used internally
5221 child_attrs = ["module"]
5224 def analyse_declarations(self, env):
5225 for name, target in self.items:
5227 if not env.is_module_scope:
5228 error(self.pos, "import * only allowed at module level")
5230 env.has_import_star = 1
5231 self.import_star = 1
5233 target.analyse_target_declaration(env)
5235 def analyse_expressions(self, env):
5237 self.module.analyse_expressions(env)
5238 self.item = ExprNodes.RawCNameExprNode(self.pos, py_object_type)
5239 self.interned_items = []
5240 for name, target in self.items:
5242 for _, entry in env.entries.items():
5243 if not entry.is_type and entry.type.is_extension_type:
5244 env.use_utility_code(ExprNodes.type_test_utility_code)
5247 entry = env.lookup(target.name)
5248 # check whether or not entry is already cimported
5249 if (entry.is_type and entry.type.name == name
5250 and hasattr(entry.type, 'module_name')):
5251 if entry.type.module_name == self.module.module_name.value:
5252 # cimported with absolute name
5255 # cimported with relative name
5256 module = env.find_module(self.module.module_name.value,
5258 if entry.type.module_name == module.qualified_name:
5260 except AttributeError:
5262 target.analyse_target_expression(env, None)
5263 if target.type is py_object_type:
5266 coerced_item = self.item.coerce_to(target.type, env)
5267 self.interned_items.append((name, target, coerced_item))
5269 def generate_execution_code(self, code):
5270 self.module.generate_evaluation_code(code)
5271 if self.import_star:
5273 'if (%s(%s) < 0) %s;' % (
5275 self.module.py_result(),
5276 code.error_goto(self.pos)))
5277 item_temp = code.funcstate.allocate_temp(py_object_type, manage_ref=True)
5278 self.item.set_cname(item_temp)
5279 for name, target, coerced_item in self.interned_items:
5280 cname = code.intern_identifier(name)
5282 '%s = PyObject_GetAttr(%s, %s); %s' % (
5284 self.module.py_result(),
5286 code.error_goto_if_null(item_temp, self.pos)))
5287 code.put_gotref(item_temp)
5288 if coerced_item is None:
5289 target.generate_assignment_code(self.item, code)
5291 coerced_item.allocate_temp_result(code)
5292 coerced_item.generate_result_code(code)
5293 target.generate_assignment_code(coerced_item, code)
5294 code.put_decref_clear(item_temp, py_object_type)
5295 code.funcstate.release_temp(item_temp)
5296 self.module.generate_disposal_code(code)
5297 self.module.free_temps(code)
5301 #------------------------------------------------------------------------------------
5303 # Runtime support code
5305 #------------------------------------------------------------------------------------
5307 utility_function_predeclarations = \
5309 /* inline attribute */
5310 #ifndef CYTHON_INLINE
5311 #if defined(__GNUC__)
5312 #define CYTHON_INLINE __inline__
5313 #elif defined(_MSC_VER)
5314 #define CYTHON_INLINE __inline
5315 #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
5316 #define CYTHON_INLINE inline
5318 #define CYTHON_INLINE
5322 /* unused attribute */
5323 #ifndef CYTHON_UNUSED
5324 # if defined(__GNUC__)
5325 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
5326 # define CYTHON_UNUSED __attribute__ ((__unused__))
5328 # define CYTHON_UNUSED
5330 # elif defined(__ICC) || defined(__INTEL_COMPILER)
5331 # define CYTHON_UNUSED __attribute__ ((__unused__))
5333 # define CYTHON_UNUSED
5337 typedef struct {PyObject **p; char *s; const long n; const char* encoding; const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; /*proto*/
5341 if Options.gcc_branch_hints:
5342 branch_prediction_macros = \
5345 /* Test for GCC > 2.95 */
5346 #if __GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))
5347 #define likely(x) __builtin_expect(!!(x), 1)
5348 #define unlikely(x) __builtin_expect(!!(x), 0)
5349 #else /* __GNUC__ > 2 ... */
5350 #define likely(x) (x)
5351 #define unlikely(x) (x)
5352 #endif /* __GNUC__ > 2 ... */
5353 #else /* __GNUC__ */
5354 #define likely(x) (x)
5355 #define unlikely(x) (x)
5356 #endif /* __GNUC__ */
5359 branch_prediction_macros = \
5361 #define likely(x) (x)
5362 #define unlikely(x) (x)
5365 #get_name_predeclaration = \
5366 #"static PyObject *__Pyx_GetName(PyObject *dict, char *name); /*proto*/"
5368 #get_name_interned_predeclaration = \
5369 #"static PyObject *__Pyx_GetName(PyObject *dict, PyObject *name); /*proto*/"
5371 #------------------------------------------------------------------------------------
5373 printing_utility_code = UtilityCode(
5375 static int __Pyx_Print(PyObject*, PyObject *, int); /*proto*/
5376 #if PY_MAJOR_VERSION >= 3
5377 static PyObject* %s = 0;
5378 static PyObject* %s = 0;
5380 """ % (Naming.print_function, Naming.print_function_kwargs),
5382 #if PY_MAJOR_VERSION >= 3
5386 """ % (Naming.print_function, Naming.print_function_kwargs),
5388 #if PY_MAJOR_VERSION < 3
5389 static PyObject *__Pyx_GetStdout(void) {
5390 PyObject *f = PySys_GetObject((char *)"stdout");
5392 PyErr_SetString(PyExc_RuntimeError, "lost sys.stdout");
5397 static int __Pyx_Print(PyObject* f, PyObject *arg_tuple, int newline) {
5402 if (!(f = __Pyx_GetStdout()))
5405 for (i=0; i < PyTuple_GET_SIZE(arg_tuple); i++) {
5406 if (PyFile_SoftSpace(f, 1)) {
5407 if (PyFile_WriteString(" ", f) < 0)
5410 v = PyTuple_GET_ITEM(arg_tuple, i);
5411 if (PyFile_WriteObject(v, f, Py_PRINT_RAW) < 0)
5413 if (PyString_Check(v)) {
5414 char *s = PyString_AsString(v);
5415 Py_ssize_t len = PyString_Size(v);
5417 isspace(Py_CHARMASK(s[len-1])) &&
5419 PyFile_SoftSpace(f, 0);
5423 if (PyFile_WriteString("\n", f) < 0)
5425 PyFile_SoftSpace(f, 0);
5430 #else /* Python 3 has a print function */
5432 static int __Pyx_Print(PyObject* stream, PyObject *arg_tuple, int newline) {
5433 PyObject* kwargs = 0;
5434 PyObject* result = 0;
5435 PyObject* end_string;
5436 if (unlikely(!%(PRINT_FUNCTION)s)) {
5437 %(PRINT_FUNCTION)s = __Pyx_GetAttrString(%(BUILTINS)s, "print");
5438 if (!%(PRINT_FUNCTION)s)
5442 kwargs = PyDict_New();
5443 if (unlikely(!kwargs))
5445 if (unlikely(PyDict_SetItemString(kwargs, "file", stream) < 0))
5448 end_string = PyUnicode_FromStringAndSize(" ", 1);
5449 if (unlikely(!end_string))
5451 if (PyDict_SetItemString(kwargs, "end", end_string) < 0) {
5452 Py_DECREF(end_string);
5455 Py_DECREF(end_string);
5457 } else if (!newline) {
5458 if (unlikely(!%(PRINT_KWARGS)s)) {
5459 %(PRINT_KWARGS)s = PyDict_New();
5460 if (unlikely(!%(PRINT_KWARGS)s))
5462 end_string = PyUnicode_FromStringAndSize(" ", 1);
5463 if (unlikely(!end_string))
5465 if (PyDict_SetItemString(%(PRINT_KWARGS)s, "end", end_string) < 0) {
5466 Py_DECREF(end_string);
5469 Py_DECREF(end_string);
5471 kwargs = %(PRINT_KWARGS)s;
5473 result = PyObject_Call(%(PRINT_FUNCTION)s, arg_tuple, kwargs);
5474 if (unlikely(kwargs) && (kwargs != %(PRINT_KWARGS)s))
5481 if (kwargs != %(PRINT_KWARGS)s)
5487 """ % {'BUILTINS' : Naming.builtins_cname,
5488 'PRINT_FUNCTION' : Naming.print_function,
5489 'PRINT_KWARGS' : Naming.print_function_kwargs}
5493 printing_one_utility_code = UtilityCode(
5495 static int __Pyx_PrintOne(PyObject* stream, PyObject *o); /*proto*/
5498 #if PY_MAJOR_VERSION < 3
5500 static int __Pyx_PrintOne(PyObject* f, PyObject *o) {
5502 if (!(f = __Pyx_GetStdout()))
5505 if (PyFile_SoftSpace(f, 0)) {
5506 if (PyFile_WriteString(" ", f) < 0)
5509 if (PyFile_WriteObject(o, f, Py_PRINT_RAW) < 0)
5511 if (PyFile_WriteString("\n", f) < 0)
5514 /* the line below is just to avoid compiler
5515 * compiler warnings about unused functions */
5516 return __Pyx_Print(f, NULL, 0);
5519 #else /* Python 3 has a print function */
5521 static int __Pyx_PrintOne(PyObject* stream, PyObject *o) {
5523 PyObject* arg_tuple = PyTuple_New(1);
5524 if (unlikely(!arg_tuple))
5527 PyTuple_SET_ITEM(arg_tuple, 0, o);
5528 res = __Pyx_Print(stream, arg_tuple, 1);
5529 Py_DECREF(arg_tuple);
5535 requires=[printing_utility_code])
5539 #------------------------------------------------------------------------------------
5541 # Exception raising code
5543 # Exceptions are raised by __Pyx_Raise() and stored as plain
5544 # type/value/tb in PyThreadState->curexc_*. When being caught by an
5545 # 'except' statement, curexc_* is moved over to exc_* by
5546 # __Pyx_GetException()
5548 restore_exception_utility_code = UtilityCode(
5550 static CYTHON_INLINE void __Pyx_ErrRestore(PyObject *type, PyObject *value, PyObject *tb); /*proto*/
5551 static CYTHON_INLINE void __Pyx_ErrFetch(PyObject **type, PyObject **value, PyObject **tb); /*proto*/
5554 static CYTHON_INLINE void __Pyx_ErrRestore(PyObject *type, PyObject *value, PyObject *tb) {
5555 PyObject *tmp_type, *tmp_value, *tmp_tb;
5556 PyThreadState *tstate = PyThreadState_GET();
5558 tmp_type = tstate->curexc_type;
5559 tmp_value = tstate->curexc_value;
5560 tmp_tb = tstate->curexc_traceback;
5561 tstate->curexc_type = type;
5562 tstate->curexc_value = value;
5563 tstate->curexc_traceback = tb;
5564 Py_XDECREF(tmp_type);
5565 Py_XDECREF(tmp_value);
5569 static CYTHON_INLINE void __Pyx_ErrFetch(PyObject **type, PyObject **value, PyObject **tb) {
5570 PyThreadState *tstate = PyThreadState_GET();
5571 *type = tstate->curexc_type;
5572 *value = tstate->curexc_value;
5573 *tb = tstate->curexc_traceback;
5575 tstate->curexc_type = 0;
5576 tstate->curexc_value = 0;
5577 tstate->curexc_traceback = 0;
5582 # The following function is based on do_raise() from ceval.c. There
5583 # are separate versions for Python2 and Python3 as exception handling
5584 # has changed quite a lot between the two versions.
5586 raise_utility_code = UtilityCode(
5588 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb); /*proto*/
5591 #if PY_MAJOR_VERSION < 3
5592 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb) {
5596 /* First, check the traceback argument, replacing None with NULL. */
5597 if (tb == Py_None) {
5601 else if (tb != NULL && !PyTraceBack_Check(tb)) {
5602 PyErr_SetString(PyExc_TypeError,
5603 "raise: arg 3 must be a traceback or None");
5606 /* Next, replace a missing value with None */
5607 if (value == NULL) {
5611 #if PY_VERSION_HEX < 0x02050000
5612 if (!PyClass_Check(type))
5614 if (!PyType_Check(type))
5617 /* Raising an instance. The value should be a dummy. */
5618 if (value != Py_None) {
5619 PyErr_SetString(PyExc_TypeError,
5620 "instance exception may not have a separate value");
5623 /* Normalize to raise <class>, <instance> */
5626 #if PY_VERSION_HEX < 0x02050000
5627 if (PyInstance_Check(type)) {
5628 type = (PyObject*) ((PyInstanceObject*)type)->in_class;
5633 PyErr_SetString(PyExc_TypeError,
5634 "raise: exception must be an old-style class or instance");
5638 type = (PyObject*) Py_TYPE(type);
5640 if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) {
5641 PyErr_SetString(PyExc_TypeError,
5642 "raise: exception class must be a subclass of BaseException");
5648 __Pyx_ErrRestore(type, value, tb);
5657 #else /* Python 3+ */
5659 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb) {
5660 if (tb == Py_None) {
5662 } else if (tb && !PyTraceBack_Check(tb)) {
5663 PyErr_SetString(PyExc_TypeError,
5664 "raise: arg 3 must be a traceback or None");
5667 if (value == Py_None)
5670 if (PyExceptionInstance_Check(type)) {
5672 PyErr_SetString(PyExc_TypeError,
5673 "instance exception may not have a separate value");
5677 type = (PyObject*) Py_TYPE(value);
5678 } else if (!PyExceptionClass_Check(type)) {
5679 PyErr_SetString(PyExc_TypeError,
5680 "raise: exception class must be a subclass of BaseException");
5684 PyErr_SetObject(type, value);
5687 PyThreadState *tstate = PyThreadState_GET();
5688 PyObject* tmp_tb = tstate->curexc_traceback;
5691 tstate->curexc_traceback = tb;
5701 requires=[restore_exception_utility_code])
5703 #------------------------------------------------------------------------------------
5705 get_exception_utility_code = UtilityCode(
5707 static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); /*proto*/
5710 static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) {
5711 PyObject *local_type, *local_value, *local_tb;
5712 PyObject *tmp_type, *tmp_value, *tmp_tb;
5713 PyThreadState *tstate = PyThreadState_GET();
5714 local_type = tstate->curexc_type;
5715 local_value = tstate->curexc_value;
5716 local_tb = tstate->curexc_traceback;
5717 tstate->curexc_type = 0;
5718 tstate->curexc_value = 0;
5719 tstate->curexc_traceback = 0;
5720 PyErr_NormalizeException(&local_type, &local_value, &local_tb);
5721 if (unlikely(tstate->curexc_type))
5723 #if PY_MAJOR_VERSION >= 3
5724 if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0))
5728 *value = local_value;
5730 Py_INCREF(local_type);
5731 Py_INCREF(local_value);
5732 Py_INCREF(local_tb);
5733 tmp_type = tstate->exc_type;
5734 tmp_value = tstate->exc_value;
5735 tmp_tb = tstate->exc_traceback;
5736 tstate->exc_type = local_type;
5737 tstate->exc_value = local_value;
5738 tstate->exc_traceback = local_tb;
5739 /* Make sure tstate is in a consistent state when we XDECREF
5740 these objects (XDECREF may run arbitrary code). */
5741 Py_XDECREF(tmp_type);
5742 Py_XDECREF(tmp_value);
5749 Py_XDECREF(local_type);
5750 Py_XDECREF(local_value);
5751 Py_XDECREF(local_tb);
5757 #------------------------------------------------------------------------------------
5759 get_exception_tuple_utility_code = UtilityCode(proto="""
5760 static PyObject *__Pyx_GetExceptionTuple(void); /*proto*/
5762 # I doubt that calling __Pyx_GetException() here is correct as it moves
5763 # the exception from tstate->curexc_* to tstate->exc_*, which prevents
5764 # exception handlers later on from receiving it.
5766 static PyObject *__Pyx_GetExceptionTuple(void) {
5767 PyObject *type = NULL, *value = NULL, *tb = NULL;
5768 if (__Pyx_GetException(&type, &value, &tb) == 0) {
5769 PyObject* exc_info = PyTuple_New(3);
5774 PyTuple_SET_ITEM(exc_info, 0, type);
5775 PyTuple_SET_ITEM(exc_info, 1, value);
5776 PyTuple_SET_ITEM(exc_info, 2, tb);
5783 requires=[get_exception_utility_code])
5785 #------------------------------------------------------------------------------------
5787 reset_exception_utility_code = UtilityCode(
5789 static CYTHON_INLINE void __Pyx_ExceptionSave(PyObject **type, PyObject **value, PyObject **tb); /*proto*/
5790 static void __Pyx_ExceptionReset(PyObject *type, PyObject *value, PyObject *tb); /*proto*/
5793 static CYTHON_INLINE void __Pyx_ExceptionSave(PyObject **type, PyObject **value, PyObject **tb) {
5794 PyThreadState *tstate = PyThreadState_GET();
5795 *type = tstate->exc_type;
5796 *value = tstate->exc_value;
5797 *tb = tstate->exc_traceback;
5803 static void __Pyx_ExceptionReset(PyObject *type, PyObject *value, PyObject *tb) {
5804 PyObject *tmp_type, *tmp_value, *tmp_tb;
5805 PyThreadState *tstate = PyThreadState_GET();
5806 tmp_type = tstate->exc_type;
5807 tmp_value = tstate->exc_value;
5808 tmp_tb = tstate->exc_traceback;
5809 tstate->exc_type = type;
5810 tstate->exc_value = value;
5811 tstate->exc_traceback = tb;
5812 Py_XDECREF(tmp_type);
5813 Py_XDECREF(tmp_value);
5818 #------------------------------------------------------------------------------------
5820 arg_type_test_utility_code = UtilityCode(
5822 static int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed,
5823 const char *name, int exact); /*proto*/
5826 static int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed,
5827 const char *name, int exact)
5830 PyErr_Format(PyExc_SystemError, "Missing type object");
5833 if (none_allowed && obj == Py_None) return 1;
5835 if (Py_TYPE(obj) == type) return 1;
5838 if (PyObject_TypeCheck(obj, type)) return 1;
5840 PyErr_Format(PyExc_TypeError,
5841 "Argument '%s' has incorrect type (expected %s, got %s)",
5842 name, type->tp_name, Py_TYPE(obj)->tp_name);
5847 #------------------------------------------------------------------------------------
5849 # __Pyx_RaiseArgtupleInvalid raises the correct exception when too
5850 # many or too few positional arguments were found. This handles
5851 # Py_ssize_t formatting correctly.
5853 raise_argtuple_invalid_utility_code = UtilityCode(
5855 static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact,
5856 Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); /*proto*/
5859 static void __Pyx_RaiseArgtupleInvalid(
5860 const char* func_name,
5864 Py_ssize_t num_found)
5866 Py_ssize_t num_expected;
5867 const char *number, *more_or_less;
5869 if (num_found < num_min) {
5870 num_expected = num_min;
5871 more_or_less = "at least";
5873 num_expected = num_max;
5874 more_or_less = "at most";
5877 more_or_less = "exactly";
5879 number = (num_expected == 1) ? "" : "s";
5880 PyErr_Format(PyExc_TypeError,
5881 #if PY_VERSION_HEX < 0x02050000
5882 "%s() takes %s %d positional argument%s (%d given)",
5884 "%s() takes %s %zd positional argument%s (%zd given)",
5886 func_name, more_or_less, num_expected, number, num_found);
5890 raise_keyword_required_utility_code = UtilityCode(
5892 static CYTHON_INLINE void __Pyx_RaiseKeywordRequired(const char* func_name, PyObject* kw_name); /*proto*/
5895 static CYTHON_INLINE void __Pyx_RaiseKeywordRequired(
5896 const char* func_name,
5899 PyErr_Format(PyExc_TypeError,
5900 #if PY_MAJOR_VERSION >= 3
5901 "%s() needs keyword-only argument %U", func_name, kw_name);
5903 "%s() needs keyword-only argument %s", func_name,
5904 PyString_AS_STRING(kw_name));
5909 raise_double_keywords_utility_code = UtilityCode(
5911 static void __Pyx_RaiseDoubleKeywordsError(
5912 const char* func_name, PyObject* kw_name); /*proto*/
5915 static void __Pyx_RaiseDoubleKeywordsError(
5916 const char* func_name,
5919 PyErr_Format(PyExc_TypeError,
5920 #if PY_MAJOR_VERSION >= 3
5921 "%s() got multiple values for keyword argument '%U'", func_name, kw_name);
5923 "%s() got multiple values for keyword argument '%s'", func_name,
5924 PyString_AS_STRING(kw_name));
5929 #------------------------------------------------------------------------------------
5931 # __Pyx_CheckKeywordStrings raises an error if non-string keywords
5932 # were passed to a function, or if any keywords were passed to a
5933 # function that does not accept them.
5935 keyword_string_check_utility_code = UtilityCode(
5937 static CYTHON_INLINE int __Pyx_CheckKeywordStrings(PyObject *kwdict,
5938 const char* function_name, int kw_allowed); /*proto*/
5941 static CYTHON_INLINE int __Pyx_CheckKeywordStrings(
5943 const char* function_name,
5948 while (PyDict_Next(kwdict, &pos, &key, 0)) {
5949 #if PY_MAJOR_VERSION < 3
5950 if (unlikely(!PyString_CheckExact(key)) && unlikely(!PyString_Check(key)))
5952 if (unlikely(!PyUnicode_CheckExact(key)) && unlikely(!PyUnicode_Check(key)))
5954 goto invalid_keyword_type;
5956 if ((!kw_allowed) && unlikely(key))
5957 goto invalid_keyword;
5959 invalid_keyword_type:
5960 PyErr_Format(PyExc_TypeError,
5961 "%s() keywords must be strings", function_name);
5964 PyErr_Format(PyExc_TypeError,
5965 #if PY_MAJOR_VERSION < 3
5966 "%s() got an unexpected keyword argument '%s'",
5967 function_name, PyString_AsString(key));
5969 "%s() got an unexpected keyword argument '%U'",
5970 function_name, key);
5976 #------------------------------------------------------------------------------------
5978 # __Pyx_ParseOptionalKeywords copies the optional/unknown keyword
5979 # arguments from the kwds dict into kwds2. If kwds2 is NULL, unknown
5980 # keywords will raise an invalid keyword error.
5982 # Three kinds of errors are checked: 1) non-string keywords, 2)
5983 # unexpected keywords and 3) overlap with positional arguments.
5985 # If num_posargs is greater 0, it denotes the number of positional
5986 # arguments that were passed and that must therefore not appear
5987 # amongst the keywords as well.
5989 # This method does not check for required keyword arguments.
5992 parse_keywords_utility_code = UtilityCode(
5994 static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[], \
5995 PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, \
5996 const char* function_name); /*proto*/
5999 static int __Pyx_ParseOptionalKeywords(
6001 PyObject **argnames[],
6004 Py_ssize_t num_pos_args,
6005 const char* function_name)
6007 PyObject *key = 0, *value = 0;
6010 PyObject*** first_kw_arg = argnames + num_pos_args;
6012 while (PyDict_Next(kwds, &pos, &key, &value)) {
6013 name = first_kw_arg;
6014 while (*name && (**name != key)) name++;
6016 values[name-argnames] = value;
6018 #if PY_MAJOR_VERSION < 3
6019 if (unlikely(!PyString_CheckExact(key)) && unlikely(!PyString_Check(key))) {
6021 if (unlikely(!PyUnicode_CheckExact(key)) && unlikely(!PyUnicode_Check(key))) {
6023 goto invalid_keyword_type;
6025 for (name = first_kw_arg; *name; name++) {
6026 #if PY_MAJOR_VERSION >= 3
6027 if (PyUnicode_GET_SIZE(**name) == PyUnicode_GET_SIZE(key) &&
6028 PyUnicode_Compare(**name, key) == 0) break;
6030 if (PyString_GET_SIZE(**name) == PyString_GET_SIZE(key) &&
6031 _PyString_Eq(**name, key)) break;
6035 values[name-argnames] = value;
6037 /* unexpected keyword found */
6038 for (name=argnames; name != first_kw_arg; name++) {
6039 if (**name == key) goto arg_passed_twice;
6040 #if PY_MAJOR_VERSION >= 3
6041 if (PyUnicode_GET_SIZE(**name) == PyUnicode_GET_SIZE(key) &&
6042 PyUnicode_Compare(**name, key) == 0) goto arg_passed_twice;
6044 if (PyString_GET_SIZE(**name) == PyString_GET_SIZE(key) &&
6045 _PyString_Eq(**name, key)) goto arg_passed_twice;
6049 if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad;
6051 goto invalid_keyword;
6059 __Pyx_RaiseDoubleKeywordsError(function_name, **name);
6061 invalid_keyword_type:
6062 PyErr_Format(PyExc_TypeError,
6063 "%s() keywords must be strings", function_name);
6066 PyErr_Format(PyExc_TypeError,
6067 #if PY_MAJOR_VERSION < 3
6068 "%s() got an unexpected keyword argument '%s'",
6069 function_name, PyString_AsString(key));
6071 "%s() got an unexpected keyword argument '%U'",
6072 function_name, key);
6079 #------------------------------------------------------------------------------------
6081 traceback_utility_code = UtilityCode(
6083 static void __Pyx_AddTraceback(const char *funcname); /*proto*/
6086 #include "compile.h"
6087 #include "frameobject.h"
6088 #include "traceback.h"
6090 static void __Pyx_AddTraceback(const char *funcname) {
6091 PyObject *py_srcfile = 0;
6092 PyObject *py_funcname = 0;
6093 PyObject *py_globals = 0;
6094 PyCodeObject *py_code = 0;
6095 PyFrameObject *py_frame = 0;
6097 #if PY_MAJOR_VERSION < 3
6098 py_srcfile = PyString_FromString(%(FILENAME)s);
6100 py_srcfile = PyUnicode_FromString(%(FILENAME)s);
6102 if (!py_srcfile) goto bad;
6104 #if PY_MAJOR_VERSION < 3
6105 py_funcname = PyString_FromFormat( "%%s (%%s:%%d)", funcname, %(CFILENAME)s, %(CLINENO)s);
6107 py_funcname = PyUnicode_FromFormat( "%%s (%%s:%%d)", funcname, %(CFILENAME)s, %(CLINENO)s);
6111 #if PY_MAJOR_VERSION < 3
6112 py_funcname = PyString_FromString(funcname);
6114 py_funcname = PyUnicode_FromString(funcname);
6117 if (!py_funcname) goto bad;
6118 py_globals = PyModule_GetDict(%(GLOBALS)s);
6119 if (!py_globals) goto bad;
6120 py_code = PyCode_New(
6121 0, /*int argcount,*/
6122 #if PY_MAJOR_VERSION >= 3
6123 0, /*int kwonlyargcount,*/
6126 0, /*int stacksize,*/
6128 %(EMPTY_BYTES)s, /*PyObject *code,*/
6129 %(EMPTY_TUPLE)s, /*PyObject *consts,*/
6130 %(EMPTY_TUPLE)s, /*PyObject *names,*/
6131 %(EMPTY_TUPLE)s, /*PyObject *varnames,*/
6132 %(EMPTY_TUPLE)s, /*PyObject *freevars,*/
6133 %(EMPTY_TUPLE)s, /*PyObject *cellvars,*/
6134 py_srcfile, /*PyObject *filename,*/
6135 py_funcname, /*PyObject *name,*/
6136 %(LINENO)s, /*int firstlineno,*/
6137 %(EMPTY_BYTES)s /*PyObject *lnotab*/
6139 if (!py_code) goto bad;
6140 py_frame = PyFrame_New(
6141 PyThreadState_GET(), /*PyThreadState *tstate,*/
6142 py_code, /*PyCodeObject *code,*/
6143 py_globals, /*PyObject *globals,*/
6144 0 /*PyObject *locals*/
6146 if (!py_frame) goto bad;
6147 py_frame->f_lineno = %(LINENO)s;
6148 PyTraceBack_Here(py_frame);
6150 Py_XDECREF(py_srcfile);
6151 Py_XDECREF(py_funcname);
6152 Py_XDECREF(py_code);
6153 Py_XDECREF(py_frame);
6156 'FILENAME': Naming.filename_cname,
6157 'LINENO': Naming.lineno_cname,
6158 'CFILENAME': Naming.cfilenm_cname,
6159 'CLINENO': Naming.clineno_cname,
6160 'GLOBALS': Naming.module_cname,
6161 'EMPTY_TUPLE' : Naming.empty_tuple,
6162 'EMPTY_BYTES' : Naming.empty_bytes,
6165 #------------------------------------------------------------------------------------
6167 unraisable_exception_utility_code = UtilityCode(
6169 static void __Pyx_WriteUnraisable(const char *name); /*proto*/
6172 static void __Pyx_WriteUnraisable(const char *name) {
6173 PyObject *old_exc, *old_val, *old_tb;
6175 __Pyx_ErrFetch(&old_exc, &old_val, &old_tb);
6176 #if PY_MAJOR_VERSION < 3
6177 ctx = PyString_FromString(name);
6179 ctx = PyUnicode_FromString(name);
6181 __Pyx_ErrRestore(old_exc, old_val, old_tb);
6183 PyErr_WriteUnraisable(Py_None);
6185 PyErr_WriteUnraisable(ctx);
6190 requires=[restore_exception_utility_code])
6192 #------------------------------------------------------------------------------------
6194 set_vtable_utility_code = UtilityCode(
6196 static int __Pyx_SetVtable(PyObject *dict, void *vtable); /*proto*/
6199 static int __Pyx_SetVtable(PyObject *dict, void *vtable) {
6200 #if PY_VERSION_HEX >= 0x02070000 && !(PY_MAJOR_VERSION==3&&PY_MINOR_VERSION==0)
6201 PyObject *ob = PyCapsule_New(vtable, 0, 0);
6203 PyObject *ob = PyCObject_FromVoidPtr(vtable, 0);
6207 if (PyDict_SetItemString(dict, "__pyx_vtable__", ob) < 0)
6217 #------------------------------------------------------------------------------------
6219 get_vtable_utility_code = UtilityCode(
6221 static int __Pyx_GetVtable(PyObject *dict, void *vtabptr); /*proto*/
6224 static int __Pyx_GetVtable(PyObject *dict, void *vtabptr) {
6225 PyObject *ob = PyMapping_GetItemString(dict, (char *)"__pyx_vtable__");
6228 #if PY_VERSION_HEX >= 0x02070000 && !(PY_MAJOR_VERSION==3&&PY_MINOR_VERSION==0)
6229 *(void **)vtabptr = PyCapsule_GetPointer(ob, 0);
6231 *(void **)vtabptr = PyCObject_AsVoidPtr(ob);
6233 if (!*(void **)vtabptr)
6243 #------------------------------------------------------------------------------------
6245 init_string_tab_utility_code = UtilityCode(
6247 static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); /*proto*/
6250 static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
6252 #if PY_MAJOR_VERSION < 3
6253 if (t->is_unicode) {
6254 *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL);
6255 } else if (t->intern) {
6256 *t->p = PyString_InternFromString(t->s);
6258 *t->p = PyString_FromStringAndSize(t->s, t->n - 1);
6260 #else /* Python 3+ has unicode identifiers */
6261 if (t->is_unicode | t->is_str) {
6263 *t->p = PyUnicode_InternFromString(t->s);
6264 } else if (t->encoding) {
6265 *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL);
6267 *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1);
6270 *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1);
6281 #------------------------------------------------------------------------------------
6283 force_init_threads_utility_code = UtilityCode(
6285 #ifndef __PYX_FORCE_INIT_THREADS
6286 #if PY_VERSION_HEX < 0x02040200
6287 #define __PYX_FORCE_INIT_THREADS 1
6289 #define __PYX_FORCE_INIT_THREADS 0
6294 #------------------------------------------------------------------------------------
6296 # Note that cPython ignores PyTrace_EXCEPTION,
6297 # but maybe some other profilers don't.
6299 profile_utility_code = UtilityCode(proto="""
6300 #ifndef CYTHON_PROFILE
6301 #define CYTHON_PROFILE 1
6304 #ifndef CYTHON_PROFILE_REUSE_FRAME
6305 #define CYTHON_PROFILE_REUSE_FRAME 0
6310 #include "compile.h"
6311 #include "frameobject.h"
6312 #include "traceback.h"
6314 #if CYTHON_PROFILE_REUSE_FRAME
6315 #define CYTHON_FRAME_MODIFIER static
6316 #define CYTHON_FRAME_DEL
6318 #define CYTHON_FRAME_MODIFIER
6319 #define CYTHON_FRAME_DEL Py_DECREF(%(FRAME)s)
6322 #define __Pyx_TraceDeclarations \\
6323 static PyCodeObject *%(FRAME_CODE)s = NULL; \\
6324 CYTHON_FRAME_MODIFIER PyFrameObject *%(FRAME)s = NULL; \\
6325 int __Pyx_use_tracing = 0;
6327 #define __Pyx_TraceCall(funcname, srcfile, firstlineno) \\
6328 if (unlikely(PyThreadState_GET()->use_tracing && PyThreadState_GET()->c_profilefunc)) { \\
6329 __Pyx_use_tracing = __Pyx_TraceSetupAndCall(&%(FRAME_CODE)s, &%(FRAME)s, funcname, srcfile, firstlineno); \\
6332 #define __Pyx_TraceException() \\
6333 if (unlikely(__Pyx_use_tracing( && PyThreadState_GET()->use_tracing && PyThreadState_GET()->c_profilefunc) { \\
6334 PyObject *exc_info = __Pyx_GetExceptionTuple(); \\
6336 PyThreadState_GET()->c_profilefunc( \\
6337 PyThreadState_GET()->c_profileobj, %(FRAME)s, PyTrace_EXCEPTION, exc_info); \\
6338 Py_DECREF(exc_info); \\
6342 #define __Pyx_TraceReturn(result) \\
6343 if (unlikely(__Pyx_use_tracing) && PyThreadState_GET()->use_tracing && PyThreadState_GET()->c_profilefunc) { \\
6344 PyThreadState_GET()->c_profilefunc( \\
6345 PyThreadState_GET()->c_profileobj, %(FRAME)s, PyTrace_RETURN, (PyObject*)result); \\
6346 CYTHON_FRAME_DEL; \\
6349 static PyCodeObject *__Pyx_createFrameCodeObject(const char *funcname, const char *srcfile, int firstlineno); /*proto*/
6350 static int __Pyx_TraceSetupAndCall(PyCodeObject** code, PyFrameObject** frame, const char *funcname, const char *srcfile, int firstlineno); /*proto*/
6354 #define __Pyx_TraceDeclarations
6355 #define __Pyx_TraceCall(funcname, srcfile, firstlineno)
6356 #define __Pyx_TraceException()
6357 #define __Pyx_TraceReturn(result)
6359 #endif /* CYTHON_PROFILE */
6362 "FRAME": Naming.frame_cname,
6363 "FRAME_CODE": Naming.frame_code_cname,
6369 static int __Pyx_TraceSetupAndCall(PyCodeObject** code,
6370 PyFrameObject** frame,
6371 const char *funcname,
6372 const char *srcfile,
6374 if (*frame == NULL || !CYTHON_PROFILE_REUSE_FRAME) {
6375 if (*code == NULL) {
6376 *code = __Pyx_createFrameCodeObject(funcname, srcfile, firstlineno);
6377 if (*code == NULL) return 0;
6379 *frame = PyFrame_New(
6380 PyThreadState_GET(), /*PyThreadState *tstate*/
6381 *code, /*PyCodeObject *code*/
6382 PyModule_GetDict(%(MODULE)s), /*PyObject *globals*/
6383 0 /*PyObject *locals*/
6385 if (*frame == NULL) return 0;
6388 (*frame)->f_tstate = PyThreadState_GET();
6390 return PyThreadState_GET()->c_profilefunc(PyThreadState_GET()->c_profileobj, *frame, PyTrace_CALL, NULL) == 0;
6393 static PyCodeObject *__Pyx_createFrameCodeObject(const char *funcname, const char *srcfile, int firstlineno) {
6394 PyObject *py_srcfile = 0;
6395 PyObject *py_funcname = 0;
6396 PyCodeObject *py_code = 0;
6398 #if PY_MAJOR_VERSION < 3
6399 py_funcname = PyString_FromString(funcname);
6400 py_srcfile = PyString_FromString(srcfile);
6402 py_funcname = PyUnicode_FromString(funcname);
6403 py_srcfile = PyUnicode_FromString(srcfile);
6405 if (!py_funcname | !py_srcfile) goto bad;
6407 py_code = PyCode_New(
6408 0, /*int argcount,*/
6409 #if PY_MAJOR_VERSION >= 3
6410 0, /*int kwonlyargcount,*/
6413 0, /*int stacksize,*/
6415 %(EMPTY_BYTES)s, /*PyObject *code,*/
6416 %(EMPTY_TUPLE)s, /*PyObject *consts,*/
6417 %(EMPTY_TUPLE)s, /*PyObject *names,*/
6418 %(EMPTY_TUPLE)s, /*PyObject *varnames,*/
6419 %(EMPTY_TUPLE)s, /*PyObject *freevars,*/
6420 %(EMPTY_TUPLE)s, /*PyObject *cellvars,*/
6421 py_srcfile, /*PyObject *filename,*/
6422 py_funcname, /*PyObject *name,*/
6423 firstlineno, /*int firstlineno,*/
6424 %(EMPTY_BYTES)s /*PyObject *lnotab*/
6428 Py_XDECREF(py_srcfile);
6429 Py_XDECREF(py_funcname);
6434 #endif /* CYTHON_PROFILE */
6436 'EMPTY_TUPLE' : Naming.empty_tuple,
6437 'EMPTY_BYTES' : Naming.empty_bytes,
6438 "MODULE": Naming.module_cname,