text: from __future__ import absolute_import
  
  from .Visitor import CythonTransform
  from .ModuleNode import ModuleNode
  from .Errors import CompileError
  from .UtilityCode import CythonUtilityCode
  from .Code import UtilityCode, TempitaUtilityCode
  
  from . import Options
  from . import Interpreter
  from . import PyrexTypes
  from . import Naming
  from . import Symtab
  
  def dedent(text, reindent=0):
      from textwrap import dedent
      text = dedent(text)
      if reindent > 0:
          indent = " " * reindent
          text = '\n'.join([indent + x for x in text.split('\n')])
      return text
  
  class IntroduceBufferAuxiliaryVars(CythonTransform):
  
      #
      # Entry point
      #
  
      buffers_exists = False
      using_memoryview = False
  
      def __call__(self, node):
          assert isinstance(node, ModuleNode)
          self.max_ndim = 0
          result = super(IntroduceBufferAuxiliaryVars, self).__call__(node)
          if self.buffers_exists:
              use_bufstruct_declare_code(node.scope)
              use_py2_buffer_functions(node.scope)
              node.scope.use_utility_code(empty_bufstruct_utility)
  
          return result
  
  
      #
      # Basic operations for transforms
      #
      def handle_scope(self, node, scope):
          # For all buffers, insert extra variables in the scope.
          # The variables are also accessible from the buffer_info
          # on the buffer entry
          scope_items = scope.entries.items()
          bufvars = [entry for name, entry in scope_items if entry.type.is_buffer]
          if len(bufvars) > 0:
              bufvars.sort(key=lambda entry: entry.name)
              self.buffers_exists = True
  
          memviewslicevars = [entry for name, entry in scope_items if entry.type.is_memoryviewslice]
          if len(memviewslicevars) > 0:
              self.buffers_exists = True
  
  
          for (name, entry) in scope_items:
              if name == 'memoryview' and isinstance(entry.utility_code_definition, CythonUtilityCode):
                  self.using_memoryview = True
                  break
          del scope_items
  
          if isinstance(node, ModuleNode) and len(bufvars) > 0:
              # for now...note that pos is wrong
              raise CompileError(node.pos, "Buffer vars not allowed in module scope")
          for entry in bufvars:
              if entry.type.dtype.is_ptr:
                  raise CompileError(node.pos, "Buffers with pointer types not yet supported.")
  
              name = entry.name
              buftype = entry.type
              if buftype.ndim > Options.buffer_max_dims:
                  raise CompileError(node.pos,
                          "Buffer ndims exceeds Options.buffer_max_dims = %d" % Options.buffer_max_dims)
              if buftype.ndim > self.max_ndim:
                  self.max_ndim = buftype.ndim
  
              # Declare auxiliary vars
              def decvar(type, prefix):
                  cname = scope.mangle(prefix, name)
                  aux_var = scope.declare_var(name=None, cname=cname,
                                              type=type, pos=node.pos)
                  if entry.is_arg:
                      aux_var.used = True # otherwise, NameNode will mark whether it is used
  
                  return aux_var
  
              auxvars = ((PyrexTypes.c_pyx_buffer_nd_type, Naming.pybuffernd_prefix),
                         (PyrexTypes.c_pyx_buffer_type, Naming.pybufferstruct_prefix))
              pybuffernd, rcbuffer = [decvar(type, prefix) for (type, prefix) in auxvars]
  
              entry.buffer_aux = Symtab.BufferAux(pybuffernd, rcbuffer)
  
          scope.buffer_entries = bufvars
          self.scope = scope
  
      def visit_ModuleNode(self, node):
          self.handle_scope(node, node.scope)
          self.visitchildren(node)
          return node
  
      def visit_FuncDefNode(self, node):
          self.handle_scope(node, node.local_scope)
          self.visitchildren(node)
          return node
  
  #
  # Analysis
  #
  buffer_options = ("dtype", "ndim", "mode", "negative_indices", "cast") # ordered!
  buffer_defaults = {"ndim": 1, "mode": "full", "negative_indices": True, "cast": False}
  buffer_positional_options_count = 1 # anything beyond this needs keyword argument
  
  ERR_BUF_OPTION_UNKNOWN = '"%s" is not a buffer option'
  ERR_BUF_TOO_MANY = 'Too many buffer options'
  ERR_BUF_DUP = '"%s" buffer option already supplied'
  ERR_BUF_MISSING = '"%s" missing'
  ERR_BUF_MODE = 'Only allowed buffer modes are: "c", "fortran", "full", "strided" (as a compile-time string)'
  ERR_BUF_NDIM = 'ndim must be a non-negative integer'
  ERR_BUF_DTYPE = 'dtype must be "object", numeric type or a struct'
  ERR_BUF_BOOL = '"%s" must be a boolean'
  
  def analyse_buffer_options(globalpos, env, posargs, dictargs, defaults=None, need_complete=True):
      """
      Must be called during type analysis, as analyse is called
      on the dtype argument.
  
      posargs and dictargs should consist of a list and a dict
      of tuples (value, pos). Defaults should be a dict of values.
  
      Returns a dict containing all the options a buffer can have and
      its value (with the positions stripped).
      """
      if defaults is None:
          defaults = buffer_defaults
  
      posargs, dictargs = Interpreter.interpret_compiletime_options(
          posargs, dictargs, type_env=env, type_args=(0, 'dtype'))
  
      if len(posargs) > buffer_positional_options_count:
          raise CompileError(posargs[-1][1], ERR_BUF_TOO_MANY)
  
      options = {}
      for name, (value, pos) in dictargs.items():
          if not name in buffer_options:
              raise CompileError(pos, ERR_BUF_OPTION_UNKNOWN % name)
          options[name] = value
  
      for name, (value, pos) in zip(buffer_options, posargs):
          if not name in buffer_options:
              raise CompileError(pos, ERR_BUF_OPTION_UNKNOWN % name)
          if name in options:
              raise CompileError(pos, ERR_BUF_DUP % name)
          options[name] = value
  
      # Check that they are all there and copy defaults
      for name in buffer_options:
          if not name in options:
              try:
                  options[name] = defaults[name]
              except KeyError:
                  if need_complete:
                      raise CompileError(globalpos, ERR_BUF_MISSING % name)
  
      dtype = options.get("dtype")
      if dtype and dtype.is_extension_type:
          raise CompileError(globalpos, ERR_BUF_DTYPE)
  
      ndim = options.get("ndim")
      if ndim and (not isinstance(ndim, int) or ndim < 0):
          raise CompileError(globalpos, ERR_BUF_NDIM)
  
      mode = options.get("mode")
      if mode and not (mode in ('full', 'strided', 'c', 'fortran')):
          raise CompileError(globalpos, ERR_BUF_MODE)
  
      def assert_bool(name):
          x = options.get(name)
          if not isinstance(x, bool):
              raise CompileError(globalpos, ERR_BUF_BOOL % name)
  
      assert_bool('negative_indices')
      assert_bool('cast')
  
      return options
  
  
  #
  # Code generation
  #
  
  class BufferEntry(object):
      def __init__(self, entry):
          self.entry = entry
          self.type = entry.type
          self.cname = entry.buffer_aux.buflocal_nd_var.cname
          self.buf_ptr = "%s.rcbuffer->pybuffer.buf" % self.cname
          self.buf_ptr_type = entry.type.buffer_ptr_type
          self.init_attributes()
  
      def init_attributes(self):
          self.shape = self.get_buf_shapevars()
          self.strides = self.get_buf_stridevars()
          self.suboffsets = self.get_buf_suboffsetvars()
  
      def get_buf_suboffsetvars(self):
          return self._for_all_ndim("%s.diminfo[%d].suboffsets")
  
      def get_buf_stridevars(self):
          return self._for_all_ndim("%s.diminfo[%d].strides")
  
      def get_buf_shapevars(self):
          return self._for_all_ndim("%s.diminfo[%d].shape")
  
      def _for_all_ndim(self, s):
          return [s % (self.cname, i) for i in range(self.type.ndim)]
  
      def generate_buffer_lookup_code(self, code, index_cnames):
          # Create buffer lookup and return it
          # This is done via utility macros/inline functions, which vary
          # according to the access mode used.
          params = []
          nd = self.type.ndim
          mode = self.type.mode
          if mode == 'full':
              for i, s, o in zip(index_cnames,
                                 self.get_buf_stridevars(),
                                 self.get_buf_suboffsetvars()):
                  params.append(i)
                  params.append(s)
                  params.append(o)
              funcname = "__Pyx_BufPtrFull%dd" % nd
              funcgen = buf_lookup_full_code
          else:
              if mode == 'strided':
                  funcname = "__Pyx_BufPtrStrided%dd" % nd
                  funcgen = buf_lookup_strided_code
              elif mode == 'c':
                  funcname = "__Pyx_BufPtrCContig%dd" % nd
                  funcgen = buf_lookup_c_code
              elif mode == 'fortran':
                  funcname = "__Pyx_BufPtrFortranContig%dd" % nd
                  funcgen = buf_lookup_fortran_code
              else:
                  assert False
              for i, s in zip(index_cnames, self.get_buf_stridevars()):
                  params.append(i)
                  params.append(s)
  
          # Make sure the utility code is available
          if funcname not in code.globalstate.utility_codes:
              code.globalstate.utility_codes.add(funcname)
              protocode = code.globalstate['utility_code_proto']
              defcode = code.globalstate['utility_code_def']
              funcgen(protocode, defcode, name=funcname, nd=nd)
  
          buf_ptr_type_code = self.buf_ptr_type.empty_declaration_code()
          ptrcode = "%s(%s, %s, %s)" % (funcname, buf_ptr_type_code, self.buf_ptr,
                                        ", ".join(params))
          return ptrcode
  
  
  def get_flags(buffer_aux, buffer_type):
      flags = 'PyBUF_FORMAT'
      mode = buffer_type.mode
      if mode == 'full':
          flags += '| PyBUF_INDIRECT'
      elif mode == 'strided':
          flags += '| PyBUF_STRIDES'
      elif mode == 'c':
          flags += '| PyBUF_C_CONTIGUOUS'
      elif mode == 'fortran':
          flags += '| PyBUF_F_CONTIGUOUS'
      else:
          assert False
      if buffer_aux.writable_needed: flags += "| PyBUF_WRITABLE"
      return flags
  
  def used_buffer_aux_vars(entry):
      buffer_aux = entry.buffer_aux
      buffer_aux.buflocal_nd_var.used = True
      buffer_aux.rcbuf_var.used = True
  
  def put_unpack_buffer_aux_into_scope(buf_entry, code):
      # Generate code to copy the needed struct info into local
      # variables.
      buffer_aux, mode = buf_entry.buffer_aux, buf_entry.type.mode
      pybuffernd_struct = buffer_aux.buflocal_nd_var.cname
  
      fldnames = ['strides', 'shape']
      if mode == 'full':
          fldnames.append('suboffsets')
  
      ln = []
      for i in range(buf_entry.type.ndim):
          for fldname in fldnames:
              ln.append("%s.diminfo[%d].%s = %s.rcbuffer->pybuffer.%s[%d];" % \
                      (pybuffernd_struct, i, fldname,
                       pybuffernd_struct, fldname, i))
      code.putln(' '.join(ln))
  
  def put_init_vars(entry, code):
      bufaux = entry.buffer_aux
      pybuffernd_struct = bufaux.buflocal_nd_var.cname
      pybuffer_struct = bufaux.rcbuf_var.cname
      # init pybuffer_struct
      code.putln("%s.pybuffer.buf = NULL;" % pybuffer_struct)
      code.putln("%s.refcount = 0;" % pybuffer_struct)
      # init the buffer object
      # code.put_init_var_to_py_none(entry)
      # init the pybuffernd_struct
      code.putln("%s.data = NULL;" % pybuffernd_struct)
      code.putln("%s.rcbuffer = &%s;" % (pybuffernd_struct, pybuffer_struct))
  
  def put_acquire_arg_buffer(entry, code, pos):
      code.globalstate.use_utility_code(acquire_utility_code)
      buffer_aux = entry.buffer_aux
      getbuffer = get_getbuffer_call(code, entry.cname, buffer_aux, entry.type)
  
      # Acquire any new buffer
      code.putln("{")
      code.putln("__Pyx_BufFmt_StackElem __pyx_stack[%d];" % entry.type.dtype.struct_nesting_depth())
      code.putln(code.error_goto_if("%s == -1" % getbuffer, pos))
      code.putln("}")
      # An exception raised in arg parsing cannot be catched, so no
      # need to care about the buffer then.
      put_unpack_buffer_aux_into_scope(entry, code)
  
  def put_release_buffer_code(code, entry):
      code.globalstate.use_utility_code(acquire_utility_code)
      code.putln("__Pyx_SafeReleaseBuffer(&%s.rcbuffer->pybuffer);" % entry.buffer_aux.buflocal_nd_var.cname)
  
  def get_getbuffer_call(code, obj_cname, buffer_aux, buffer_type):
      ndim = buffer_type.ndim
      cast = int(buffer_type.cast)
      flags = get_flags(buffer_aux, buffer_type)
      pybuffernd_struct = buffer_aux.buflocal_nd_var.cname
  
      dtype_typeinfo = get_type_information_cname(code, buffer_type.dtype)
  
      return ("__Pyx_GetBufferAndValidate(&%(pybuffernd_struct)s.rcbuffer->pybuffer, "
              "(PyObject*)%(obj_cname)s, &%(dtype_typeinfo)s, %(flags)s, %(ndim)d, "
              "%(cast)d, __pyx_stack)" % locals())
  
  def put_assign_to_buffer(lhs_cname, rhs_cname, buf_entry,
                           is_initialized, pos, code):
      """
      Generate code for reassigning a buffer variables. This only deals with getting
      the buffer auxiliary structure and variables set up correctly, the assignment
      itself and refcounting is the responsibility of the caller.
  
      However, the assignment operation may throw an exception so that the reassignment
      never happens.
  
      Depending on the circumstances there are two possible outcomes:
      - Old buffer released, new acquired, rhs assigned to lhs
      - Old buffer released, new acquired which fails, reaqcuire old lhs buffer
        (which may or may not succeed).
      """
  
      buffer_aux, buffer_type = buf_entry.buffer_aux, buf_entry.type
      code.globalstate.use_utility_code(acquire_utility_code)
      pybuffernd_struct = buffer_aux.buflocal_nd_var.cname
      flags = get_flags(buffer_aux, buffer_type)
  
      code.putln("{")  # Set up necesarry stack for getbuffer
      code.putln("__Pyx_BufFmt_StackElem __pyx_stack[%d];" % buffer_type.dtype.struct_nesting_depth())
  
      getbuffer = get_getbuffer_call(code, "%s", buffer_aux, buffer_type) # fill in object below
  
      if is_initialized:
          # Release any existing buffer
          code.putln('__Pyx_SafeReleaseBuffer(&%s.rcbuffer->pybuffer);' % pybuffernd_struct)
          # Acquire
          retcode_cname = code.funcstate.allocate_temp(PyrexTypes.c_int_type, manage_ref=False)
          code.putln("%s = %s;" % (retcode_cname, getbuffer % rhs_cname))
          code.putln('if (%s) {' % (code.unlikely("%s < 0" % retcode_cname)))
          # If acquisition failed, attempt to reacquire the old buffer
          # before raising the exception. A failure of reacquisition
          # will cause the reacquisition exception to be reported, one
          # can consider working around this later.
          type, value, tb = [code.funcstate.allocate_temp(PyrexTypes.py_object_type, manage_ref=False)
                             for i in range(3)]
          code.putln('PyErr_Fetch(&%s, &%s, &%s);' % (type, value, tb))
          code.putln('if (%s) {' % code.unlikely("%s == -1" % (getbuffer % lhs_cname)))
          code.putln('Py_XDECREF(%s); Py_XDECREF(%s); Py_XDECREF(%s);' % (type, value, tb)) # Do not refnanny these!
          code.globalstate.use_utility_code(raise_buffer_fallback_code)
          code.putln('__Pyx_RaiseBufferFallbackError();')
          code.putln('} else {')
          code.putln('PyErr_Restore(%s, %s, %s);' % (type, value, tb))
          for t in (type, value, tb):
              code.funcstate.release_temp(t)
          code.putln('}')
          code.putln('}')
          # Unpack indices
          put_unpack_buffer_aux_into_scope(buf_entry, code)
          code.putln(code.error_goto_if_neg(retcode_cname, pos))
          code.funcstate.release_temp(retcode_cname)
      else:
          # Our entry had no previous value, so set to None when acquisition fails.
          # In this case, auxiliary vars should be set up right in initialization to a zero-buffer,
          # so it suffices to set the buf field to NULL.
          code.putln('if (%s) {' % code.unlikely("%s == -1" % (getbuffer % rhs_cname)))
          code.putln('%s = %s; __Pyx_INCREF(Py_None); %s.rcbuffer->pybuffer.buf = NULL;' %
                     (lhs_cname,
                      PyrexTypes.typecast(buffer_type, PyrexTypes.py_object_type, "Py_None"),
                      pybuffernd_struct))
          code.putln(code.error_goto(pos))
          code.put('} else {')
          # Unpack indices
          put_unpack_buffer_aux_into_scope(buf_entry, code)
          code.putln('}')
  
      code.putln("}") # Release stack
  
  
  def put_buffer_lookup_code(entry, index_signeds, index_cnames, directives,
                             pos, code, negative_indices, in_nogil_context):
      """
      Generates code to process indices and calculate an offset into
      a buffer. Returns a C string which gives a pointer which can be
      read from or written to at will (it is an expression so caller should
      store it in a temporary if it is used more than once).
  
      As the bounds checking can have any number of combinations of unsigned
      arguments, smart optimizations etc. we insert it directly in the function
      body. The lookup however is delegated to a inline function that is instantiated
      once per ndim (lookup with suboffsets tend to get quite complicated).
  
      entry is a BufferEntry
      """
      negative_indices = directives['wraparound'] and negative_indices
  
      if directives['boundscheck']:
          # Check bounds and fix negative indices.
          # We allocate a temporary which is initialized to -1, meaning OK (!).
          # If an error occurs, the temp is set to the index dimension the
          # error is occurring at.
          failed_dim_temp = code.funcstate.allocate_temp(PyrexTypes.c_int_type, manage_ref=False)
          code.putln("%s = -1;" % failed_dim_temp)
          for dim, (signed, cname, shape) in enumerate(zip(index_signeds, index_cnames, entry.get_buf_shapevars())):
              if signed != 0:
                  # not unsigned, deal with negative index
                  code.putln("if (%s < 0) {" % cname)
                  if negative_indices:
                      code.putln("%s += %s;" % (cname, shape))
                      code.putln("if (%s) %s = %d;" % (
                          code.unlikely("%s < 0" % cname),
                          failed_dim_temp, dim))
                  else:
                      code.putln("%s = %d;" % (failed_dim_temp, dim))
                  code.put("} else ")
              # check bounds in positive direction
              if signed != 0:
                  cast = ""
              else:
                  cast = "(size_t)"
              code.putln("if (%s) %s = %d;" % (
                  code.unlikely("%s >= %s%s" % (cname, cast, shape)),
                  failed_dim_temp, dim))
  
          if in_nogil_context:
              code.globalstate.use_utility_code(raise_indexerror_nogil)
              func = '__Pyx_RaiseBufferIndexErrorNogil'
          else:
              code.globalstate.use_utility_code(raise_indexerror_code)
              func = '__Pyx_RaiseBufferIndexError'
  
          code.putln("if (%s) {" % code.unlikely("%s != -1" % failed_dim_temp))
          code.putln('%s(%s);' % (func, failed_dim_temp))
          code.putln(code.error_goto(pos))
          code.putln('}')
          code.funcstate.release_temp(failed_dim_temp)
      elif negative_indices:
          # Only fix negative indices.
          for signed, cname, shape in zip(index_signeds, index_cnames, entry.get_buf_shapevars()):
              if signed != 0:
                  code.putln("if (%s < 0) %s += %s;" % (cname, cname, shape))
  
      return entry.generate_buffer_lookup_code(code, index_cnames)
  
  
  def use_bufstruct_declare_code(env):
      env.use_utility_code(buffer_struct_declare_code)
  
  
  def get_empty_bufstruct_code(max_ndim):
      code = dedent("""
          static Py_ssize_t __Pyx_zeros[] = {%s};
          static Py_ssize_t __Pyx_minusones[] = {%s};
      """) % (", ".join(["0"] * max_ndim), ", ".join(["-1"] * max_ndim))
      return UtilityCode(proto=code)
  
  empty_bufstruct_utility = get_empty_bufstruct_code(Options.buffer_max_dims)
  
  def buf_lookup_full_code(proto, defin, name, nd):
      """
      Generates a buffer lookup function for the right number
      of dimensions. The function gives back a void* at the right location.
      """
      # _i_ndex, _s_tride, sub_o_ffset
      macroargs = ", ".join(["i%d, s%d, o%d" % (i, i, i) for i in range(nd)])
      proto.putln("#define %s(type, buf, %s) (type)(%s_imp(buf, %s))" % (name, macroargs, name, macroargs))
  
      funcargs = ", ".join(["Py_ssize_t i%d, Py_ssize_t s%d, Py_ssize_t o%d" % (i, i, i) for i in range(nd)])
      proto.putln("static CYTHON_INLINE void* %s_imp(void* buf, %s);" % (name, funcargs))
      defin.putln(dedent("""
          static CYTHON_INLINE void* %s_imp(void* buf, %s) {
            char* ptr = (char*)buf;
          """) % (name, funcargs) + "".join([dedent("""\
            ptr += s%d * i%d;
            if (o%d >= 0) ptr = *((char**)ptr) + o%d;
          """) % (i, i, i, i) for i in range(nd)]
          ) + "\nreturn ptr;\n}")
  
  def buf_lookup_strided_code(proto, defin, name, nd):
      """
      Generates a buffer lookup function for the right number
      of dimensions. The function gives back a void* at the right location.
      """
      # _i_ndex, _s_tride
      args = ", ".join(["i%d, s%d" % (i, i) for i in range(nd)])
      offset = " + ".join(["i%d * s%d" % (i, i) for i in range(nd)])
      proto.putln("#define %s(type, buf, %s) (type)((char*)buf + %s)" % (name, args, offset))
  
  def buf_lookup_c_code(proto, defin, name, nd):
      """
      Similar to strided lookup, but can assume that the last dimension
      doesn't need a multiplication as long as.
      Still we keep the same signature for now.
      """
      if nd == 1:
          proto.putln("#define %s(type, buf, i0, s0) ((type)buf + i0)" % name)
      else:
          args = ", ".join(["i%d, s%d" % (i, i) for i in range(nd)])
          offset = " + ".join(["i%d * s%d" % (i, i) for i in range(nd - 1)])
          proto.putln("#define %s(type, buf, %s) ((type)((char*)buf + %s) + i%d)" % (name, args, offset, nd - 1))
  
  def buf_lookup_fortran_code(proto, defin, name, nd):
      """
      Like C lookup, but the first index is optimized instead.
      """
      if nd == 1:
          proto.putln("#define %s(type, buf, i0, s0) ((type)buf + i0)" % name)
      else:
          args = ", ".join(["i%d, s%d" % (i, i) for i in range(nd)])
          offset = " + ".join(["i%d * s%d" % (i, i) for i in range(1, nd)])
          proto.putln("#define %s(type, buf, %s) ((type)((char*)buf + %s) + i%d)" % (name, args, offset, 0))
  
  
  def use_py2_buffer_functions(env):
      env.use_utility_code(GetAndReleaseBufferUtilityCode())
  
  class GetAndReleaseBufferUtilityCode(object):
      # Emulation of PyObject_GetBuffer and PyBuffer_Release for Python 2.
      # For >= 2.6 we do double mode -- use the new buffer interface on objects
      # which has the right tp_flags set, but emulation otherwise.
  
      requires = None
      is_cython_utility = False
  
      def __init__(self):
          pass
  
      def __eq__(self, other):
          return isinstance(other, GetAndReleaseBufferUtilityCode)
  
      def __hash__(self):
          return 24342342
  
      def get_tree(self, **kwargs): pass
  
      def put_code(self, output):
          code = output['utility_code_def']
          proto_code = output['utility_code_proto']
          env = output.module_node.scope
          cython_scope = env.context.cython_scope
  
          # Search all types for __getbuffer__ overloads
          types = []
          visited_scopes = set()
          def find_buffer_types(scope):
              if scope in visited_scopes:
                  return
              visited_scopes.add(scope)
              for m in scope.cimported_modules:
                  find_buffer_types(m)
              for e in scope.type_entries:
                  if isinstance(e.utility_code_definition, CythonUtilityCode):
                      continue
                  t = e.type
                  if t.is_extension_type:
                      if scope is cython_scope and not e.used:
                          continue
                      release = get = None
                      for x in t.scope.pyfunc_entries:
                          if x.name == u"__getbuffer__": get = x.func_cname
                          elif x.name == u"__releasebuffer__": release = x.func_cname
                      if get:
                          types.append((t.typeptr_cname, get, release))
  
          find_buffer_types(env)
  
          util_code = TempitaUtilityCode.load(
              "GetAndReleaseBuffer", from_file="Buffer.c",
              context=dict(types=types))
  
          proto = util_code.format_code(util_code.proto)
          impl = util_code.format_code(
              util_code.inject_string_constants(util_code.impl, output)[1])
  
          proto_code.putln(proto)
          code.putln(impl)
  
  
  def mangle_dtype_name(dtype):
      # Use prefixes to seperate user defined types from builtins
      # (consider "typedef float unsigned_int")
      if dtype.is_pyobject:
          return "object"
      elif dtype.is_ptr:
          return "ptr"
      else:
          if dtype.is_typedef or dtype.is_struct_or_union:
              prefix = "nn_"
          else:
              prefix = ""
          return prefix + dtype.specialization_name()
  
  def get_type_information_cname(code, dtype, maxdepth=None):
      """
      Output the run-time type information (__Pyx_TypeInfo) for given dtype,
      and return the name of the type info struct.
  
      Structs with two floats of the same size are encoded as complex numbers.
      One can seperate between complex numbers declared as struct or with native
      encoding by inspecting to see if the fields field of the type is
      filled in.
      """
      namesuffix = mangle_dtype_name(dtype)
      name = "__Pyx_TypeInfo_%s" % namesuffix
      structinfo_name = "__Pyx_StructFields_%s" % namesuffix
  
      if dtype.is_error: return "<error>"
  
      # It's critical that walking the type info doesn't use more stack
      # depth than dtype.struct_nesting_depth() returns, so use an assertion for this
      if maxdepth is None: maxdepth = dtype.struct_nesting_depth()
      if maxdepth <= 0:
          assert False
  
      if name not in code.globalstate.utility_codes:
          code.globalstate.utility_codes.add(name)
          typecode = code.globalstate['typeinfo']
  
          arraysizes = []
          if dtype.is_array:
              while dtype.is_array:
                  arraysizes.append(dtype.size)
                  dtype = dtype.base_type
  
          complex_possible = dtype.is_struct_or_union and dtype.can_be_complex()
  
          declcode = dtype.empty_declaration_code()
          if dtype.is_simple_buffer_dtype():
              structinfo_name = "NULL"
          elif dtype.is_struct:
              fields = dtype.scope.var_entries
              # Must pre-call all used types in order not to recurse utility code
              # writing.
              assert len(fields) > 0
              types = [get_type_information_cname(code, f.type, maxdepth - 1)
                       for f in fields]
              typecode.putln("static __Pyx_StructField %s[] = {" % structinfo_name, safe=True)
              for f, typeinfo in zip(fields, types):
                  typecode.putln('  {&%s, "%s", offsetof(%s, %s)},' %
                             (typeinfo, f.name, dtype.empty_declaration_code(), f.cname), safe=True)
              typecode.putln('  {NULL, NULL, 0}', safe=True)
              typecode.putln("};", safe=True)
          else:
              assert False
  
          rep = str(dtype)
  
          flags = "0"
          is_unsigned = "0"
          if dtype is PyrexTypes.c_char_type:
              is_unsigned = "IS_UNSIGNED(%s)" % declcode
              typegroup = "'H'"
          elif dtype.is_int:
              is_unsigned = "IS_UNSIGNED(%s)" % declcode
              typegroup = "%s ? 'U' : 'I'" % is_unsigned
          elif complex_possible or dtype.is_complex:
              typegroup = "'C'"
          elif dtype.is_float:
              typegroup = "'R'"
          elif dtype.is_struct:
              typegroup = "'S'"
              if dtype.packed:
                  flags = "__PYX_BUF_FLAGS_PACKED_STRUCT"
          elif dtype.is_pyobject:
              typegroup = "'O'"
          else:
              assert False, dtype
  
          typeinfo = ('static __Pyx_TypeInfo %s = '
                          '{ "%s", %s, sizeof(%s), { %s }, %s, %s, %s, %s };')
          tup = (name, rep, structinfo_name, declcode,
                 ', '.join([str(x) for x in arraysizes]) or '0', len(arraysizes),
                 typegroup, is_unsigned, flags)
          typecode.putln(typeinfo % tup, safe=True)
  
      return name
  
  def load_buffer_utility(util_code_name, context=None, **kwargs):
      if context is None:
          return UtilityCode.load(util_code_name, "Buffer.c", **kwargs)
      else:
          return TempitaUtilityCode.load(util_code_name, "Buffer.c", context=context, **kwargs)
  
  context = dict(max_dims=str(Options.buffer_max_dims))
  buffer_struct_declare_code = load_buffer_utility("BufferStructDeclare",
                                                   context=context)
  
  
  # Utility function to set the right exception
  # The caller should immediately goto_error
  raise_indexerror_code = load_buffer_utility("BufferIndexError")
  raise_indexerror_nogil = load_buffer_utility("BufferIndexErrorNogil")
  
  raise_buffer_fallback_code = load_buffer_utility("BufferFallbackError")
  buffer_structs_code = load_buffer_utility(
          "BufferFormatStructs", proto_block='utility_code_proto_before_types')
  acquire_utility_code = load_buffer_utility("BufferFormatCheck",
                                             context=context,
                                             requires=[buffer_structs_code])
  
  # See utility code BufferFormatFromTypeInfo
  _typeinfo_to_format_code = load_buffer_utility("TypeInfoToFormat", context={},
                                                 requires=[buffer_structs_code])
  typeinfo_compare_code = load_buffer_utility("TypeInfoCompare", context={},
                                              requires=[buffer_structs_code])
  