// do statically, as user code has explicit references (reads and
// writes) to stack variables. The compiler can do a simple dataflow
// analysis to determine liveness of stack variables at every point in
// the code. See cmd/compile/internal/gc/plive.go for that analysis.
//
// However, when we take the address of a stack variable, determining
// whether that variable is still live is less clear. We can still

export MINIO_IDENTITY_LDAP_TLS_SKIP_VERIFY=on
```

### Variable substitution in configuration strings

In the configuration variables, `%s` is substituted with the _username_ from the STS request and `%d` is substituted with the _distinguished username (user DN)_ of the LDAP user. Please see the following table for which configuration variables support these substitution variables:

| Variable                                    | Supported substitutions |

// FreezeSavedModel sets `frozen_graph_def` to a GraphDef of all nodes needed by
// `outputs`. All variables in the supplied SavedModelBundle are converted to
// constants, set to the value of the variables, by running the restored Session
// in the SavedModelBundle.
// WARNING: Only the variable checkpoints will be reflected in the frozen
// graph_def. All saved_model assets will be ignored.

// variable, and, if so, extracts:
//   - the minimum bound
//   - the increment value
//   - the "next" value (SSA value that is Phi'd into the induction variable every loop)
//
// Currently, we detect induction variables that match (Phi min nxt),
// with nxt being (Add inc ind).
// If it can't parse the induction variable correctly, it returns (nil, nil, nil).

// int* get_arr(char* arg, void* dummy)
// {return NULL;}
import "C"
import "unsafe"

// Test variables
var (
	checkedPointer            = []byte{1}
	doublePointerChecked      = []byte{1}
	singleInnerPointerChecked = []byte{1}
)

// This test checks the positions of variable identifiers.
// Changing the positions of the test variables idents after this point will break the test.

func TestSingleArgumentCast() C.int {

      // Handles tf.resource variables.
      TF_RET_CHECK(input->dtype() == DT_RESOURCE);
      const VariableInfo& variable = *variable_info_lookup[input_num];
      arg.kind = XlaCompiler::Argument::kResource;
      arg.resource_kind = XlaResource::kVariable;
      arg.definition_stack_trace = variable.definition_stack_trace();
      TF_RET_CHECK(variable.var() && variable.var()->is_initialized);

  switch (kind) {
    case SavedObject::kVariable: {
      const auto& variables_iter = objects.variables.find(node_id);
      if (variables_iter == objects.variables.end()) {
        return absl::FailedPreconditionError(absl::StrCat(
            "Tried to convert node id ", node_id,
            " of type variable to tensor but the variable wasn't initialized"));
      }

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

// Check that we don't crash due to "lost track of variable in
// liveness" errors against unused variables.

package p

import "strings"

// Minimized test case from github.com/mvdan/sh/syntax.
func F() {
	var _ = []string{
		strings.Repeat("\n\n\t\t        \n", 10) +

  // Whether to enable TFLite variables or not, this will allow
  // mutable variables and produce ReadVariable/AssignVariable ops in TFLite.
  bool enable_tflite_variables = false;
  // Whether to disable the variable freezing pass or not.
  // By default we freeze all variables and disallow mutable variables. When
  // 'enable_tflite_variables' is true then we allow mutable variable only.
  bool disable_variable_freezing = false;

[[sec:gradle_environment_variables]]
== Environment variables

Gradle provides a number of environment variables, which are listed below.

=== Setting environment variables

Let's take an example that sets the $JAVA_HOME environment variable:

[source,text]
----
$ set JAVA_HOME=C:\Path\To\Your\Java\Home   // Windows