#

# Parse tree nodes

#

import cython

cython.declare(sys=object, os=object, copy=object,

Builtin=object, error=object, warning=object, Naming=object, PyrexTypes=object,

py_object_type=object, ModuleScope=object, LocalScope=object, ClosureScope=object,

StructOrUnionScope=object, PyClassScope=object,

CppClassScope=object, UtilityCode=object, EncodedString=object,

absolute_path_length=cython.Py_ssize_t)

import sys, os, copy

from itertools import chain

import Builtin

from Errors import error, warning, InternalError, CompileError

import Naming

import PyrexTypes

import TypeSlots

from PyrexTypes import py_object_type, error_type

from Symtab import (ModuleScope, LocalScope, ClosureScope,

StructOrUnionScope, PyClassScope, CppClassScope, TemplateScope)

from Code import UtilityCode

from StringEncoding import EncodedString, escape_byte_string, split_string_literal

import Options

import DebugFlags

from Cython.Utils import cached_function

absolute_path_length = 0

def relative_position(pos):

"""

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

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

whenever the Python install directory moves (which could happen,

e.g,. when distributing binaries.)

INPUT:

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

OUTPUT:

relative filename

line number

AUTHOR: William Stein

"""

global absolute_path_length

if absolute_path_length==0:

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

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

def embed_position(pos, docstring):

if not Options.embed_pos_in_docstring:

return docstring

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

if docstring is None:

# unicode string

return EncodedString(pos_line)

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

# otherwise make the docstring a unicode string

encoding = docstring.encoding

if encoding is not None:

try:

pos_line.encode(encoding)

except UnicodeEncodeError:

encoding = None

if not docstring:

# reuse the string encoding of the original docstring

doc = EncodedString(pos_line)

else:

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

doc.encoding = encoding

return doc

def write_func_call(func, codewriter_class):

def f(*args, **kwds):

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

# here we annotate the code with this function call

# but only if new code is generated

node, code = args[:2]

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

' ' * code.call_level,

node.__class__.__name__,

func.__name__,

node.pos[1:])

pristine = code.buffer.stream.tell()

code.putln(marker)

start = code.buffer.stream.tell()

code.call_level += 4

res = func(*args, **kwds)

code.call_level -= 4

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

code.buffer.stream.seek(pristine)

else:

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

code.putln(marker)

return res

else:

return func(*args, **kwds)

return f

class VerboseCodeWriter(type):

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

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

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

from types import FunctionType

from Code import CCodeWriter

attrs = dict(attrs)

for mname, m in attrs.items():

if isinstance(m, FunctionType):

attrs[mname] = write_func_call(m, CCodeWriter)

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

class CheckAnalysers(type):

"""Metaclass to check that type analysis functions return a node.

"""

methods = set(['analyse_types',

'analyse_expressions',

'analyse_target_types'])

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

from types import FunctionType

def check(name, func):

def call(*args, **kwargs):

retval = func(*args, **kwargs)

if retval is None:

print name, args, kwargs

return retval

return call

attrs = dict(attrs)

for mname, m in attrs.items():

if isinstance(m, FunctionType) and mname in cls.methods:

attrs[mname] = check(mname, m)

return super(CheckAnalysers, cls).__new__(cls, name, bases, attrs)

class Node(object):

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

# is_name boolean Is a NameNode

# is_literal boolean Is a ConstNode

#__metaclass__ = CheckAnalysers

if DebugFlags.debug_trace_code_generation:

__metaclass__ = VerboseCodeWriter

is_name = 0

is_none = 0

is_nonecheck = 0

is_literal = 0

is_terminator = 0

temps = None

# All descendants should set child_attrs to a list of the attributes

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

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

child_attrs = None

cf_state = None

# This may be an additional (or 'actual') type that will be checked when

# this node is coerced to another type. This could be useful to set when

# the actual type to which it can coerce is known, but you want to leave

# the type a py_object_type

coercion_type = None

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

self.pos = pos

self.__dict__.update(kw)

gil_message = "Operation"

nogil_check = None

def gil_error(self, env=None):

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

cpp_message = "Operation"

