}

// Follows the structure of Live-variable analysis. It is a form of
// CFG (Control Flow Graph) analysis, often used in compilers.
//
// A variable is live if it holds a value that may be used in the future.
// It is live-in at node n if it is live on any of the node's in-edges.
// It is live-out at node n if it is live on any of the node's out-edges.
// def[n] refers to values that are defined at node n.

// Once we're done processing all the pointers (including the ones we
// added during processing), we've found all the stack objects that
// are live. Any dead stack objects are not scanned and their contents
// will not keep heap objects live. Unlike the main garbage
// collection, we can't sweep the dead stack objects; they live on in
// a moribund state until the stack frame that contains them is
// popped.
//
// A stack can look like this:
//

	// Output:
	// Good morning, Gopher!
}

func ExampleExpandEnv() {
	os.Setenv("NAME", "gopher")
	os.Setenv("BURROW", "/usr/gopher")

	fmt.Println(os.ExpandEnv("$NAME lives in ${BURROW}."))

	// Output:
	// gopher lives in /usr/gopher.
}

func ExampleLookupEnv() {
	show := func(key string) {
		val, ok := os.LookupEnv(key)
		if !ok {
			fmt.Printf("%s not set\n", key)
		} else {

	p1.x[i] = j
	r += p1.x[j]
	p2.x[i] = j
	r += p2.x[j]
	if j != 505 {
		var xp3 Pointery2
		xp3.x[i] = j
		r += xp3.x[j]
	}

	if i == j*2 {
		// p2 live on this path
		p2.x[i] += j
		r += p2.x[j]
	} else {
		// p2 not live on this path
		var xp4 Pointery2
		xp4.x[i] = j
		r += xp4.x[j]
	}

	return r + G

## Docs

First, make sure you set up your environment as described above, that will install all the requirements.

### Docs live

During local development, there is a script that builds the site and checks for any changes, live-reloading:

<div class="termy">

```console
$ python ./scripts/docs.py live

<span style="color: green;">[INFO]</span> Serving on http://127.0.0.1:8008

     */
    PipedOutputStream getStdinPipe();

    /**
     * Returns the stdout output currently received from the build. This is live.
     */
    String getStandardOutput();

    /**
     * Returns the stderr output currently received from the build. This is live.
     */
    String getErrorOutput();

    /**
     * Forcefully kills the build and returns immediately. Does not block until the build has finished.

	}
	if getCalls != 1 {
		t.Errorf("Expected a live lookup of the namespace at t=forceLiveLookupTTL, got %d", getCalls)
	}
	getCalls = 0

	// Ensure the live lookup expires
	fakeClock.Step(time.Millisecond)

	// verify create operations in the namespace don't force a live lookup after the timeout

//go:registerparams
//go:noinline
func f(x int, xm1, xm2, p *int) {
	var y = [2]int{x - 4, 0}
	if x < 2 {
		*p += x
		return
	}
	x -= 3
	g(*xm1, xm2, &x, p)   // xm1 is no longer live.
	h(*xm2, &x, &y[0], p) // xm2 is no longer live, but was spilled.
}

//go:registerparams
//go:noinline
func g(x int, xm1, xm2, p *int) {
	var y = [3]int{x - 4, 0, 0}
	if x < 2 {
		*p += x
		return
	}
	x -= 3

// The liveness code used to say that, in func g, s was live
// starting at its declaration, because it appears to have its
// address taken by the closure (different s, but the parser
// gets slightly confused, a separate bug). The liveness analysis
// saw s as having its address taken but the register optimizer
// did not. This mismatch meant that s would be marked live
// (and therefore initialized) at the call to f, but the register optimizer

const (
	// PluginName indicates the name of admission plug-in
	PluginName = "NamespaceLifecycle"
	// how long a namespace stays in the force live lookup cache before expiration.
	forceLiveLookupTTL = 30 * time.Second
	// how long to wait for a missing namespace before re-checking the cache (and then doing a live lookup)
	// this accomplishes two things:
	// 1. It allows a watch-fed cache time to observe a namespace creation event