// Create a custom split function by wrapping the existing ScanWords function.
	split := func(data []byte, atEOF bool) (advance int, token []byte, err error) {
		advance, token, err = bufio.ScanWords(data, atEOF)
		if err == nil && token != nil {
			_, err = strconv.ParseInt(string(token), 10, 32)
		}
		return
	}
	// Set the split function for the scanning operation.
	scanner.Split(split)

when the function is invoked, not when the "defer" statement is executed.
</p>

<p>
For instance, if the deferred function is
a <a href="#Function_literals">function literal</a> and the surrounding
function has <a href="#Function_types">named result parameters</a> that
are in scope within the literal, the deferred function may access and modify
the result parameters before they are returned.

#ifdef _AMD64_
	CONTEXT context;
	RtlCaptureContext(&context);
	ULONG64 ControlPc;
	ControlPc = context.Rip;
	int i;
	for (i = 0; i < FramesToCapture; i++) {
		PRUNTIME_FUNCTION FunctionEntry;
		ULONG64 ImageBase;
		VOID *HandlerData;
		ULONG64 EstablisherFrame;

		FunctionEntry = RtlLookupFunctionEntry(ControlPc, &ImageBase, NULL);

		if (!FunctionEntry) {

The [SliceAt(typ Type, p unsafe.Pointer, len int)] function
returns a Value representing a slice whose underlying array starts

func nestedCall(f func()) {
	// callback(x) calls goCallback(x)
	callbackMutex.Lock()
	callbackToken++
	i := callbackToken
	callbackFuncs[i] = f
	callbackMutex.Unlock()

	// Pass the address of i because the C function was written to
	// take a pointer.  We could pass an int if we felt like
	// rewriting the C code.
	C.callback(unsafe.Pointer(&i))

	callbackMutex.Lock()
	delete(callbackFuncs, i)
	callbackMutex.Unlock()
}

/* Copyright 2011 The Go Authors. All rights reserved.
   Use of this source code is governed by a BSD-style
   license that can be found in the LICENSE file.  */

/* An example of writing a C++ virtual function in Go.  */

%module(directors="1") callback

%{
#include <string>
#include "main.h"
%}

%include "std_string.i"

%feature("director");

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include "_cgo_export.h"

/* Test calling a Go function with multiple return values.  */

void
callMulti(void)
{
	struct multi_return result = multi();
	assert(strcmp(result.r0, "multi") == 0);
	assert(result.r1 == 0);
	free(result.r0);

The [Repeat] function returns a new slice that repeats the

	//            C.f(_cgo0)
	//    }()
	// Using a function literal like this lets us evaluate the
	// function arguments only once while doing pointer checks.
	// This is particularly useful when passing additional arguments
	// to _cgoCheckPointer, as done in checkIndex and checkAddr.
	//
	// When the function argument is a conversion to unsafe.Pointer,

The [RuneLen] function returns the number of 16-bit words in
the UTF-16 encoding of the rune. It returns -1 if the rune