def cpp_check(self, env):

if not env.is_cpp():

self.cpp_error()

def cpp_error(self):

error(self.pos, "%s only allowed in c++" % self.cpp_message)

def clone_node(self):

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

amongst the child attributes (from get_child_accessors) which are also

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

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

level in the tree."""

result = copy.copy(self)

for attrname in result.child_attrs:

value = getattr(result, attrname)

if isinstance(value, list):

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

return result

#

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

# all the statements in a given scope-block:

#

# (0) analyse_declarations

# Make symbol table entries for all declarations at the current

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

# to an otherwise undeclared name).

#

# (1) analyse_expressions

# Determine the result types of expressions and fill in the

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

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

# Allocate temporary locals for intermediate results. Fill

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

# fragment.

#

# (2) generate_code

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

# Recursively applies the 3 processing phases to the bodies of

# functions.

#

def analyse_declarations(self, env):

pass

def analyse_expressions(self, env):

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

self.__class__.__name__)

def generate_code(self, code):

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

self.__class__.__name__)

def annotate(self, code):

# mro does the wrong thing

if isinstance(self, BlockNode):

self.body.annotate(code)

def end_pos(self):

try:

return self._end_pos

except AttributeError:

pos = self.pos

if not self.child_attrs:

self._end_pos = pos

return pos

for attr in self.child_attrs:

child = getattr(self, attr)

# Sometimes lists, sometimes nodes

if child is None:

pass

elif isinstance(child, list):

for c in child:

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

else:

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

self._end_pos = pos

return pos

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

"""Debug helper method that returns a recursive string representation of this node.

"""

if cutoff == 0:

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

if encountered is None:

encountered = set()

if id(self) in encountered:

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

encountered.add(id(self))

def dump_child(x, level):

if isinstance(x, Node):

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

elif isinstance(x, list):

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

else:

return repr(x)

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

if len(attrs) == 0:

return "<%s (0x%x)>" % (self.__class__.__name__, id(self))

else:

indent = " " * level

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

for key, value in attrs:

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

res += "%s>" % indent

return res

def dump_pos(self, mark_column=False, marker='(#)'):

"""Debug helper method that returns the source code context of this node as a string.

"""

if not self.pos:

return u''

source_desc, line, col = self.pos

contents = source_desc.get_lines(encoding='ASCII',

error_handling='ignore')

# line numbers start at 1

lines = contents[max(0,line-3):line]

current = lines[-1]

if mark_column:

current = current[:col] + marker + current[col:]

lines[-1] = current.rstrip() + u' # <<<<<<<<<<<<<<\n'

lines += contents[line:line+2]

return u'"%s":%d:%d\n%s\n' % (

source_desc.get_escaped_description(), line, col, u''.join(lines))

class CompilerDirectivesNode(Node):

"""

Sets compiler directives for the children nodes

