//
// CHECK:      node {
// CHECK-NEXT:   name: "rets_0"
// CHECK-NEXT:   op: "_Retval"
// CHECK-NOT:    device
// CHECK:        attr {
// CHECK:          key: "index"
// CHECK-NEXT:     value {
// CHECK-NEXT:       i: 0
//
// CHECK:      node {
// CHECK-NEXT:   name: "rets_1"
// CHECK-NEXT:   op: "_Retval"
// CHECK:        device: "/CPU:1"
// CHECK:        attr {
// CHECK:          key: "index"

    key: "index"
    value {
      i: 0
    }
  }
}
node {
  name: "ret1"
  op: "_Retval"
  input: "arg1"
  attr {
    key: "T"
    value {
      type: DT_INT32
    }
  }
  attr {
    key: "index"
    value {
      i: 1
    }
  }
}
node {
  name: "ret2"
  op: "_Retval"
  input: "arg2"
  attr {
    key: "T"
    value {
      type: DT_BOOL
    }
  }

}

func optionsCommand(rootCmd *cobra.Command) *cobra.Command {
	retval := &cobra.Command{
		Use:   "options",
		Short: "Displays istioctl global options",
		Args:  cobra.ExactArgs(0),
	}

	retval.SetHelpFunc(func(c *cobra.Command, args []string) {
		c.Printf("The following options can be passed to any command:\n")

// argset_t matches runtime/cgocall.go:argset.
typedef struct {
	uintptr_t* args;
	uintptr_t retval;
} argset_t;

// libc backed posix-compliant syscalls.

#define SET_RETVAL(fn) \
  uintptr_t ret = (uintptr_t) fn ; \
  if (ret == (uintptr_t) -1) {	   \
    x->retval = (uintptr_t) errno; \
  } else                           \
    x->retval = ret

void
_cgo_libc_setegid(argset_t* x) {
	SET_RETVAL(setegid((gid_t) x->args[0]));

    daemon --user $FESS_USER --pidfile="$pidfile" $exec -d
    retval=$?
    pid=`ps aux | grep "^${FESS_USER}" | grep "${PROC_NAME}" | sed 's/[\t ]\+/\t/g' | cut -f2`
    if [ -n "$pid" ]; then
        echo $pid > "$pidfile"
    fi
    echo
    [ $retval -eq 0 ] && touch $lockfile
    return $retval
}

stop() {
    echo -n $"Stopping $prog: "
    # stop it here, often "killproc $prog"

	}
	for _, pod := range pods.Items {
		retval[resource.Namespace(pod.GetNamespace())] = append(retval[resource.Namespace(pod.GetNamespace())], pod)
	}
	return retval, nil
}

// getInjectedImages() returns a map of revision->dockerimage
func getInjectedImages(ctx context.Context, client kube.CLIClient) (map[string]string, error) {
	retval := map[string]string{}

	// All configs in all namespaces that are Istio revisioned

        }

        def process = ["ls", "-ld", file.absolutePath].execute()
        def result = process.inputStream.text
        def error = process.errorStream.text
        def retval = process.waitFor()
        if (retval != 0) {
            throw new RuntimeException("Could not list permissions for '$file': $error")
        }
        def perms = result.split()[0]

  {
    tensorflow::Scope s = tensorflow::Scope::NewRootScope();
    Output arg = ops::_Arg(s.WithOpName("arg"), DT_INT32, 0);
    Output identity = ops::Identity(s.WithOpName("identity_true_fn"), arg);
    ops::_Retval retval(s.WithOpName("retval"), identity, 0);
    std::unique_ptr<Graph> g(new Graph(OpRegistry::Global()));
    TF_CHECK_OK(s.ToGraph(g.get()));
    auto node_name_image = g->BuildNodeNameIndex();

		// start with a generic forbidden error
		retval := admission.NewForbidden(a, errors.New("Not allowed by PodSecurity")).(*apierrors.StatusError)
		// use message/reason/details/code from admission library if populated
		if result.Result != nil {
			if len(result.Result.Message) > 0 {
				retval.ErrStatus.Message = result.Result.Message
			}
			if len(result.Result.Reason) > 0 {
				retval.ErrStatus.Reason = result.Result.Reason
			}

                        if (subResult != null) {
                            retVal += subResult;
                        } else {
                            retVal += "$" + expr.substring(index + 1, lastIndex + 1);
                        }
                    }

                    retVal += evaluate(expr.substring(lastIndex + 1));
                    return retVal;
                }
            }