*/
    VERBOSE,
    /**
     * -quiet
     *
     * Shuts off non-error and non-warning messages, leaving only the warnings and errors appear,
     * making them easier to view. Also suppresses the version string.
     */
    QUIET

		if len(results) != 0 {
			warnings = append(warnings, v1.ExpressionWarning{
				FieldRef: fieldRef.Index(i).Child("expression").String(),
				Warning:  results.String(),
			})
		}
		// Note that MessageExpression is optional
		if v.MessageExpression == "" {
			continue
		}
		results = c.CheckExpression(ctx, v.MessageExpression)
		if len(results) != 0 {
			warnings = append(warnings, v1.ExpressionWarning{

	return err
}

// WarningsOnCreate returns warnings for the creation of the given object.
func (endpointSliceStrategy) WarningsOnCreate(ctx context.Context, obj runtime.Object) []string {
	eps := obj.(*discovery.EndpointSlice)
	if eps == nil {
		return nil
	}
	var warnings []string
	warnings = append(warnings, warnOnDeprecatedAddressType(eps.AddressType)...)
	return warnings
}

            return ResolvedCoordinates.create(resolved);
        }

        if (mappings.incompatibleModules.contains(key)) {
            // TODO: We should enhance this warning to list the conflicting dependencies.
            warnings.addIncompatible(String.format(
                "Cannot determine variant coordinates for dependency '%s' since " +

		// Could not probe the kernel version
		return false
	}

	if currentKernel == 0 {
		// We could not get any valid value return false
		return false
	}

	// legacy linux indicator for printing warnings
	// about older Linux kernels and Go runtime.
	return currentKernel < kernel.Version(4, 0, 0)
}

func setMaxResources(ctx serverCtxt) (err error) {
	// Set the Go runtime max threads threshold to 90% of kernel setting.

`-S` or `--full-stacktrace`::
The full stacktraces are printed out. This option renders stacktraces for deprecation warnings.

<No stacktrace options>::

     *
     * If a configuration with this name already exists this method will <strong>overwrite</strong> its current usage to match what
     * would be set if the configuration needed to be created and emit an additional deprecation warning when doing this
     * <strong>IFF</strong> {@code verifyPrexisting} is set to {@code true}.
     */

        System_Ext(editorDependencies, "Dependencies", "classpath, sourcepath, implicit imports")
        System_Ext(editorReportPanel, "Report Panel", "Displays warnings and errors on top of the editor UI")
        System_Ext(editorHints, "Inline Hints", "Displays warning and error hints inline in the editor UI")
    }

    System_Ext(ideKotlin, "IntelliJ Kotlin Plugin", "for IDEA or Android Studio")

    Rel(editor, ideKotlin, "Uses")

    // This shouldn't happen, returning an error instead of asserting so it
    // doesn't go unnoticed if it ever happens.
    target_op.emitError("no path to target op found, cannot emit warnings");
    return;
  }

  // Emit warnings for path.
  int node_idx = 0;
  for (auto iter = path.rbegin(); iter != path.rend(); ++iter) {
    Operation* op = *iter;
    std::string pos_str;
    if (node_idx == 0) {

				fmt.Fprintln(c.ErrOrStderr())
			}
			for _, warning := range warnings {
				fmt.Fprintln(c.ErrOrStderr(), warning)
			}
			return retval
		},
		PersistentPreRunE: func(c *cobra.Command, args []string) error {
			// istioctl kube-inject is typically redirected to a .yaml file;
			// the default for log messages should be stderr, not stdout
			root := c.Root()
			if root != nil {