"""

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

# *all* possible directives.

# body Node

child_attrs = ["body"]

def analyse_declarations(self, env):

old = env.directives

env.directives = self.directives

self.body.analyse_declarations(env)

env.directives = old

def analyse_expressions(self, env):

old = env.directives

env.directives = self.directives

self.body = self.body.analyse_expressions(env)

env.directives = old

return self

def generate_function_definitions(self, env, code):

env_old = env.directives

code_old = code.globalstate.directives

code.globalstate.directives = self.directives

self.body.generate_function_definitions(env, code)

env.directives = env_old

code.globalstate.directives = code_old

def generate_execution_code(self, code):

old = code.globalstate.directives

code.globalstate.directives = self.directives

self.body.generate_execution_code(code)

code.globalstate.directives = old

def annotate(self, code):

old = code.globalstate.directives

code.globalstate.directives = self.directives

self.body.annotate(code)

code.globalstate.directives = old

class BlockNode(object):

# Mixin class for nodes representing a declaration block.

def generate_cached_builtins_decls(self, env, code):

entries = env.global_scope().undeclared_cached_builtins

for entry in entries:

code.globalstate.add_cached_builtin_decl(entry)

del entries[:]

def generate_lambda_definitions(self, env, code):

for node in env.lambda_defs:

node.generate_function_definitions(env, code)

class StatListNode(Node):

# stats a list of StatNode

child_attrs = ["stats"]

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

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

return node # No node-specific analysis necesarry

create_analysed = staticmethod(create_analysed)

def analyse_declarations(self, env):

#print "StatListNode.analyse_declarations" ###

for stat in self.stats:

stat.analyse_declarations(env)

def analyse_expressions(self, env):

#print "StatListNode.analyse_expressions" ###

self.stats = [ stat.analyse_expressions(env)

for stat in self.stats ]

return self

def generate_function_definitions(self, env, code):

#print "StatListNode.generate_function_definitions" ###

for stat in self.stats:

stat.generate_function_definitions(env, code)

def generate_execution_code(self, code):

#print "StatListNode.generate_execution_code" ###

for stat in self.stats:

code.mark_pos(stat.pos)

stat.generate_execution_code(code)

def annotate(self, code):

for stat in self.stats:

stat.annotate(code)

class StatNode(Node):

#

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

#

# (1) generate_function_definitions

# Emit C code for the definitions of any structs,

# unions, enums and functions defined in the current

# scope-block.

#

# (2) generate_execution_code

# Emit C code for executable statements.

#

def generate_function_definitions(self, env, code):

pass

def generate_execution_code(self, code):

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

self.__class__.__name__)

class CDefExternNode(StatNode):

# include_file string or None

# body StatNode

child_attrs = ["body"]

def analyse_declarations(self, env):

if self.include_file:

env.add_include_file(self.include_file)

old_cinclude_flag = env.in_cinclude

env.in_cinclude = 1

self.body.analyse_declarations(env)

env.in_cinclude = old_cinclude_flag

def analyse_expressions(self, env):

return self

def generate_execution_code(self, code):

pass

def annotate(self, code):

self.body.annotate(code)

class CDeclaratorNode(Node):

# Part of a C declaration.

#

# Processing during analyse_declarations phase:

#

# analyse

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

# CNameDeclaratorNode of the name being declared

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

#

# calling_convention string Calling convention of CFuncDeclaratorNode

# for which this is a base

child_attrs = []

calling_convention = ""

def analyse_templates(self):

# Only C++ functions have templates.

return None

class CNameDeclaratorNode(CDeclaratorNode):

# name string The Cython name being declared

# cname string or None C name, if specified

# default ExprNode or None the value assigned on declaration

child_attrs = ['default']

default = None

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

if nonempty and self.name == '':

# May have mistaken the name for the type.

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

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

elif base_type.is_void:

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

else:

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

base_type = py_object_type

if base_type.is_fused and env.fused_to_specific:

base_type = base_type.specialize(env.fused_to_specific)

self.type = base_type

return self, base_type

class CPtrDeclaratorNode(CDeclaratorNode):

# base CDeclaratorNode

child_attrs = ["base"]

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

if base_type.is_pyobject:

error(self.pos,

"Pointer base type cannot be a Python object")

ptr_type = PyrexTypes.c_ptr_type(base_type)

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

class CReferenceDeclaratorNode(CDeclaratorNode):

# base CDeclaratorNode

child_attrs = ["base"]

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

if base_type.is_pyobject:

error(self.pos,

"Reference base type cannot be a Python object")

ref_type = PyrexTypes.c_ref_type(base_type)

return self.base.analyse(ref_type, env, nonempty = nonempty)

class CArrayDeclaratorNode(CDeclaratorNode):

# base CDeclaratorNode

# dimension ExprNode

child_attrs = ["base", "dimension"]

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

if base_type.is_cpp_class or base_type.is_cfunction:

from ExprNodes import TupleNode

if isinstance(self.dimension, TupleNode):

args = self.dimension.args

else:

args = self.dimension,

values = [v.analyse_as_type(env) for v in args]

if None in values:

ix = values.index(None)

error(args[ix].pos, "Template parameter not a type")

base_type = error_type

else:

base_type = base_type.specialize_here(self.pos, values)

return self.base.analyse(base_type, env, nonempty = nonempty)

if self.dimension:

self.dimension = self.dimension.analyse_const_expression(env)

if not self.dimension.type.is_int:

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

size = self.dimension.get_constant_c_result_code()

if size is not None:

try:

size = int(size)

except ValueError:

# runtime constant?

pass

else:

size = None

if not base_type.is_complete():

error(self.pos,

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

if base_type.is_pyobject:

error(self.pos,

"Array element cannot be a Python object")

if base_type.is_cfunction:

error(self.pos,

"Array element cannot be a function")

array_type = PyrexTypes.c_array_type(base_type, size)

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

class CFuncDeclaratorNode(CDeclaratorNode):

# base CDeclaratorNode

# args [CArgDeclNode]

# templates [TemplatePlaceholderType]

# has_varargs boolean

# exception_value ConstNode

# exception_check boolean True if PyErr_Occurred check needed

# nogil boolean Can be called without gil

# with_gil boolean Acquire gil around function body

# is_const_method boolean Whether this is a const method

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

overridable = 0

optional_arg_count = 0

is_const_method = 0

templates = None

def analyse_templates(self):

if isinstance(self.base, CArrayDeclaratorNode):

from ExprNodes import TupleNode, NameNode

template_node = self.base.dimension

if isinstance(template_node, TupleNode):

template_nodes = template_node.args

elif isinstance(template_node, NameNode):

template_nodes = [template_node]

else:

error(template_node.pos, "Template arguments must be a list of names")

return None

self.templates = []

for template in template_nodes:

if isinstance(template, NameNode):

self.templates.append(PyrexTypes.TemplatePlaceholderType(template.name))

else:

error(template.pos, "Template arguments must be a list of names")

self.base = self.base.base

return self.templates

else:

return None

def analyse(self, return_type, env, nonempty = 0, directive_locals = {}):

if nonempty:

nonempty -= 1

func_type_args = []

for i, arg_node in enumerate(self.args):

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

is_self_arg = (i == 0 and env.is_c_class_scope))

name = name_declarator.name

if name in directive_locals:

type_node = directive_locals[name]

other_type = type_node.analyse_as_type(env)

if other_type is None:

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

elif (type is not PyrexTypes.py_object_type

and not type.same_as(other_type)):

error(self.base.pos, "Signature does not agree with previous declaration")

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

else:

type = other_type

if name_declarator.cname:

error(self.pos,

"Function argument cannot have C name specification")

if i==0 and env.is_c_class_scope and type.is_unspecified:

# fix the type of self

type = env.parent_type

# Turn *[] argument into **

if type.is_array:

type = PyrexTypes.c_ptr_type(type.base_type)

# Catch attempted C-style func(void) decl

if type.is_void:

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

func_type_args.append(

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

if arg_node.default:

self.optional_arg_count += 1

elif self.optional_arg_count:

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

exc_val = None

exc_check = 0

if self.exception_check == '+':

env.add_include_file('ios') # for std::ios_base::failure

env.add_include_file('new') # for std::bad_alloc

env.add_include_file('stdexcept')

env.add_include_file('typeinfo') # for std::bad_cast

if (return_type.is_pyobject

and (self.exception_value or self.exception_check)

and self.exception_check != '+'):

error(self.pos,

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

else:

if self.exception_value:

self.exception_value = self.exception_value.analyse_const_expression(env)

if self.exception_check == '+':

exc_val_type = self.exception_value.type

if (not exc_val_type.is_error

and not exc_val_type.is_pyobject

and not (exc_val_type.is_cfunction

and not exc_val_type.return_type.is_pyobject

and not exc_val_type.args)):

error(self.exception_value.pos,

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

exc_val = self.exception_value

else:

self.exception_value = self.exception_value.coerce_to(

return_type, env).analyse_const_expression(env)

exc_val = self.exception_value.get_constant_c_result_code()

if exc_val is None:

raise InternalError(

"get_constant_c_result_code not implemented for %s" %

self.exception_value.__class__.__name__)

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

error(self.exception_value.pos,

"Exception value incompatible with function return type")

exc_check = self.exception_check

if return_type.is_cfunction:

error(self.pos,

"Function cannot return a function")

func_type = PyrexTypes.CFuncType(

return_type, func_type_args, self.has_varargs,

optional_arg_count = self.optional_arg_count,

exception_value = exc_val, exception_check = exc_check,

calling_convention = self.base.calling_convention,

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

is_const_method = self.is_const_method,

templates = self.templates)

if self.optional_arg_count:

if func_type.is_fused:

# This is a bit of a hack... When we need to create specialized CFuncTypes

# on the fly because the cdef is defined in a pxd, we need to declare the specialized optional arg

# struct

def declare_opt_arg_struct(func_type, fused_cname):

self.declare_optional_arg_struct(func_type, env, fused_cname)

func_type.declare_opt_arg_struct = declare_opt_arg_struct

else:

self.declare_optional_arg_struct(func_type, env)

callspec = env.directives['callspec']

if callspec:

current = func_type.calling_convention

if current and current != callspec:

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

"calling conventions" % (current, callspec))

func_type.calling_convention = callspec

return self.base.analyse(func_type, env)

def declare_optional_arg_struct(self, func_type, env, fused_cname=None):

"""

