Build #1681751 2025-01-28 07:42:25
# rustc version
rustc 1.86.0-nightly (2f348cb7c 2025-01-27)# docs.rs version
docsrs 0.6.0 (29a0e81b 2025-01-22)# build log
[INFO] running `Command { std: "docker" "create" "-v" "/home/cratesfyi/workspace-builder/builds/libvips-rs-8.15.1/target:/opt/rustwide/target:rw,Z" "-v" "/home/cratesfyi/workspace-builder/builds/libvips-rs-8.15.1/source:/opt/rustwide/workdir:ro,Z" "-v" "/home/cratesfyi/workspace-builder/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/home/cratesfyi/workspace-builder/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "DOCS_RS=1" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "6442450944" "--cpus" "6" "--user" "1001:1001" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:c80049f3b88b82089a44e0f06d0d6029d44b96b7257e55a1cd63dbc9f4c33334" "/opt/rustwide/cargo-home/bin/cargo" "+nightly" "rustdoc" "--lib" "-Zrustdoc-map" "--config" "build.rustdocflags=[\"--cfg\", \"docsrs\", \"-Z\", \"unstable-options\", \"--emit=invocation-specific\", \"--resource-suffix\", \"-20250127-1.86.0-nightly-2f348cb7c\", \"--static-root-path\", \"/-/rustdoc.static/\", \"--cap-lints\", \"warn\", \"--extern-html-root-takes-precedence\"]" "--offline" "-Zunstable-options" "--config=doc.extern-map.registries.crates-io=\"https://docs.rs/{pkg_name}/{version}/x86_64-unknown-linux-gnu\"" "-Zrustdoc-scrape-examples" "-j6" "--target" "x86_64-unknown-linux-gnu", kill_on_drop: false }`
[INFO] [stderr] WARNING: Your kernel does not support swap limit capabilities or the cgroup is not mounted. Memory limited without swap.
[INFO] [stdout] f3ef6827290f9e90e08d94164a68eac604536b6935917bb219d5e1a2350d2586
[INFO] running `Command { std: "docker" "start" "-a" "f3ef6827290f9e90e08d94164a68eac604536b6935917bb219d5e1a2350d2586", kill_on_drop: false }`
[INFO] [stderr] warning: target filter specified, but no targets matched; this is a no-op
[INFO] [stderr] Documenting libvips-rs v8.15.1 (/opt/rustwide/workdir)
[INFO] [stderr] warning: unresolved link to `0`
[INFO] [stderr] --> src/bindings.rs:25417:9
[INFO] [stderr] |
[INFO] [stderr] 25417 | ... = " GTypeValueInitFunc:\n @value: the value to initialize\n\n Initializes the value contents by setting the fields of the `value->data`\n array.\n\n The data array of the #GValue passed into this function was zero-filled\n with `memset()`, so no care has to be taken to free any old contents.\n For example, in the case of a string value that may never be %NULL, the\n implementation might look like:\n\n |[<!-- language=\"C\" -->\n value->data[0].v_pointer = g_strdup (\"\");\n ]|\n\n Since: 2.7...
[INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] |
[INFO] [stderr] = note: the link appears in this line:
[INFO] [stderr]
[INFO] [stderr] value->data[0].v_pointer = g_strdup ("");
[INFO] [stderr] ^
[INFO] [stderr] = note: no item named `0` in scope
[INFO] [stderr] = help: to escape `[` and `]` characters, add '\' before them like `\[` or `\]`
[INFO] [stderr] = note: `#[warn(rustdoc::broken_intra_doc_links)]` on by default
[INFO] [stderr]
[INFO] [stderr] warning: unresolved link to `1`
[INFO] [stderr] --> src/bindings.rs:25419:9
[INFO] [stderr] |
[INFO] [stderr] 25419 | ... = " GTypeValueFreeFunc:\n @value: the value to free\n\n Frees any old contents that might be left in the `value->data` array of\n the given value.\n\n No resources may remain allocated through the #GValue contents after this\n function returns. E.g. for our above string type:\n\n |[<!-- language=\"C\" -->\n // only free strings without a specific flag for static storage\n if (!(value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS))\n g_free (value->data[0].v_pointer);\n ]|\n\n Since: 2.7...
[INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] |
[INFO] [stderr] = note: the link appears in this line:
[INFO] [stderr]
[INFO] [stderr] if (!(value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS))
[INFO] [stderr] ^
[INFO] [stderr] = note: no item named `1` in scope
[INFO] [stderr] = help: to escape `[` and `]` characters, add '\' before them like `\[` or `\]`
[INFO] [stderr]
[INFO] [stderr] warning: unresolved link to `0`
[INFO] [stderr] --> src/bindings.rs:25419:9
[INFO] [stderr] |
[INFO] [stderr] 25419 | ... = " GTypeValueFreeFunc:\n @value: the value to free\n\n Frees any old contents that might be left in the `value->data` array of\n the given value.\n\n No resources may remain allocated through the #GValue contents after this\n function returns. E.g. for our above string type:\n\n |[<!-- language=\"C\" -->\n // only free strings without a specific flag for static storage\n if (!(value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS))\n g_free (value->data[0].v_pointer);\n ]|\n\n Since: 2.7...
[INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] |
[INFO] [stderr] = note: the link appears in this line:
[INFO] [stderr]
[INFO] [stderr] g_free (value->data[0].v_pointer);
[INFO] [stderr] ^
[INFO] [stderr] = note: no item named `0` in scope
[INFO] [stderr] = help: to escape `[` and `]` characters, add '\' before them like `\[` or `\]`
[INFO] [stderr]
[INFO] [stderr] warning: unresolved link to `0`
[INFO] [stderr] --> src/bindings.rs:25421:9
[INFO] [stderr] |
[INFO] [stderr] 25421 | ... = " GTypeValueCopyFunc:\n @src_value: the value to copy\n @dest_value: (out): the location of the copy\n\n Copies the content of a #GValue into another.\n\n The @dest_value is a #GValue with zero-filled data section and @src_value\n is a properly initialized #GValue of same type, or derived type.\n\n The purpose of this function is to copy the contents of @src_value\n into @dest_value in a way, that even after @src_value has been freed, the\n contents of @dest_value remain valid. String type example:\n\n |[<!-- language=\"C\" -->\n dest_value->data[0].v_pointer = g_strdup (src_value->data[0].v_pointer);\n ]|\n\n Since: 2.7...
[INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] |
[INFO] [stderr] = note: the link appears in this line:
[INFO] [stderr]
[INFO] [stderr] dest_value->data[0].v_pointer = g_strdup (src_value->data[0].v_pointer);
[INFO] [stderr] ^
[INFO] [stderr] = note: no item named `0` in scope
[INFO] [stderr] = help: to escape `[` and `]` characters, add '\' before them like `\[` or `\]`
[INFO] [stderr]
[INFO] [stderr] warning: unresolved link to `0`
[INFO] [stderr] --> src/bindings.rs:25421:9
[INFO] [stderr] |
[INFO] [stderr] 25421 | ... = " GTypeValueCopyFunc:\n @src_value: the value to copy\n @dest_value: (out): the location of the copy\n\n Copies the content of a #GValue into another.\n\n The @dest_value is a #GValue with zero-filled data section and @src_value\n is a properly initialized #GValue of same type, or derived type.\n\n The purpose of this function is to copy the contents of @src_value\n into @dest_value in a way, that even after @src_value has been freed, the\n contents of @dest_value remain valid. String type example:\n\n |[<!-- language=\"C\" -->\n dest_value->data[0].v_pointer = g_strdup (src_value->data[0].v_pointer);\n ]|\n\n Since: 2.7...
[INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] |
[INFO] [stderr] = note: the link appears in this line:
[INFO] [stderr]
[INFO] [stderr] dest_value->data[0].v_pointer = g_strdup (src_value->data[0].v_pointer);
[INFO] [stderr] ^
[INFO] [stderr] = note: no item named `0` in scope
[INFO] [stderr] = help: to escape `[` and `]` characters, add '\' before them like `\[` or `\]`
[INFO] [stderr]
[INFO] [stderr] warning: unresolved link to `0`
[INFO] [stderr] --> src/bindings.rs:25424:9
[INFO] [stderr] |
[INFO] [stderr] 25424 | ... = " GTypeValuePeekPointerFunc:\n @value: the value to peek\n\n If the value contents fit into a pointer, such as objects or strings,\n return this pointer, so the caller can peek at the current contents.\n\n To extend on our above string example:\n\n |[<!-- language=\"C\" -->\n return value->data[0].v_pointer;\n ]|\n\n Returns: (transfer none): a pointer to the value contents\n\n Since: 2.7...
[INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] |
[INFO] [stderr] = note: the link appears in this line:
[INFO] [stderr]
[INFO] [stderr] return value->data[0].v_pointer;
[INFO] [stderr] ^
[INFO] [stderr] = note: no item named `0` in scope
[INFO] [stderr] = help: to escape `[` and `]` characters, add '\' before them like `\[` or `\]`
[INFO] [stderr]
[INFO] [stderr] warning: unresolved link to `0`
[INFO] [stderr] --> src/bindings.rs:25427:9
[INFO] [stderr] |
[INFO] [stderr] 25427 | ... = " GTypeValueCollectFunc:\n @value: the value to initialize\n @n_collect_values: the number of collected values\n @collect_values: (array length=n_collect_values): the collected values\n @collect_flags: optional flags\n\n This function is responsible for converting the values collected from\n a variadic argument list into contents suitable for storage in a #GValue.\n\n This function should setup @value similar to #GTypeValueInitFunc; e.g.\n for a string value that does not allow `NULL` pointers, it needs to either\n emit an error, or do an implicit conversion by storing an empty string.\n\n The @value passed in to this function has a zero-filled data array, so\n just like for #GTypeValueInitFunc it is guaranteed to not contain any old\n contents that might need freeing.\n\n The @n_collect_values argument is the string length of the `collect_format`\n field of #GTypeValueTable, and `collect_values` is an array of #GTypeCValue\n with length of @n_collect_values, containing the collected values according\n to `collect_format`.\n\n The @collect_flags argument provided as a hint by the caller. It may\n contain the flag %G_VALUE_NOCOPY_CONTENTS indicating that the collected\n value contents may be considered ‘static’ for the duration of the @value\n lifetime. Thus an extra copy of the contents stored in @collect_values is\n not required for assignment to @value.\n\n For our above string example, we continue with:\n\n |[<!-- language=\"C\" -->\n if (!collect_values[0].v_pointer)\n value->data[0].v_pointer = g_strdup (\"\");\n else if (collect_flags & G_VALUE_NOCOPY_CONTENTS)\n {\n value->data[0].v_pointer = collect_values[0].v_pointer;\n // keep a flag for the value_free() implementation to not free this string\n value->data[1].v_uint = G_VALUE_NOCOPY_CONTENTS;\n }\n else\n value->data[0].v_pointer = g_strdup (collect_values[0].v_pointer);\n return NULL;\n ]|\n\n It should be noted, that it is generally a bad idea to follow the\n %G_VALUE_NOCOPY_CONTENTS hint for reference counted types. Due to\n reentrancy requirements and reference count assertions performed\n by the signal emission code, reference counts should always be\n incremented for reference counted contents stored in the `value->data`\n array. To deviate from our string example for a moment, and taking\n a look at an exemplary implementation for `GTypeValueTable.collect_value()`\n of `GObject`:\n\n |[<!-- language=\"C\" -->\n GObject *object = G_OBJECT (collect_values[0].v_pointer);\n g_return_val_if_fail (object != NULL,\n g_strdup_printf (\"Object %p passed as invalid NULL pointer\", object));\n // never honour G_VALUE_NOCOPY_CONTENTS for ref-counted types\n value->data[0].v_pointer = g_object_ref (object);\n return NULL;\n ]|\n\n The reference count for valid objects is always incremented, regardless\n of `collect_flags`. For invalid objects, the example returns a newly\n allocated string without altering `value`.\n\n Upon success, `collect_value()` needs to return `NULL`. If, however,\n an error condition occurred, `collect_value()` should return a newly\n allocated string containing an error diagnostic.\n\n The calling code makes no assumptions about the `value` contents being\n valid upon error returns, `value` is simply thrown away without further\n freeing. As such, it is a good idea to not allocate `GValue` contents\n prior to returning an error; however, `collect_values()` is not obliged\n to return a correctly setup @value for error returns, simply because\n any non-`NULL` return is considered a fatal programming error, and\n further program behaviour is undefined.\n\n Returns: (transfer full) (nullable): `NULL` on success, otherwise a\n newly allocated error string on failure\n\n Since: 2.7...
[INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] |
[INFO] [stderr] = note: the link appears in this line:
[INFO] [stderr]
[INFO] [stderr] if (!collect_values[0].v_pointer)
[INFO] [stderr] ^
[INFO] [stderr] = note: no item named `0` in scope
[INFO] [stderr] = help: to escape `[` and `]` characters, add '\' before them like `\[` or `\]`
[INFO] [stderr]
[INFO] [stderr] warning: unresolved link to `0`
[INFO] [stderr] --> src/bindings.rs:25427:9
[INFO] [stderr] |
[INFO] [stderr] 25427 | ... = " GTypeValueCollectFunc:\n @value: the value to initialize\n @n_collect_values: the number of collected values\n @collect_values: (array length=n_collect_values): the collected values\n @collect_flags: optional flags\n\n This function is responsible for converting the values collected from\n a variadic argument list into contents suitable for storage in a #GValue.\n\n This function should setup @value similar to #GTypeValueInitFunc; e.g.\n for a string value that does not allow `NULL` pointers, it needs to either\n emit an error, or do an implicit conversion by storing an empty string.\n\n The @value passed in to this function has a zero-filled data array, so\n just like for #GTypeValueInitFunc it is guaranteed to not contain any old\n contents that might need freeing.\n\n The @n_collect_values argument is the string length of the `collect_format`\n field of #GTypeValueTable, and `collect_values` is an array of #GTypeCValue\n with length of @n_collect_values, containing the collected values according\n to `collect_format`.\n\n The @collect_flags argument provided as a hint by the caller. It may\n contain the flag %G_VALUE_NOCOPY_CONTENTS indicating that the collected\n value contents may be considered ‘static’ for the duration of the @value\n lifetime. Thus an extra copy of the contents stored in @collect_values is\n not required for assignment to @value.\n\n For our above string example, we continue with:\n\n |[<!-- language=\"C\" -->\n if (!collect_values[0].v_pointer)\n value->data[0].v_pointer = g_strdup (\"\");\n else if (collect_flags & G_VALUE_NOCOPY_CONTENTS)\n {\n value->data[0].v_pointer = collect_values[0].v_pointer;\n // keep a flag for the value_free() implementation to not free this string\n value->data[1].v_uint = G_VALUE_NOCOPY_CONTENTS;\n }\n else\n value->data[0].v_pointer = g_strdup (collect_values[0].v_pointer);\n return NULL;\n ]|\n\n It should be noted, that it is generally a bad idea to follow the\n %G_VALUE_NOCOPY_CONTENTS hint for reference counted types. Due to\n reentrancy requirements and reference count assertions performed\n by the signal emission code, reference counts should always be\n incremented for reference counted contents stored in the `value->data`\n array. To deviate from our string example for a moment, and taking\n a look at an exemplary implementation for `GTypeValueTable.collect_value()`\n of `GObject`:\n\n |[<!-- language=\"C\" -->\n GObject *object = G_OBJECT (collect_values[0].v_pointer);\n g_return_val_if_fail (object != NULL,\n g_strdup_printf (\"Object %p passed as invalid NULL pointer\", object));\n // never honour G_VALUE_NOCOPY_CONTENTS for ref-counted types\n value->data[0].v_pointer = g_object_ref (object);\n return NULL;\n ]|\n\n The reference count for valid objects is always incremented, regardless\n of `collect_flags`. For invalid objects, the example returns a newly\n allocated string without altering `value`.\n\n Upon success, `collect_value()` needs to return `NULL`. If, however,\n an error condition occurred, `collect_value()` should return a newly\n allocated string containing an error diagnostic.\n\n The calling code makes no assumptions about the `value` contents being\n valid upon error returns, `value` is simply thrown away without further\n freeing. As such, it is a good idea to not allocate `GValue` contents\n prior to returning an error; however, `collect_values()` is not obliged\n to return a correctly setup @value for error returns, simply because\n any non-`NULL` return is considered a fatal programming error, and\n further program behaviour is undefined.\n\n Returns: (transfer full) (nullable): `NULL` on success, otherwise a\n newly allocated error string on failure\n\n Since: 2.7...
[INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] |
[INFO] [stderr] = note: the link appears in this line:
[INFO] [stderr]
[INFO] [stderr] value->data[0].v_pointer = g_strdup ("");
[INFO] [stderr] ^
[INFO] [stderr] = note: no item named `0` in scope
[INFO] [stderr] = help: to escape `[` and `]` characters, add '\' before them like `\[` or `\]`
[INFO] [stderr]
[INFO] [stderr] warning: unresolved link to `0`
[INFO] [stderr] --> src/bindings.rs:25427:9
[INFO] [stderr] |
[INFO] [stderr] 25427 | ... = " GTypeValueCollectFunc:\n @value: the value to initialize\n @n_collect_values: the number of collected values\n @collect_values: (array length=n_collect_values): the collected values\n @collect_flags: optional flags\n\n This function is responsible for converting the values collected from\n a variadic argument list into contents suitable for storage in a #GValue.\n\n This function should setup @value similar to #GTypeValueInitFunc; e.g.\n for a string value that does not allow `NULL` pointers, it needs to either\n emit an error, or do an implicit conversion by storing an empty string.\n\n The @value passed in to this function has a zero-filled data array, so\n just like for #GTypeValueInitFunc it is guaranteed to not contain any old\n contents that might need freeing.\n\n The @n_collect_values argument is the string length of the `collect_format`\n field of #GTypeValueTable, and `collect_values` is an array of #GTypeCValue\n with length of @n_collect_values, containing the collected values according\n to `collect_format`.\n\n The @collect_flags argument provided as a hint by the caller. It may\n contain the flag %G_VALUE_NOCOPY_CONTENTS indicating that the collected\n value contents may be considered ‘static’ for the duration of the @value\n lifetime. Thus an extra copy of the contents stored in @collect_values is\n not required for assignment to @value.\n\n For our above string example, we continue with:\n\n |[<!-- language=\"C\" -->\n if (!collect_values[0].v_pointer)\n value->data[0].v_pointer = g_strdup (\"\");\n else if (collect_flags & G_VALUE_NOCOPY_CONTENTS)\n {\n value->data[0].v_pointer = collect_values[0].v_pointer;\n // keep a flag for the value_free() implementation to not free this string\n value->data[1].v_uint = G_VALUE_NOCOPY_CONTENTS;\n }\n else\n value->data[0].v_pointer = g_strdup (collect_values[0].v_pointer);\n return NULL;\n ]|\n\n It should be noted, that it is generally a bad idea to follow the\n %G_VALUE_NOCOPY_CONTENTS hint for reference counted types. Due to\n reentrancy requirements and reference count assertions performed\n by the signal emission code, reference counts should always be\n incremented for reference counted contents stored in the `value->data`\n array. To deviate from our string example for a moment, and taking\n a look at an exemplary implementation for `GTypeValueTable.collect_value()`\n of `GObject`:\n\n |[<!-- language=\"C\" -->\n GObject *object = G_OBJECT (collect_values[0].v_pointer);\n g_return_val_if_fail (object != NULL,\n g_strdup_printf (\"Object %p passed as invalid NULL pointer\", object));\n // never honour G_VALUE_NOCOPY_CONTENTS for ref-counted types\n value->data[0].v_pointer = g_object_ref (object);\n return NULL;\n ]|\n\n The reference count for valid objects is always incremented, regardless\n of `collect_flags`. For invalid objects, the example returns a newly\n allocated string without altering `value`.\n\n Upon success, `collect_value()` needs to return `NULL`. If, however,\n an error condition occurred, `collect_value()` should return a newly\n allocated string containing an error diagnostic.\n\n The calling code makes no assumptions about the `value` contents being\n valid upon error returns, `value` is simply thrown away without further\n freeing. As such, it is a good idea to not allocate `GValue` contents\n prior to returning an error; however, `collect_values()` is not obliged\n to return a correctly setup @value for error returns, simply because\n any non-`NULL` return is considered a fatal programming error, and\n further program behaviour is undefined.\n\n Returns: (transfer full) (nullable): `NULL` on success, otherwise a\n newly allocated error string on failure\n\n Since: 2.7...
[INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] |
[INFO] [stderr] = note: the link appears in this line:
[INFO] [stderr]
[INFO] [stderr] value->data[0].v_pointer = collect_values[0].v_pointer;
[INFO] [stderr] ^
[INFO] [stderr] = note: no item named `0` in scope
[INFO] [stderr] = help: to escape `[` and `]` characters, add '\' before them like `\[` or `\]`
[INFO] [stderr]
[INFO] [stderr] warning: unresolved link to `0`
[INFO] [stderr] --> src/bindings.rs:25427:9
[INFO] [stderr] |
[INFO] [stderr] 25427 | ... = " GTypeValueCollectFunc:\n @value: the value to initialize\n @n_collect_values: the number of collected values\n @collect_values: (array length=n_collect_values): the collected values\n @collect_flags: optional flags\n\n This function is responsible for converting the values collected from\n a variadic argument list into contents suitable for storage in a #GValue.\n\n This function should setup @value similar to #GTypeValueInitFunc; e.g.\n for a string value that does not allow `NULL` pointers, it needs to either\n emit an error, or do an implicit conversion by storing an empty string.\n\n The @value passed in to this function has a zero-filled data array, so\n just like for #GTypeValueInitFunc it is guaranteed to not contain any old\n contents that might need freeing.\n\n The @n_collect_values argument is the string length of the `collect_format`\n field of #GTypeValueTable, and `collect_values` is an array of #GTypeCValue\n with length of @n_collect_values, containing the collected values according\n to `collect_format`.\n\n The @collect_flags argument provided as a hint by the caller. It may\n contain the flag %G_VALUE_NOCOPY_CONTENTS indicating that the collected\n value contents may be considered ‘static’ for the duration of the @value\n lifetime. Thus an extra copy of the contents stored in @collect_values is\n not required for assignment to @value.\n\n For our above string example, we continue with:\n\n |[<!-- language=\"C\" -->\n if (!collect_values[0].v_pointer)\n value->data[0].v_pointer = g_strdup (\"\");\n else if (collect_flags & G_VALUE_NOCOPY_CONTENTS)\n {\n value->data[0].v_pointer = collect_values[0].v_pointer;\n // keep a flag for the value_free() implementation to not free this string\n value->data[1].v_uint = G_VALUE_NOCOPY_CONTENTS;\n }\n else\n value->data[0].v_pointer = g_strdup (collect_values[0].v_pointer);\n return NULL;\n ]|\n\n It should be noted, that it is generally a bad idea to follow the\n %G_VALUE_NOCOPY_CONTENTS hint for reference counted types. Due to\n reentrancy requirements and reference count assertions performed\n by the signal emission code, reference counts should always be\n incremented for reference counted contents stored in the `value->data`\n array. To deviate from our string example for a moment, and taking\n a look at an exemplary implementation for `GTypeValueTable.collect_value()`\n of `GObject`:\n\n |[<!-- language=\"C\" -->\n GObject *object = G_OBJECT (collect_values[0].v_pointer);\n g_return_val_if_fail (object != NULL,\n g_strdup_printf (\"Object %p passed as invalid NULL pointer\", object));\n // never honour G_VALUE_NOCOPY_CONTENTS for ref-counted types\n value->data[0].v_pointer = g_object_ref (object);\n return NULL;\n ]|\n\n The reference count for valid objects is always incremented, regardless\n of `collect_flags`. For invalid objects, the example returns a newly\n allocated string without altering `value`.\n\n Upon success, `collect_value()` needs to return `NULL`. If, however,\n an error condition occurred, `collect_value()` should return a newly\n allocated string containing an error diagnostic.\n\n The calling code makes no assumptions about the `value` contents being\n valid upon error returns, `value` is simply thrown away without further\n freeing. As such, it is a good idea to not allocate `GValue` contents\n prior to returning an error; however, `collect_values()` is not obliged\n to return a correctly setup @value for error returns, simply because\n any non-`NULL` return is considered a fatal programming error, and\n further program behaviour is undefined.\n\n Returns: (transfer full) (nullable): `NULL` on success, otherwise a\n newly allocated error string on failure\n\n Since: 2.7...
[INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] |
[INFO] [stderr] = note: the link appears in this line:
[INFO] [stderr]
[INFO] [stderr] value->data[0].v_pointer = collect_values[0].v_pointer;
[INFO] [stderr] ^
[INFO] [stderr] = note: no item named `0` in scope
[INFO] [stderr] = help: to escape `[` and `]` characters, add '\' before them like `\[` or `\]`
[INFO] [stderr]
[INFO] [stderr] warning: unresolved link to `1`
[INFO] [stderr] --> src/bindings.rs:25427:9
[INFO] [stderr] |
[INFO] [stderr] 25427 | ... = " GTypeValueCollectFunc:\n @value: the value to initialize\n @n_collect_values: the number of collected values\n @collect_values: (array length=n_collect_values): the collected values\n @collect_flags: optional flags\n\n This function is responsible for converting the values collected from\n a variadic argument list into contents suitable for storage in a #GValue.\n\n This function should setup @value similar to #GTypeValueInitFunc; e.g.\n for a string value that does not allow `NULL` pointers, it needs to either\n emit an error, or do an implicit conversion by storing an empty string.\n\n The @value passed in to this function has a zero-filled data array, so\n just like for #GTypeValueInitFunc it is guaranteed to not contain any old\n contents that might need freeing.\n\n The @n_collect_values argument is the string length of the `collect_format`\n field of #GTypeValueTable, and `collect_values` is an array of #GTypeCValue\n with length of @n_collect_values, containing the collected values according\n to `collect_format`.\n\n The @collect_flags argument provided as a hint by the caller. It may\n contain the flag %G_VALUE_NOCOPY_CONTENTS indicating that the collected\n value contents may be considered ‘static’ for the duration of the @value\n lifetime. Thus an extra copy of the contents stored in @collect_values is\n not required for assignment to @value.\n\n For our above string example, we continue with:\n\n |[<!-- language=\"C\" -->\n if (!collect_values[0].v_pointer)\n value->data[0].v_pointer = g_strdup (\"\");\n else if (collect_flags & G_VALUE_NOCOPY_CONTENTS)\n {\n value->data[0].v_pointer = collect_values[0].v_pointer;\n // keep a flag for the value_free() implementation to not free this string\n value->data[1].v_uint = G_VALUE_NOCOPY_CONTENTS;\n }\n else\n value->data[0].v_pointer = g_strdup (collect_values[0].v_pointer);\n return NULL;\n ]|\n\n It should be noted, that it is generally a bad idea to follow the\n %G_VALUE_NOCOPY_CONTENTS hint for reference counted types. Due to\n reentrancy requirements and reference count assertions performed\n by the signal emission code, reference counts should always be\n incremented for reference counted contents stored in the `value->data`\n array. To deviate from our string example for a moment, and taking\n a look at an exemplary implementation for `GTypeValueTable.collect_value()`\n of `GObject`:\n\n |[<!-- language=\"C\" -->\n GObject *object = G_OBJECT (collect_values[0].v_pointer);\n g_return_val_if_fail (object != NULL,\n g_strdup_printf (\"Object %p passed as invalid NULL pointer\", object));\n // never honour G_VALUE_NOCOPY_CONTENTS for ref-counted types\n value->data[0].v_pointer = g_object_ref (object);\n return NULL;\n ]|\n\n The reference count for valid objects is always incremented, regardless\n of `collect_flags`. For invalid objects, the example returns a newly\n allocated string without altering `value`.\n\n Upon success, `collect_value()` needs to return `NULL`. If, however,\n an error condition occurred, `collect_value()` should return a newly\n allocated string containing an error diagnostic.\n\n The calling code makes no assumptions about the `value` contents being\n valid upon error returns, `value` is simply thrown away without further\n freeing. As such, it is a good idea to not allocate `GValue` contents\n prior to returning an error; however, `collect_values()` is not obliged\n to return a correctly setup @value for error returns, simply because\n any non-`NULL` return is considered a fatal programming error, and\n further program behaviour is undefined.\n\n Returns: (transfer full) (nullable): `NULL` on success, otherwise a\n newly allocated error string on failure\n\n Since: 2.7...
[INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] |
[INFO] [stderr] = note: the link appears in this line:
[INFO] [stderr]
[INFO] [stderr] value->data[1].v_uint = G_VALUE_NOCOPY_CONTENTS;
[INFO] [stderr] ^
[INFO] [stderr] = note: no item named `1` in scope
[INFO] [stderr] = help: to escape `[` and `]` characters, add '\' before them like `\[` or `\]`
[INFO] [stderr]
[INFO] [stderr] warning: unresolved link to `0`
[INFO] [stderr] --> src/bindings.rs:25427:9
[INFO] [stderr] |
[INFO] [stderr] 25427 | ... = " GTypeValueCollectFunc:\n @value: the value to initialize\n @n_collect_values: the number of collected values\n @collect_values: (array length=n_collect_values): the collected values\n @collect_flags: optional flags\n\n This function is responsible for converting the values collected from\n a variadic argument list into contents suitable for storage in a #GValue.\n\n This function should setup @value similar to #GTypeValueInitFunc; e.g.\n for a string value that does not allow `NULL` pointers, it needs to either\n emit an error, or do an implicit conversion by storing an empty string.\n\n The @value passed in to this function has a zero-filled data array, so\n just like for #GTypeValueInitFunc it is guaranteed to not contain any old\n contents that might need freeing.\n\n The @n_collect_values argument is the string length of the `collect_format`\n field of #GTypeValueTable, and `collect_values` is an array of #GTypeCValue\n with length of @n_collect_values, containing the collected values according\n to `collect_format`.\n\n The @collect_flags argument provided as a hint by the caller. It may\n contain the flag %G_VALUE_NOCOPY_CONTENTS indicating that the collected\n value contents may be considered ‘static’ for the duration of the @value\n lifetime. Thus an extra copy of the contents stored in @collect_values is\n not required for assignment to @value.\n\n For our above string example, we continue with:\n\n |[<!-- language=\"C\" -->\n if (!collect_values[0].v_pointer)\n value->data[0].v_pointer = g_strdup (\"\");\n else if (collect_flags & G_VALUE_NOCOPY_CONTENTS)\n {\n value->data[0].v_pointer = collect_values[0].v_pointer;\n // keep a flag for the value_free() implementation to not free this string\n value->data[1].v_uint = G_VALUE_NOCOPY_CONTENTS;\n }\n else\n value->data[0].v_pointer = g_strdup (collect_values[0].v_pointer);\n return NULL;\n ]|\n\n It should be noted, that it is generally a bad idea to follow the\n %G_VALUE_NOCOPY_CONTENTS hint for reference counted types. Due to\n reentrancy requirements and reference count assertions performed\n by the signal emission code, reference counts should always be\n incremented for reference counted contents stored in the `value->data`\n array. To deviate from our string example for a moment, and taking\n a look at an exemplary implementation for `GTypeValueTable.collect_value()`\n of `GObject`:\n\n |[<!-- language=\"C\" -->\n GObject *object = G_OBJECT (collect_values[0].v_pointer);\n g_return_val_if_fail (object != NULL,\n g_strdup_printf (\"Object %p passed as invalid NULL pointer\", object));\n // never honour G_VALUE_NOCOPY_CONTENTS for ref-counted types\n value->data[0].v_pointer = g_object_ref (object);\n return NULL;\n ]|\n\n The reference count for valid objects is always incremented, regardless\n of `collect_flags`. For invalid objects, the example returns a newly\n allocated string without altering `value`.\n\n Upon success, `collect_value()` needs to return `NULL`. If, however,\n an error condition occurred, `collect_value()` should return a newly\n allocated string containing an error diagnostic.\n\n The calling code makes no assumptions about the `value` contents being\n valid upon error returns, `value` is simply thrown away without further\n freeing. As such, it is a good idea to not allocate `GValue` contents\n prior to returning an error; however, `collect_values()` is not obliged\n to return a correctly setup @value for error returns, simply because\n any non-`NULL` return is considered a fatal programming error, and\n further program behaviour is undefined.\n\n Returns: (transfer full) (nullable): `NULL` on success, otherwise a\n newly allocated error string on failure\n\n Since: 2.7...
[INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] |
[INFO] [stderr] = note: the link appears in this line:
[INFO] [stderr]
[INFO] [stderr] value->data[0].v_pointer = g_strdup (collect_values[0].v_pointer);
[INFO] [stderr] ^
[INFO] [stderr] = note: no item named `0` in scope
[INFO] [stderr] = help: to escape `[` and `]` characters, add '\' before them like `\[` or `\]`
[INFO] [stderr]
[INFO] [stderr] warning: unresolved link to `0`
[INFO] [stderr] --> src/bindings.rs:25427:9
[INFO] [stderr] |
[INFO] [stderr] 25427 | ... = " GTypeValueCollectFunc:\n @value: the value to initialize\n @n_collect_values: the number of collected values\n @collect_values: (array length=n_collect_values): the collected values\n @collect_flags: optional flags\n\n This function is responsible for converting the values collected from\n a variadic argument list into contents suitable for storage in a #GValue.\n\n This function should setup @value similar to #GTypeValueInitFunc; e.g.\n for a string value that does not allow `NULL` pointers, it needs to either\n emit an error, or do an implicit conversion by storing an empty string.\n\n The @value passed in to this function has a zero-filled data array, so\n just like for #GTypeValueInitFunc it is guaranteed to not contain any old\n contents that might need freeing.\n\n The @n_collect_values argument is the string length of the `collect_format`\n field of #GTypeValueTable, and `collect_values` is an array of #GTypeCValue\n with length of @n_collect_values, containing the collected values according\n to `collect_format`.\n\n The @collect_flags argument provided as a hint by the caller. It may\n contain the flag %G_VALUE_NOCOPY_CONTENTS indicating that the collected\n value contents may be considered ‘static’ for the duration of the @value\n lifetime. Thus an extra copy of the contents stored in @collect_values is\n not required for assignment to @value.\n\n For our above string example, we continue with:\n\n |[<!-- language=\"C\" -->\n if (!collect_values[0].v_pointer)\n value->data[0].v_pointer = g_strdup (\"\");\n else if (collect_flags & G_VALUE_NOCOPY_CONTENTS)\n {\n value->data[0].v_pointer = collect_values[0].v_pointer;\n // keep a flag for the value_free() implementation to not free this string\n value->data[1].v_uint = G_VALUE_NOCOPY_CONTENTS;\n }\n else\n value->data[0].v_pointer = g_strdup (collect_values[0].v_pointer);\n return NULL;\n ]|\n\n It should be noted, that it is generally a bad idea to follow the\n %G_VALUE_NOCOPY_CONTENTS hint for reference counted types. Due to\n reentrancy requirements and reference count assertions performed\n by the signal emission code, reference counts should always be\n incremented for reference counted contents stored in the `value->data`\n array. To deviate from our string example for a moment, and taking\n a look at an exemplary implementation for `GTypeValueTable.collect_value()`\n of `GObject`:\n\n |[<!-- language=\"C\" -->\n GObject *object = G_OBJECT (collect_values[0].v_pointer);\n g_return_val_if_fail (object != NULL,\n g_strdup_printf (\"Object %p passed as invalid NULL pointer\", object));\n // never honour G_VALUE_NOCOPY_CONTENTS for ref-counted types\n value->data[0].v_pointer = g_object_ref (object);\n return NULL;\n ]|\n\n The reference count for valid objects is always incremented, regardless\n of `collect_flags`. For invalid objects, the example returns a newly\n allocated string without altering `value`.\n\n Upon success, `collect_value()` needs to return `NULL`. If, however,\n an error condition occurred, `collect_value()` should return a newly\n allocated string containing an error diagnostic.\n\n The calling code makes no assumptions about the `value` contents being\n valid upon error returns, `value` is simply thrown away without further\n freeing. As such, it is a good idea to not allocate `GValue` contents\n prior to returning an error; however, `collect_values()` is not obliged\n to return a correctly setup @value for error returns, simply because\n any non-`NULL` return is considered a fatal programming error, and\n further program behaviour is undefined.\n\n Returns: (transfer full) (nullable): `NULL` on success, otherwise a\n newly allocated error string on failure\n\n Since: 2.7...
[INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] |
[INFO] [stderr] = note: the link appears in this line:
[INFO] [stderr]
[INFO] [stderr] value->data[0].v_pointer = g_strdup (collect_values[0].v_pointer);
[INFO] [stderr] ^
[INFO] [stderr] = note: no item named `0` in scope
[INFO] [stderr] = help: to escape `[` and `]` characters, add '\' before them like `\[` or `\]`
[INFO] [stderr]
[INFO] [stderr] warning: unresolved link to `0`
[INFO] [stderr] --> src/bindings.rs:25427:9
[INFO] [stderr] |
[INFO] [stderr] 25427 | ... = " GTypeValueCollectFunc:\n @value: the value to initialize\n @n_collect_values: the number of collected values\n @collect_values: (array length=n_collect_values): the collected values\n @collect_flags: optional flags\n\n This function is responsible for converting the values collected from\n a variadic argument list into contents suitable for storage in a #GValue.\n\n This function should setup @value similar to #GTypeValueInitFunc; e.g.\n for a string value that does not allow `NULL` pointers, it needs to either\n emit an error, or do an implicit conversion by storing an empty string.\n\n The @value passed in to this function has a zero-filled data array, so\n just like for #GTypeValueInitFunc it is guaranteed to not contain any old\n contents that might need freeing.\n\n The @n_collect_values argument is the string length of the `collect_format`\n field of #GTypeValueTable, and `collect_values` is an array of #GTypeCValue\n with length of @n_collect_values, containing the collected values according\n to `collect_format`.\n\n The @collect_flags argument provided as a hint by the caller. It may\n contain the flag %G_VALUE_NOCOPY_CONTENTS indicating that the collected\n value contents may be considered ‘static’ for the duration of the @value\n lifetime. Thus an extra copy of the contents stored in @collect_values is\n not required for assignment to @value.\n\n For our above string example, we continue with:\n\n |[<!-- language=\"C\" -->\n if (!collect_values[0].v_pointer)\n value->data[0].v_pointer = g_strdup (\"\");\n else if (collect_flags & G_VALUE_NOCOPY_CONTENTS)\n {\n value->data[0].v_pointer = collect_values[0].v_pointer;\n // keep a flag for the value_free() implementation to not free this string\n value->data[1].v_uint = G_VALUE_NOCOPY_CONTENTS;\n }\n else\n value->data[0].v_pointer = g_strdup (collect_values[0].v_pointer);\n return NULL;\n ]|\n\n It should be noted, that it is generally a bad idea to follow the\n %G_VALUE_NOCOPY_CONTENTS hint for reference counted types. Due to\n reentrancy requirements and reference count assertions performed\n by the signal emission code, reference counts should always be\n incremented for reference counted contents stored in the `value->data`\n array. To deviate from our string example for a moment, and taking\n a look at an exemplary implementation for `GTypeValueTable.collect_value()`\n of `GObject`:\n\n |[<!-- language=\"C\" -->\n GObject *object = G_OBJECT (collect_values[0].v_pointer);\n g_return_val_if_fail (object != NULL,\n g_strdup_printf (\"Object %p passed as invalid NULL pointer\", object));\n // never honour G_VALUE_NOCOPY_CONTENTS for ref-counted types\n value->data[0].v_pointer = g_object_ref (object);\n return NULL;\n ]|\n\n The reference count for valid objects is always incremented, regardless\n of `collect_flags`. For invalid objects, the example returns a newly\n allocated string without altering `value`.\n\n Upon success, `collect_value()` needs to return `NULL`. If, however,\n an error condition occurred, `collect_value()` should return a newly\n allocated string containing an error diagnostic.\n\n The calling code makes no assumptions about the `value` contents being\n valid upon error returns, `value` is simply thrown away without further\n freeing. As such, it is a good idea to not allocate `GValue` contents\n prior to returning an error; however, `collect_values()` is not obliged\n to return a correctly setup @value for error returns, simply because\n any non-`NULL` return is considered a fatal programming error, and\n further program behaviour is undefined.\n\n Returns: (transfer full) (nullable): `NULL` on success, otherwise a\n newly allocated error string on failure\n\n Since: 2.7...
[INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] |
[INFO] [stderr] = note: the link appears in this line:
[INFO] [stderr]
[INFO] [stderr] GObject *object = G_OBJECT (collect_values[0].v_pointer);
[INFO] [stderr] ^
[INFO] [stderr] = note: no item named `0` in scope
[INFO] [stderr] = help: to escape `[` and `]` characters, add '\' before them like `\[` or `\]`
[INFO] [stderr]
[INFO] [stderr] warning: unresolved link to `0`
[INFO] [stderr] --> src/bindings.rs:25427:9
[INFO] [stderr] |
[INFO] [stderr] 25427 | ... = " GTypeValueCollectFunc:\n @value: the value to initialize\n @n_collect_values: the number of collected values\n @collect_values: (array length=n_collect_values): the collected values\n @collect_flags: optional flags\n\n This function is responsible for converting the values collected from\n a variadic argument list into contents suitable for storage in a #GValue.\n\n This function should setup @value similar to #GTypeValueInitFunc; e.g.\n for a string value that does not allow `NULL` pointers, it needs to either\n emit an error, or do an implicit conversion by storing an empty string.\n\n The @value passed in to this function has a zero-filled data array, so\n just like for #GTypeValueInitFunc it is guaranteed to not contain any old\n contents that might need freeing.\n\n The @n_collect_values argument is the string length of the `collect_format`\n field of #GTypeValueTable, and `collect_values` is an array of #GTypeCValue\n with length of @n_collect_values, containing the collected values according\n to `collect_format`.\n\n The @collect_flags argument provided as a hint by the caller. It may\n contain the flag %G_VALUE_NOCOPY_CONTENTS indicating that the collected\n value contents may be considered ‘static’ for the duration of the @value\n lifetime. Thus an extra copy of the contents stored in @collect_values is\n not required for assignment to @value.\n\n For our above string example, we continue with:\n\n |[<!-- language=\"C\" -->\n if (!collect_values[0].v_pointer)\n value->data[0].v_pointer = g_strdup (\"\");\n else if (collect_flags & G_VALUE_NOCOPY_CONTENTS)\n {\n value->data[0].v_pointer = collect_values[0].v_pointer;\n // keep a flag for the value_free() implementation to not free this string\n value->data[1].v_uint = G_VALUE_NOCOPY_CONTENTS;\n }\n else\n value->data[0].v_pointer = g_strdup (collect_values[0].v_pointer);\n return NULL;\n ]|\n\n It should be noted, that it is generally a bad idea to follow the\n %G_VALUE_NOCOPY_CONTENTS hint for reference counted types. Due to\n reentrancy requirements and reference count assertions performed\n by the signal emission code, reference counts should always be\n incremented for reference counted contents stored in the `value->data`\n array. To deviate from our string example for a moment, and taking\n a look at an exemplary implementation for `GTypeValueTable.collect_value()`\n of `GObject`:\n\n |[<!-- language=\"C\" -->\n GObject *object = G_OBJECT (collect_values[0].v_pointer);\n g_return_val_if_fail (object != NULL,\n g_strdup_printf (\"Object %p passed as invalid NULL pointer\", object));\n // never honour G_VALUE_NOCOPY_CONTENTS for ref-counted types\n value->data[0].v_pointer = g_object_ref (object);\n return NULL;\n ]|\n\n The reference count for valid objects is always incremented, regardless\n of `collect_flags`. For invalid objects, the example returns a newly\n allocated string without altering `value`.\n\n Upon success, `collect_value()` needs to return `NULL`. If, however,\n an error condition occurred, `collect_value()` should return a newly\n allocated string containing an error diagnostic.\n\n The calling code makes no assumptions about the `value` contents being\n valid upon error returns, `value` is simply thrown away without further\n freeing. As such, it is a good idea to not allocate `GValue` contents\n prior to returning an error; however, `collect_values()` is not obliged\n to return a correctly setup @value for error returns, simply because\n any non-`NULL` return is considered a fatal programming error, and\n further program behaviour is undefined.\n\n Returns: (transfer full) (nullable): `NULL` on success, otherwise a\n newly allocated error string on failure\n\n Since: 2.7...
[INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] |
[INFO] [stderr] = note: the link appears in this line:
[INFO] [stderr]
[INFO] [stderr] value->data[0].v_pointer = g_object_ref (object);
[INFO] [stderr] ^
[INFO] [stderr] = note: no item named `0` in scope
[INFO] [stderr] = help: to escape `[` and `]` characters, add '\' before them like `\[` or `\]`
[INFO] [stderr]
[INFO] [stderr] warning: unresolved link to `0`
[INFO] [stderr] --> src/bindings.rs:25436:9
[INFO] [stderr] |
[INFO] [stderr] 25436 | ... = " GTypeValueLCopyFunc:\n @value: the value to lcopy\n @n_collect_values: the number of collected values\n @collect_values: (array length=n_collect_values): the collected\n locations for storage\n @collect_flags: optional flags\n\n This function is responsible for storing the `value`\n contents into arguments passed through a variadic argument list which\n got collected into `collect_values` according to `lcopy_format`.\n\n The `n_collect_values` argument equals the string length of\n `lcopy_format`, and `collect_flags` may contain %G_VALUE_NOCOPY_CONTENTS.\n\n In contrast to #GTypeValueCollectFunc, this function is obliged to always\n properly support %G_VALUE_NOCOPY_CONTENTS.\n\n Similar to #GTypeValueCollectFunc the function may prematurely abort by\n returning a newly allocated string describing an error condition. To\n complete the string example:\n\n |[<!-- language=\"C\" -->\n gchar **string_p = collect_values[0].v_pointer;\n g_return_val_if_fail (string_p != NULL,\n g_strdup (\"string location passed as NULL\"));\n\n if (collect_flags & G_VALUE_NOCOPY_CONTENTS)\n *string_p = value->data[0].v_pointer;\n else\n *string_p = g_strdup (value->data[0].v_pointer);\n ]|\n\n And an illustrative version of this function for reference-counted\n types:\n\n |[<!-- language=\"C\" -->\n GObject **object_p = collect_values[0].v_pointer;\n g_return_val_if_fail (object_p != NULL,\n g_strdup (\"object location passed as NULL\"));\n\n if (value->data[0].v_pointer == NULL)\n *object_p = NULL;\n else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) // always honour\n *object_p = value->data[0].v_pointer;\n else\n *object_p = g_object_ref (value->data[0].v_pointer);\n\n return NULL;\n ]|\n\n Returns: (transfer full) (nullable): `NULL` on success, otherwise\n a newly allocated error string on failure\n\n Since: 2.7...
[INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] |
[INFO] [stderr] = note: the link appears in this line:
[INFO] [stderr]
[INFO] [stderr] gchar **string_p = collect_values[0].v_pointer;
[INFO] [stderr] ^
[INFO] [stderr] = note: no item named `0` in scope
[INFO] [stderr] = help: to escape `[` and `]` characters, add '\' before them like `\[` or `\]`
[INFO] [stderr]
[INFO] [stderr] warning: unresolved link to `0`
[INFO] [stderr] --> src/bindings.rs:25436:9
[INFO] [stderr] |
[INFO] [stderr] 25436 | ... = " GTypeValueLCopyFunc:\n @value: the value to lcopy\n @n_collect_values: the number of collected values\n @collect_values: (array length=n_collect_values): the collected\n locations for storage\n @collect_flags: optional flags\n\n This function is responsible for storing the `value`\n contents into arguments passed through a variadic argument list which\n got collected into `collect_values` according to `lcopy_format`.\n\n The `n_collect_values` argument equals the string length of\n `lcopy_format`, and `collect_flags` may contain %G_VALUE_NOCOPY_CONTENTS.\n\n In contrast to #GTypeValueCollectFunc, this function is obliged to always\n properly support %G_VALUE_NOCOPY_CONTENTS.\n\n Similar to #GTypeValueCollectFunc the function may prematurely abort by\n returning a newly allocated string describing an error condition. To\n complete the string example:\n\n |[<!-- language=\"C\" -->\n gchar **string_p = collect_values[0].v_pointer;\n g_return_val_if_fail (string_p != NULL,\n g_strdup (\"string location passed as NULL\"));\n\n if (collect_flags & G_VALUE_NOCOPY_CONTENTS)\n *string_p = value->data[0].v_pointer;\n else\n *string_p = g_strdup (value->data[0].v_pointer);\n ]|\n\n And an illustrative version of this function for reference-counted\n types:\n\n |[<!-- language=\"C\" -->\n GObject **object_p = collect_values[0].v_pointer;\n g_return_val_if_fail (object_p != NULL,\n g_strdup (\"object location passed as NULL\"));\n\n if (value->data[0].v_pointer == NULL)\n *object_p = NULL;\n else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) // always honour\n *object_p = value->data[0].v_pointer;\n else\n *object_p = g_object_ref (value->data[0].v_pointer);\n\n return NULL;\n ]|\n\n Returns: (transfer full) (nullable): `NULL` on success, otherwise\n a newly allocated error string on failure\n\n Since: 2.7...
[INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] |
[INFO] [stderr] = note: the link appears in this line:
[INFO] [stderr]
[INFO] [stderr] *string_p = value->data[0].v_pointer;
[INFO] [stderr] ^
[INFO] [stderr] = note: no item named `0` in scope
[INFO] [stderr] = help: to escape `[` and `]` characters, add '\' before them like `\[` or `\]`
[INFO] [stderr]
[INFO] [stderr] warning: unresolved link to `0`
[INFO] [stderr] --> src/bindings.rs:25436:9
[INFO] [stderr] |
[INFO] [stderr] 25436 | ... = " GTypeValueLCopyFunc:\n @value: the value to lcopy\n @n_collect_values: the number of collected values\n @collect_values: (array length=n_collect_values): the collected\n locations for storage\n @collect_flags: optional flags\n\n This function is responsible for storing the `value`\n contents into arguments passed through a variadic argument list which\n got collected into `collect_values` according to `lcopy_format`.\n\n The `n_collect_values` argument equals the string length of\n `lcopy_format`, and `collect_flags` may contain %G_VALUE_NOCOPY_CONTENTS.\n\n In contrast to #GTypeValueCollectFunc, this function is obliged to always\n properly support %G_VALUE_NOCOPY_CONTENTS.\n\n Similar to #GTypeValueCollectFunc the function may prematurely abort by\n returning a newly allocated string describing an error condition. To\n complete the string example:\n\n |[<!-- language=\"C\" -->\n gchar **string_p = collect_values[0].v_pointer;\n g_return_val_if_fail (string_p != NULL,\n g_strdup (\"string location passed as NULL\"));\n\n if (collect_flags & G_VALUE_NOCOPY_CONTENTS)\n *string_p = value->data[0].v_pointer;\n else\n *string_p = g_strdup (value->data[0].v_pointer);\n ]|\n\n And an illustrative version of this function for reference-counted\n types:\n\n |[<!-- language=\"C\" -->\n GObject **object_p = collect_values[0].v_pointer;\n g_return_val_if_fail (object_p != NULL,\n g_strdup (\"object location passed as NULL\"));\n\n if (value->data[0].v_pointer == NULL)\n *object_p = NULL;\n else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) // always honour\n *object_p = value->data[0].v_pointer;\n else\n *object_p = g_object_ref (value->data[0].v_pointer);\n\n return NULL;\n ]|\n\n Returns: (transfer full) (nullable): `NULL` on success, otherwise\n a newly allocated error string on failure\n\n Since: 2.7...
[INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] |
[INFO] [stderr] = note: the link appears in this line:
[INFO] [stderr]
[INFO] [stderr] *string_p = g_strdup (value->data[0].v_pointer);
[INFO] [stderr] ^
[INFO] [stderr] = note: no item named `0` in scope
[INFO] [stderr] = help: to escape `[` and `]` characters, add '\' before them like `\[` or `\]`
[INFO] [stderr]
[INFO] [stderr] warning: unresolved link to `0`
[INFO] [stderr] --> src/bindings.rs:25436:9
[INFO] [stderr] |
[INFO] [stderr] 25436 | ... = " GTypeValueLCopyFunc:\n @value: the value to lcopy\n @n_collect_values: the number of collected values\n @collect_values: (array length=n_collect_values): the collected\n locations for storage\n @collect_flags: optional flags\n\n This function is responsible for storing the `value`\n contents into arguments passed through a variadic argument list which\n got collected into `collect_values` according to `lcopy_format`.\n\n The `n_collect_values` argument equals the string length of\n `lcopy_format`, and `collect_flags` may contain %G_VALUE_NOCOPY_CONTENTS.\n\n In contrast to #GTypeValueCollectFunc, this function is obliged to always\n properly support %G_VALUE_NOCOPY_CONTENTS.\n\n Similar to #GTypeValueCollectFunc the function may prematurely abort by\n returning a newly allocated string describing an error condition. To\n complete the string example:\n\n |[<!-- language=\"C\" -->\n gchar **string_p = collect_values[0].v_pointer;\n g_return_val_if_fail (string_p != NULL,\n g_strdup (\"string location passed as NULL\"));\n\n if (collect_flags & G_VALUE_NOCOPY_CONTENTS)\n *string_p = value->data[0].v_pointer;\n else\n *string_p = g_strdup (value->data[0].v_pointer);\n ]|\n\n And an illustrative version of this function for reference-counted\n types:\n\n |[<!-- language=\"C\" -->\n GObject **object_p = collect_values[0].v_pointer;\n g_return_val_if_fail (object_p != NULL,\n g_strdup (\"object location passed as NULL\"));\n\n if (value->data[0].v_pointer == NULL)\n *object_p = NULL;\n else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) // always honour\n *object_p = value->data[0].v_pointer;\n else\n *object_p = g_object_ref (value->data[0].v_pointer);\n\n return NULL;\n ]|\n\n Returns: (transfer full) (nullable): `NULL` on success, otherwise\n a newly allocated error string on failure\n\n Since: 2.7...
[INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] |
[INFO] [stderr] = note: the link appears in this line:
[INFO] [stderr]
[INFO] [stderr] GObject **object_p = collect_values[0].v_pointer;
[INFO] [stderr] ^
[INFO] [stderr] = note: no item named `0` in scope
[INFO] [stderr] = help: to escape `[` and `]` characters, add '\' before them like `\[` or `\]`
[INFO] [stderr]
[INFO] [stderr] warning: unresolved link to `0`
[INFO] [stderr] --> src/bindings.rs:25436:9
[INFO] [stderr] |
[INFO] [stderr] 25436 | ... = " GTypeValueLCopyFunc:\n @value: the value to lcopy\n @n_collect_values: the number of collected values\n @collect_values: (array length=n_collect_values): the collected\n locations for storage\n @collect_flags: optional flags\n\n This function is responsible for storing the `value`\n contents into arguments passed through a variadic argument list which\n got collected into `collect_values` according to `lcopy_format`.\n\n The `n_collect_values` argument equals the string length of\n `lcopy_format`, and `collect_flags` may contain %G_VALUE_NOCOPY_CONTENTS.\n\n In contrast to #GTypeValueCollectFunc, this function is obliged to always\n properly support %G_VALUE_NOCOPY_CONTENTS.\n\n Similar to #GTypeValueCollectFunc the function may prematurely abort by\n returning a newly allocated string describing an error condition. To\n complete the string example:\n\n |[<!-- language=\"C\" -->\n gchar **string_p = collect_values[0].v_pointer;\n g_return_val_if_fail (string_p != NULL,\n g_strdup (\"string location passed as NULL\"));\n\n if (collect_flags & G_VALUE_NOCOPY_CONTENTS)\n *string_p = value->data[0].v_pointer;\n else\n *string_p = g_strdup (value->data[0].v_pointer);\n ]|\n\n And an illustrative version of this function for reference-counted\n types:\n\n |[<!-- language=\"C\" -->\n GObject **object_p = collect_values[0].v_pointer;\n g_return_val_if_fail (object_p != NULL,\n g_strdup (\"object location passed as NULL\"));\n\n if (value->data[0].v_pointer == NULL)\n *object_p = NULL;\n else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) // always honour\n *object_p = value->data[0].v_pointer;\n else\n *object_p = g_object_ref (value->data[0].v_pointer);\n\n return NULL;\n ]|\n\n Returns: (transfer full) (nullable): `NULL` on success, otherwise\n a newly allocated error string on failure\n\n Since: 2.7...
[WARN] too much data in the log, truncating it