math.Atan2(x, y)  // function call
var pt *Point
pt.Scale(3.5)     // method call with receiver pt
</pre>

<p>
In a function call, the function value and arguments are evaluated in
<a href="#Order_of_evaluation">the usual order</a>.
After they are evaluated, the parameters of the call are passed by value to the function
and the called function begins execution.
The return parameters of the function are passed by value

to a gcc-compiled function that can be called early during program
startup, and _cgo_thread_start to a gcc-compiled function that can be
used to create a new thread, in place of the runtime's usual direct
system calls.

Internal and External Linking

The text above describes "internal" linking, in which cmd/link parses and
links host object files (ELF, Mach-O, PE, and so on) into the final

pkg syscall (netbsd-arm64-cgo), const ETHERTYPE_VINESLOOP = 2990
pkg syscall (netbsd-arm64-cgo), const ETHERTYPE_VINESLOOP ideal-int
pkg syscall (netbsd-arm64-cgo), const ETHERTYPE_VITAL = 65280
pkg syscall (netbsd-arm64-cgo), const ETHERTYPE_VITAL ideal-int
pkg syscall (netbsd-arm64-cgo), const ETHERTYPE_VLAN = 33024
pkg syscall (netbsd-arm64-cgo), const ETHERTYPE_VLAN ideal-int

	//TODO: FISTTPLL (R11)                  // 41dd0b
	//TODO: FISUB (BX)                      // de23
	//TODO: FISUB (R11)                     // 41de23
	//TODO: FISUBL (BX)                     // da23
	//TODO: FISUBL (R11)                    // 41da23
	//TODO: FISUBR (BX)                     // de2b
	//TODO: FISUBR (R11)                    // 41de2b
	//TODO: FISUBRL (BX)                    // da2b

	if in.peek {
		in.peek = false
		tok := in.peekToken
		in.text = in.peekText
		return tok
	}
	// If we cannot generate a token after 100 macro invocations, we're in trouble.
	// The usual case is caught by Push, below, but be safe.
	for nesting := 0; nesting < 100; {
		tok := in.Stack.Next()
		switch tok {
		case '#':
			if !in.beginningOfLine {
				in.Error("'#' must be first item on line")
			}

// The panic built-in function stops normal execution of the current
// goroutine. When a function F calls panic, normal execution of F stops
// immediately. Any functions whose execution was deferred by F are run in
// the usual way, and then F returns to its caller. To the caller G, the
// invocation of F then behaves like a call to panic, terminating G's
// execution and running any deferred functions. This continues until all

	errorLine     int   // Line number of last error.
	errorCount    int   // Number of errors.
	sawCode       bool  // saw code in this file (as opposed to comments and blank lines)
	pc            int64 // virtual PC; count of Progs; doesn't advance for GLOBL or DATA.
	input         []lex.Token
	inputPos      int
	pendingLabels []string // Labels to attach to next instruction.
	labels        map[string]*obj.Prog
	toPatch       []Patch

<a href="#Instantiations">instantiated</a> before it can be called
or used as a function value.
</p>

<p>
In a function call, the function value and arguments are evaluated in
<a href="#Order_of_evaluation">the usual order</a>.
After they are evaluated, the parameters of the call are passed by value to the function
and the called function begins execution.
The return parameters of the function are passed by value

pkg syscall (netbsd-386), const ETHERTYPE_VINES = 2989
pkg syscall (netbsd-386), const ETHERTYPE_VINESECHO = 2991
pkg syscall (netbsd-386), const ETHERTYPE_VINESLOOP = 2990
pkg syscall (netbsd-386), const ETHERTYPE_VITAL = 65280
pkg syscall (netbsd-386), const ETHERTYPE_VLAN = 33024
pkg syscall (netbsd-386), const ETHERTYPE_VLTLMAN = 32896
pkg syscall (netbsd-386), const ETHERTYPE_VPROD = 32860

// 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.

class Callback {
public:
	virtual ~Callback() { }
	virtual std::string run() { return "Callback::run"; }
};

class Caller {
private:
	Callback *callback_;
public:
	Caller(): callback_(0) { }
	~Caller() { delCallback(); }
	void delCallback() { delete callback_; callback_ = 0; }