Declares the optional argument struct (the struct used to hold the

values for optional arguments). For fused cdef functions, this is

deferred as analyse_declarations is called only once (on the fused

cdef function).

"""

scope = StructOrUnionScope()

arg_count_member = '%sn' % Naming.pyrex_prefix

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

for arg in func_type.args[len(func_type.args)-self.optional_arg_count:]:

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

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

if fused_cname is not None:

struct_cname = PyrexTypes.get_fused_cname(fused_cname, struct_cname)

op_args_struct = env.global_scope().declare_struct_or_union(

name = struct_cname,

kind = 'struct',

scope = scope,

typedef_flag = 0,

pos = self.pos,

cname = struct_cname)

op_args_struct.defined_in_pxd = 1

op_args_struct.used = 1

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

class CConstDeclaratorNode(CDeclaratorNode):

# base CDeclaratorNode

child_attrs = ["base"]

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

if base_type.is_pyobject:

error(self.pos,

"Const base type cannot be a Python object")

const = PyrexTypes.c_const_type(base_type)

return self.base.analyse(const, env, nonempty = nonempty)

class CArgDeclNode(Node):

# Item in a function declaration argument list.

#

# base_type CBaseTypeNode

# declarator CDeclaratorNode

# not_none boolean Tagged with 'not None'

# or_none boolean Tagged with 'or None'

# accept_none boolean Resolved boolean for not_none/or_none

# default ExprNode or None

# default_value PyObjectConst constant for default value

# annotation ExprNode or None Py3 function arg annotation

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

# is_type_arg boolean Is the "class" arg of an extension type classmethod

# is_kw_only boolean Is a keyword-only argument

# is_dynamic boolean Non-literal arg stored inside CyFunction

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

is_self_arg = 0

is_type_arg = 0

is_generic = 1

kw_only = 0

not_none = 0

or_none = 0

type = None

name_declarator = None

default_value = None

annotation = None

is_dynamic = 0

def analyse(self, env, nonempty = 0, is_self_arg = False):

if is_self_arg:

self.base_type.is_self_arg = self.is_self_arg = True

if self.type is None:

# The parser may misinterpret names as types. We fix that here.

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

if nonempty:

if self.base_type.is_basic_c_type:

# char, short, long called "int"

type = self.base_type.analyse(env, could_be_name = True)

arg_name = type.declaration_code("")

else:

arg_name = self.base_type.name

self.declarator.name = EncodedString(arg_name)

self.base_type.name = None

self.base_type.is_basic_c_type = False

could_be_name = True

else:

could_be_name = False

self.base_type.is_arg = True

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

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

self.declarator.name = self.base_type.arg_name

# The parser is unable to resolve the ambiguity of [] as part of the

# type (e.g. in buffers) or empty declarator (as with arrays).

# This is only arises for empty multi-dimensional arrays.

if (base_type.is_array

and isinstance(self.base_type, TemplatedTypeNode)

and isinstance(self.declarator, CArrayDeclaratorNode)):

declarator = self.declarator

while isinstance(declarator.base, CArrayDeclaratorNode):

declarator = declarator.base

declarator.base = self.base_type.array_declarator

base_type = base_type.base_type

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

else:

return self.name_declarator, self.type

def calculate_default_value_code(self, code):

if self.default_value is None:

if self.default:

if self.default.is_literal:

# will not output any code, just assign the result_code

self.default.generate_evaluation_code(code)

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

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

return self.default_value

def annotate(self, code):

if self.default:

self.default.annotate(code)

def generate_assignment_code(self, code, target=None):

default = self.default

if default is None or default.is_literal:

return

if target is None:

target = self.calculate_default_value_code(code)

default.generate_evaluation_code(code)

default.make_owned_reference(code)

result = default.result_as(self.type)

code.putln("%s = %s;" % (target, result))

if self.type.is_pyobject:

code.put_giveref(default.result())

default.generate_post_assignment_code(code)

default.free_temps(code)

class CBaseTypeNode(Node):

# Abstract base class for C base type nodes.

#

# Processing during analyse_declarations phase:

#

# analyse

# Returns the type.

pass

def analyse_as_type(self, env):

return self.analyse(env)

class CAnalysedBaseTypeNode(Node):

# type type

child_attrs = []

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

return self.type

class CSimpleBaseTypeNode(CBaseTypeNode):

# name string

# module_path [string] Qualifying name components

# is_basic_c_type boolean

# signed boolean

# longness integer

# complex boolean

# is_self_arg boolean Is self argument of C method

# ##is_type_arg boolean Is type argument of class method

child_attrs = []

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

module_path = []

is_basic_c_type = False

complex = False

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

# Return type descriptor.

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

type = None

if self.is_basic_c_type:

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

if not type:

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

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

type = py_object_type

elif self.name is None:

if self.is_self_arg and env.is_c_class_scope:

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

type = env.parent_type

## elif self.is_type_arg and env.is_c_class_scope:

## type = Builtin.type_type

else:

type = py_object_type

else:

if self.module_path:

# Maybe it's a nested C++ class.

scope = env

for item in self.module_path:

entry = scope.lookup(item)

if entry is not None and entry.is_cpp_class:

scope = entry.type.scope

else:

scope = None

break

if scope is None:

# Maybe it's a cimport.

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

if scope:

scope.fused_to_specific = env.fused_to_specific

else:

scope = env

if scope:

if scope.is_c_class_scope:

scope = scope.global_scope()

type = scope.lookup_type(self.name)

if type is not None:

pass

elif could_be_name:

if self.is_self_arg and env.is_c_class_scope:

type = env.parent_type

## elif self.is_type_arg and env.is_c_class_scope:

## type = Builtin.type_type

else:

type = py_object_type

self.arg_name = EncodedString(self.name)

else:

if self.templates:

if not self.name in self.templates:

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

type = PyrexTypes.TemplatePlaceholderType(self.name)

else:

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

if self.complex:

if not type.is_numeric or type.is_complex:

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

type = PyrexTypes.CComplexType(type)

type.create_declaration_utility_code(env)

elif type is Builtin.complex_type:

# Special case: optimise builtin complex type into C's

# double complex. The parser cannot do this (as for the

# normal scalar types) as the user may have redeclared the

# 'complex' type. Testing for the exact type here works.

type = PyrexTypes.c_double_complex_type

type.create_declaration_utility_code(env)

self.complex = True

if type:

return type

else:

return PyrexTypes.error_type

class MemoryViewSliceTypeNode(CBaseTypeNode):

name = 'memoryview'

child_attrs = ['base_type_node', 'axes']

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

base_type = self.base_type_node.analyse(env)

if base_type.is_error: return base_type

import MemoryView

try:

axes_specs = MemoryView.get_axes_specs(env, self.axes)

except CompileError, e:

error(e.position, e.message_only)

self.type = PyrexTypes.ErrorType()

return self.type

if not MemoryView.validate_axes(self.pos, axes_specs):

self.type = error_type

else:

MemoryView.validate_memslice_dtype(self.pos, base_type)

self.type = PyrexTypes.MemoryViewSliceType(base_type, axes_specs)