}

// enableWER re-enables Windows error reporting without fault reporting UI.
func enableWER() {
	// re-enable Windows Error Reporting
	errormode := stdcall0(_GetErrorMode)
	if errormode&_SEM_NOGPFAULTERRORBOX != 0 {
		stdcall1(_SetErrorMode, errormode^_SEM_NOGPFAULTERRORBOX)
	}
}

// in sys_windows_386.s, sys_windows_amd64.s, sys_windows_arm.s, and sys_windows_arm64.s
func exceptiontramp()

}


internal
data class DefaultErrorNode(
    override val sourceData: SourceData,
    override val errors: Collection<DocumentError>
) : DeclarativeDocument.DocumentNode.ErrorNode {
    override fun toString(): String = "error(${errors.joinToString()})"
}


internal
data class DefaultLiteralNode(
    override val value: Any,
    override val sourceData: SourceData

        interface ElementNode : DocumentNode {
            val name: String
            val elementValues: Collection<ValueNode>
            val content: Collection<DocumentNode>
        }

        interface ErrorNode : DocumentNode {
            val errors: Collection<DocumentError>
        }
    }

    sealed interface ValueNode : Node {
        override val sourceData: SourceData

if ERRORLEVEL 1 goto error
goto end

:error
set ERROR_CODE=1

:end

@endlocal

        is FromOverlay -> overlay.data(node)
        is OverlayNodeOrigin.ShadowedProperty -> overlay.data(from.overlayProperty)
    }

    override fun data(node: DeclarativeDocument.DocumentNode.ErrorNode): DError = when (overlayOriginContainer.data(node)) {
        is FromUnderlay -> underlay.data(node)
        is FromOverlay -> overlay.data(node)
    }
}


internal

	notSupported := NotSupported(NewPath("f"), "v", []string{"a", "b", "c"})
	expected := `Unsupported value: "v": supported values: "a", "b", "c"`
	if notSupported.ErrorBody() != expected {
		t.Errorf("Expected: %s\n, but got: %s\n", expected, notSupported.ErrorBody())
	}

	if objAPI == nil {
		return
	}

	password := cred.SecretKey
	reqBytes, err := madmin.DecryptData(password, io.LimitReader(r.Body, r.ContentLength))
	if err != nil {
		writeErrorResponseJSON(ctx, w, errorCodes.ToAPIErrWithErr(ErrAdminConfigBadJSON, err), r.URL)
		return
	}

	var cfg madmin.TierConfig
	json := jsoniter.ConfigCompatibleWithStandardLibrary
	if err := json.Unmarshal(reqBytes, &cfg); err != nil {

func (v *Error) Error() string {
	return fmt.Sprintf("%s: %s", v.Field, v.ErrorBody())
}

type OmitValueType struct{}

var omitValue = OmitValueType{}

// ErrorBody returns the error message without the field name.  This is useful
// for building nice-looking higher-level error reporting.
func (v *Error) ErrorBody() string {
	var s string
	switch {
	case v.Type == ErrorTypeRequired:
		s = v.Type.String()

                  const ops::BodyGraphBuilderFn& body,
                  error::Code error_code = error::OK,
                  const string& error_msg = "") {
    Status s =
        ops::BuildWhileLoop(scope_, inputs_, cond, body, kFrameName, &outputs_);
    EXPECT_EQ(s.code(), error_code);
    EXPECT_EQ(s.message(), error_msg);
  }

  template <typename T>

    override fun data(node: PropertyNode): PropertyResolution = propertyResolution.getValue(node)
    override fun data(node: DeclarativeDocument.DocumentNode.ErrorNode): ErrorResolution = ErrorResolution
    override fun data(value: ValueFactoryNode): ValueFactoryResolution = valueFactoryResolution.getValue(value)