luc14n0/glib
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/glib.git synced 2024-12-25 15:06:14 +01:00
Code Issues Packages Projects Releases Wiki Activity

Docs: Don't use the note tag

Browse Source 
More markup avoidance.
This commit is contained in:
Matthias Clasen 2014-01-31 14:56:10 -05:00
parent 4cbee6a35b
commit c575d24dfb
22 changed files with 770 additions and 866 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
gio/gioscheduler.c
View File

@ -29,14 +29,12 @@
* @short_description: I/O Scheduler * @short_description: I/O Scheduler
* @include: gio/gio.h * @include: gio/gio.h
* *
* <note><para> * As of GLib 2.36, #GIOScheduler is deprecated in favor of
* As of GLib 2.36, the <literal>g_io_scheduler</literal> methods * #GThreadPool and #GTask.
* are deprecated in favor of #GThreadPool and #GTask.
* </para></note>
* *
* Schedules asynchronous I/O operations. #GIOScheduler integrates * Schedules asynchronous I/O operations. #GIOScheduler integrates
* into the main event loop (#GMainLoop) and uses threads. * into the main event loop (#GMainLoop) and uses threads.
**/ */
struct _GIOSchedulerJob { struct _GIOSchedulerJob {
GList *active_link; GList *active_link;

6
gio/gsettingsbackend.c
View File

@ -75,13 +75,11 @@ static gboolean g_settings_has_backend;
* g_settings_backend_create_tree() is a convenience function to create * g_settings_backend_create_tree() is a convenience function to create
* suitable trees. * suitable trees.
* *
* <note><para> * The GSettingsBackend API is exported to allow third-party
* The #GSettingsBackend API is exported to allow third-party
* implementations, but does not carry the same stability guarantees * implementations, but does not carry the same stability guarantees
* as the public GIO API. For this reason, you have to define the * as the public GIO API. For this reason, you have to define the
* C preprocessor symbol #G_SETTINGS_ENABLE_BACKEND before including * C preprocessor symbol %G_SETTINGS_ENABLE_BACKEND before including
* <filename>gio/gsettingsbackend.h</filename> * <filename>gio/gsettingsbackend.h</filename>
* </para></note>
**/ **/
static gboolean static gboolean

4
gio/gsimpleasyncresult.c
View File

@ -34,12 +34,10 @@
* SECTION:gsimpleasyncresult * SECTION:gsimpleasyncresult
* @short_description: Simple asynchronous results implementation * @short_description: Simple asynchronous results implementation
* @include: gio/gio.h * @include: gio/gio.h
* @see_also: #GAsyncResult * @see_also: #GAsyncResult, #GTask
* *
* <note><para>
* As of GLib 2.36, #GSimpleAsyncResult is deprecated in favor of * As of GLib 2.36, #GSimpleAsyncResult is deprecated in favor of
* #GTask, which provides a simpler API. * #GTask, which provides a simpler API.
* </para></note>
* *
* #GSimpleAsyncResult implements #GAsyncResult. * #GSimpleAsyncResult implements #GAsyncResult.
* *

4
gio/gthemedicon.c
View File

@ -390,10 +390,8 @@ g_themed_icon_get_names (GThemedIcon *icon)
* *
* Append a name to the list of icons from within @icon. * Append a name to the list of icons from within @icon.
* *
* <note><para>
* Note that doing so invalidates the hash computed by prior calls * Note that doing so invalidates the hash computed by prior calls
* to g_icon_hash(). * to g_icon_hash().
* </para></note>
*/ */
void void
g_themed_icon_append_name (GThemedIcon *icon, g_themed_icon_append_name (GThemedIcon *icon,
@ -419,10 +417,8 @@ g_themed_icon_append_name (GThemedIcon *icon,
* *
* Prepend a name to the list of icons from within @icon. * Prepend a name to the list of icons from within @icon.
* *
* <note><para>
* Note that doing so invalidates the hash computed by prior calls * Note that doing so invalidates the hash computed by prior calls
* to g_icon_hash(). * to g_icon_hash().
* </para></note>
* *
* Since: 2.18 * Since: 2.18
*/ */

261
glib/docs.c
View File

@ -409,11 +409,9 @@
* for scanning and printing values of type #gint64 or #guint64. * for scanning and printing values of type #gint64 or #guint64.
* It is a string literal. * It is a string literal.
* *
* <note><para> * Some platforms do not support printing 64-bit integers, even
* Some platforms do not support printing 64 bit integers, even * though the types are supported. On such platforms %G_GINT64_MODIFIER
* though the types are supported. On such platforms #G_GINT64_MODIFIER
* is not defined. * is not defined.
* </para></note>
* *
* Since: 2.4 * Since: 2.4
*/ */
@ -424,20 +422,18 @@
* This is the platform dependent conversion specifier for scanning * This is the platform dependent conversion specifier for scanning
* and printing values of type #gint64. See also #G_GINT16_FORMAT. * and printing values of type #gint64. See also #G_GINT16_FORMAT.
* *
* <note><para> * Some platforms do not support scanning and printing 64-bit integers,
* Some platforms do not support scanning and printing 64 bit integers, * even though the types are supported. On such platforms %G_GINT64_FORMAT
* even though the types are supported. On such platforms #G_GINT64_FORMAT * is not defined. Note that scanf() may not support 64-bit integers, even
* is not defined. Note that scanf() may not support 64 bit integers, even * if %G_GINT64_FORMAT is defined. Due to its weak error handling, scanf()
* if #G_GINT64_FORMAT is defined. Due to its weak error handling, scanf()
* is not recommended for parsing anyway; consider using g_ascii_strtoull() * is not recommended for parsing anyway; consider using g_ascii_strtoull()
* instead. * instead.
* </para></note>
*/ */
/** /**
* guint64: * guint64:
* *
* An unsigned integer guaranteed to be 64 bits on all platforms. * An unsigned integer guaranteed to be 64-bits on all platforms.
* Values of this type can range from 0 to #G_MAXUINT64 * Values of this type can range from 0 to #G_MAXUINT64
* (= 18,446,744,073,709,551,615). * (= 18,446,744,073,709,551,615).
* *
@ -457,14 +453,12 @@
* This is the platform dependent conversion specifier for scanning * This is the platform dependent conversion specifier for scanning
* and printing values of type #guint64. See also #G_GINT16_FORMAT. * and printing values of type #guint64. See also #G_GINT16_FORMAT.
* *
* <note><para> * Some platforms do not support scanning and printing 64-bit integers,
* Some platforms do not support scanning and printing 64 bit integers, * even though the types are supported. On such platforms %G_GUINT64_FORMAT
* even though the types are supported. On such platforms #G_GUINT64_FORMAT * is not defined. Note that scanf() may not support 64-bit integers, even
* is not defined. Note that scanf() may not support 64 bit integers, even * if %G_GINT64_FORMAT is defined. Due to its weak error handling, scanf()
* if #G_GINT64_FORMAT is defined. Due to its weak error handling, scanf()
* is not recommended for parsing anyway; consider using g_ascii_strtoull() * is not recommended for parsing anyway; consider using g_ascii_strtoull()
* instead. * instead.
* </para></note>
*/ */
/** /**
@ -498,7 +492,7 @@
* The minimum positive value which can be held in a #gfloat. * The minimum positive value which can be held in a #gfloat.
* *
* If you are interested in the smallest value which can be held * If you are interested in the smallest value which can be held
* in a #gfloat, use -G_MAXFLOAT. * in a #gfloat, use -%G_MAXFLOAT.
*/ */
/** /**
@ -520,7 +514,7 @@
* The minimum positive value which can be held in a #gdouble. * The minimum positive value which can be held in a #gdouble.
* *
* If you are interested in the smallest value which can be held * If you are interested in the smallest value which can be held
* in a #gdouble, use -G_MAXDOUBLE. * in a #gdouble, use -%G_MAXDOUBLE.
*/ */
/** /**
@ -535,8 +529,8 @@
* An unsigned integer type of the result of the sizeof operator, * An unsigned integer type of the result of the sizeof operator,
* corresponding to the size_t type defined in C99. * corresponding to the size_t type defined in C99.
* This type is wide enough to hold the numeric value of a pointer, * This type is wide enough to hold the numeric value of a pointer,
* so it is usually 32bit wide on a 32bit platform and 64bit wide * so it is usually 32 bit wide on a 32-bit platform and 64 bit wide
* on a 64bit platform. Values of this type can range from 0 to * on a 64-bit platform. Values of this type can range from 0 to
* #G_MAXSIZE. * #G_MAXSIZE.
* *
* To print or scan values of this type, use * To print or scan values of this type, use
@ -1711,7 +1705,7 @@
* arrays or arrays on the stack. * arrays or arrays on the stack.
*/ */
/* Miscellaneous Macros {{{1 */ / * Miscellaneous Macros {{{1 */
/** /**
* SECTION:macros_misc * SECTION:macros_misc
@ -1727,7 +1721,7 @@
* *
* This macro is used to export function prototypes so they can be linked * This macro is used to export function prototypes so they can be linked
* with an external version when no inlining is performed. The file which * with an external version when no inlining is performed. The file which
* implements the functions should define <literal>G_IMPLEMENTS_INLINES</literal> * implements the functions should define %G_IMPLEMENTS_INLINES
* before including the headers which contain %G_INLINE_FUNC declarations. * before including the headers which contain %G_INLINE_FUNC declarations.
* Since inlining is very compiler-dependent using these macros correctly * Since inlining is very compiler-dependent using these macros correctly
* is very difficult. Their use is strongly discouraged. * is very difficult. Their use is strongly discouraged.
@ -1755,7 +1749,7 @@
* G_BEGIN_DECLS: * G_BEGIN_DECLS:
* *
* Used (along with #G_END_DECLS) to bracket header files. If the * Used (along with #G_END_DECLS) to bracket header files. If the
* compiler in use is a C++ compiler, adds <literal>extern "C"</literal> * compiler in use is a C++ compiler, adds extern "C"
* around the header. * around the header.
*/ */
@ -1763,7 +1757,7 @@
* G_END_DECLS: * G_END_DECLS:
* *
* Used (along with #G_BEGIN_DECLS) to bracket header files. If the * Used (along with #G_BEGIN_DECLS) to bracket header files. If the
* compiler in use is a C++ compiler, adds <literal>extern "C"</literal> * compiler in use is a C++ compiler, adds extern "C"
* around the header. * around the header.
*/ */
@ -1804,7 +1798,7 @@
* @identifier2: an identifier * @identifier2: an identifier
* *
* Yields a new preprocessor pasted identifier * Yields a new preprocessor pasted identifier
* <code>identifier1identifier2</code> from its expanded * @identifier1identifier2 from its expanded
* arguments @identifier1 and @identifier2. For example, * arguments @identifier1 and @identifier2. For example,
* the following code: * the following code:
* |[ * |[
@ -1828,18 +1822,14 @@
* G_STATIC_ASSERT: * G_STATIC_ASSERT:
* @expr: a constant expression * @expr: a constant expression
* *
* The G_STATIC_ASSERT macro lets the programmer check * The G_STATIC_ASSERT() macro lets the programmer check
* a condition at compile time, the condition needs to * a condition at compile time, the condition needs to
* be compile time computable. The macro can be used in * be compile time computable. The macro can be used in
* any place where a <literal>typedef</literal> is valid. * any place where a typedef is valid.
* *
* <note><para> * A typedef is generally allowed in exactly the same places that
* A <literal>typedef</literal> is generally allowed in * a variable declaration is allowed. For this reason, you should
* exactly the same places that a variable declaration is * not use G_STATIC_ASSERT() in the middle of blocks of code.
* allowed. For this reason, you should not use
* <literal>G_STATIC_ASSERT</literal> in the middle of
* blocks of code.
* </para></note>
* *
* The macro should only be used once per source code line. * The macro should only be used once per source code line.
* *
@ -1850,15 +1840,14 @@
* G_STATIC_ASSERT_EXPR: * G_STATIC_ASSERT_EXPR:
* @expr: a constant expression * @expr: a constant expression
* *
* The G_STATIC_ASSERT_EXPR macro lets the programmer check * The G_STATIC_ASSERT_EXPR() macro lets the programmer check
* a condition at compile time. The condition needs to be * a condition at compile time. The condition needs to be
* compile time computable. * compile time computable.
* *
* Unlike <literal>G_STATIC_ASSERT</literal>, this macro * Unlike G_STATIC_ASSERT(), this macro evaluates to an expression
* evaluates to an expression and, as such, can be used in * and, as such, can be used in the middle of other expressions.
* the middle of other expressions. Its value should be * Its value should be ignored. This can be accomplished by placing
* ignored. This can be accomplished by placing it as * it as the first argument of a comma expression.
* the first argument of a comma expression.
* *
* |[ * |[
* #define ADD_ONE_TO_INT(x) \ * #define ADD_ONE_TO_INT(x) \
@ -1871,41 +1860,37 @@
/** /**
* G_GNUC_EXTENSION: * G_GNUC_EXTENSION:
* *
* Expands to <literal>__extension__</literal> when <command>gcc</command> * Expands to __extension__ when gcc is used as the compiler. This simply
* is used as the compiler. This simply tells <command>gcc</command> not * tells gcc not to warn about the following non-standard code when compiling
* to warn about the following non-standard code when compiling with the * with the <option>-pedantic</option> option.
* <option>-pedantic</option> option.
*/ */
/** /**
* G_GNUC_CONST: * G_GNUC_CONST:
* *
* Expands to the GNU C <literal>const</literal> function attribute if * Expands to the GNU C const function attribute if the compiler is gcc.
* the compiler is <command>gcc</command>. Declaring a function as const * Declaring a function as const enables better optimization of calls to
* enables better optimization of calls to the function. A const function * the function. A const function doesn't examine any values except its
* doesn't examine any values except its parameters, and has no effects * parameters, and has no effects except its return value.
* except its return value.
* *
* Place the attribute after the declaration, just before the semicolon. * Place the attribute after the declaration, just before the semicolon.
* *
* See the GNU C documentation for more details. * See the GNU C documentation for more details.
* *
* <note><para>
* A function that has pointer arguments and examines the data pointed to * A function that has pointer arguments and examines the data pointed to
* must <emphasis>not</emphasis> be declared const. Likewise, a function * must not be declared const. Likewise, a function that calls a non-const
* that calls a non-const function usually must not be const. It doesn't * function usually must not be const. It doesn't make sense for a const
* make sense for a const function to return void. * function to return void.
* </para></note>
*/ */
/** /**
* G_GNUC_PURE: * G_GNUC_PURE:
* *
* Expands to the GNU C <literal>pure</literal> function attribute if the * Expands to the GNU C pure function attribute if the compiler is gcc.
* compiler is <command>gcc</command>. Declaring a function as pure enables * Declaring a function as pure enables better optimization of calls to
* better optimization of calls to the function. A pure function has no * the function. A pure function has no effects except its return value
* effects except its return value and the return value depends only on * and the return value depends only on the parameters and/or global
* the parameters and/or global variables. * variables.
* *
* Place the attribute after the declaration, just before the semicolon. * Place the attribute after the declaration, just before the semicolon.
* *
@ -1915,12 +1900,11 @@
/** /**
* G_GNUC_MALLOC: * G_GNUC_MALLOC:
* *
* Expands to the GNU C <literal>malloc</literal> function attribute if the * Expands to the GNU C malloc function attribute if the compiler is gcc.
* compiler is <command>gcc</command>. Declaring a function as malloc enables * Declaring a function as malloc enables better optimization of the function.
* better optimization of the function. A function can have the malloc * A function can have the malloc attribute if it returns a pointer which is
* attribute if it returns a pointer which is guaranteed to not alias with * guaranteed to not alias with any other pointer when the function returns
* any other pointer when the function returns (in practice, this means newly * (in practice, this means newly allocated memory).
* allocated memory).
* *
* Place the attribute after the declaration, just before the semicolon. * Place the attribute after the declaration, just before the semicolon.
* *
@ -1933,10 +1917,10 @@
* G_GNUC_ALLOC_SIZE: * G_GNUC_ALLOC_SIZE:
* @x: the index of the argument specifying the allocation size * @x: the index of the argument specifying the allocation size
* *
* Expands to the GNU C <literal>alloc_size</literal> function attribute * Expands to the GNU C alloc_size function attribute if the compiler is
* if the compiler is a new enough <command>gcc</command>. This attribute * a new enough gcc. This attribute tells the compiler that the function
* tells the compiler that the function returns a pointer to memory of a * returns a pointer to memory of a size that is specified by the @xth
* size that is specified by the @x<!-- -->th function parameter. * function parameter.
* *
* Place the attribute after the function declaration, just before the * Place the attribute after the function declaration, just before the
* semicolon. * semicolon.
@ -1951,10 +1935,10 @@
* @x: the index of the argument specifying one factor of the allocation size * @x: the index of the argument specifying one factor of the allocation size
* @y: the index of the argument specifying the second factor of the allocation size * @y: the index of the argument specifying the second factor of the allocation size
* *
* Expands to the GNU C <literal>alloc_size</literal> function attribute * Expands to the GNU C alloc_size function attribute if the compiler is a
* if the compiler is a new enough <command>gcc</command>. This attribute * new enough gcc. This attribute tells the compiler that the function returns
* tells the compiler that the function returns a pointer to memory of a * a pointer to memory of a size that is specified by the product of two
* size that is specified by the product of two function parameters. * function parameters.
* *
* Place the attribute after the function declaration, just before the * Place the attribute after the function declaration, just before the
* semicolon. * semicolon.
@ -1967,11 +1951,10 @@
/** /**
* G_GNUC_DEPRECATED: * G_GNUC_DEPRECATED:
* *
* Expands to the GNU C <literal>deprecated</literal> attribute if the * Expands to the GNU C deprecated attribute if the compiler is gcc.
* compiler is <command>gcc</command>. It can be used to mark typedefs, * It can be used to mark typedefs, variables and functions as deprecated.
* variables and functions as deprecated. When called with the * When called with the <option>-Wdeprecated-declarations</option> option,
* <option>-Wdeprecated-declarations</option> option, the compiler will * gcc will generate warnings when deprecated interfaces are used.
* generate warnings when deprecated interfaces are used.
* *
* Place the attribute after the declaration, just before the semicolon. * Place the attribute after the declaration, just before the semicolon.
* *
@ -1986,8 +1969,8 @@
* such as the name of a function * such as the name of a function
* *
* Like %G_GNUC_DEPRECATED, but names the intended replacement for the * Like %G_GNUC_DEPRECATED, but names the intended replacement for the
* deprecated symbol if the version of <command>gcc</command> in use is * deprecated symbol if the version of gcc in use is new enough to support
* new enough to support custom deprecation messages. * custom deprecation messages.
* *
* Place the attribute after the declaration, just before the semicolon. * Place the attribute after the declaration, just before the semicolon.
* *
@ -2003,12 +1986,11 @@
/** /**
* G_GNUC_BEGIN_IGNORE_DEPRECATIONS: * G_GNUC_BEGIN_IGNORE_DEPRECATIONS:
* *
* Tells <command>gcc</command> (if it is a new enough version) to * Tells gcc (if it is a new enough version) to temporarily stop emitting
* temporarily stop emitting warnings when functions marked with * warnings when functions marked with %G_GNUC_DEPRECATED or
* %G_GNUC_DEPRECATED or %G_GNUC_DEPRECATED_FOR are called. This is * %G_GNUC_DEPRECATED_FOR are called. This is useful for when you have
* useful for when you have one deprecated function calling another * one deprecated function calling another one, or when you still have
* one, or when you still have regression tests for deprecated * regression tests for deprecated functions.
* functions.
* *
* Use %G_GNUC_END_IGNORE_DEPRECATIONS to begin warning again. (If you * Use %G_GNUC_END_IGNORE_DEPRECATIONS to begin warning again. (If you
* are not compiling with <literal>-Wdeprecated-declarations</literal> * are not compiling with <literal>-Wdeprecated-declarations</literal>
@ -2024,8 +2006,8 @@
* G_GNUC_END_IGNORE_DEPRECATIONS: * G_GNUC_END_IGNORE_DEPRECATIONS:
* *
* Undoes the effect of %G_GNUC_BEGIN_IGNORE_DEPRECATIONS, telling * Undoes the effect of %G_GNUC_BEGIN_IGNORE_DEPRECATIONS, telling
* <command>gcc</command> to begin outputting warnings again * gcc to begin outputting warnings again (assuming those warnings
* (assuming those warnings had been enabled to begin with). * had been enabled to begin with).
* *
* This macro can be used either inside or outside of a function body, * This macro can be used either inside or outside of a function body,
* but must appear on a line by itself. * but must appear on a line by itself.
@ -2049,8 +2031,8 @@
* @f: the name of the function that this function was deprecated for * @f: the name of the function that this function was deprecated for
* *
* This macro is similar to %G_GNUC_DEPRECATED_FOR, and can be used to mark * This macro is similar to %G_GNUC_DEPRECATED_FOR, and can be used to mark
* functions declarations as deprecated. Unlike %G_GNUC_DEPRECATED_FOR, it is * functions declarations as deprecated. Unlike %G_GNUC_DEPRECATED_FOR, it
* meant to be portable across different compilers and must be placed * is meant to be portable across different compilers and must be placed
* before the function declaration. * before the function declaration.
* *
* Since: 2.32 * Since: 2.32
@ -2079,10 +2061,9 @@
/** /**
* G_GNUC_NORETURN: * G_GNUC_NORETURN:
* *
* Expands to the GNU C <literal>noreturn</literal> function attribute * Expands to the GNU C noreturn function attribute if the compiler is gcc.
* if the compiler is <command>gcc</command>. It is used for declaring * It is used for declaring functions which never return. It enables
* functions which never return. It enables optimization of the function, * optimization of the function, and avoids possible compiler warnings.
* and avoids possible compiler warnings.
* *
* Place the attribute after the declaration, just before the semicolon. * Place the attribute after the declaration, just before the semicolon.
* *
@ -2092,10 +2073,9 @@
/** /**
* G_GNUC_UNUSED: * G_GNUC_UNUSED:
* *
* Expands to the GNU C <literal>unused</literal> function attribute if * Expands to the GNU C unused function attribute if the compiler is gcc.
* the compiler is <command>gcc</command>. It is used for declaring * It is used for declaring functions and arguments which may never be used.
* functions and arguments which may never be used. It avoids possible compiler * It avoids possible compiler warnings.
* warnings.
* *
* For functions, place the attribute after the declaration, just before the * For functions, place the attribute after the declaration, just before the
* semicolon. For arguments, place the attribute at the beginning of the * semicolon. For arguments, place the attribute at the beginning of the
@ -2115,11 +2095,10 @@
* format string (The arguments are numbered from 1) * format string (The arguments are numbered from 1)
* @arg_idx: the index of the first of the format arguments * @arg_idx: the index of the first of the format arguments
* *
* Expands to the GNU C <literal>format</literal> function attribute * Expands to the GNU C format function attribute if the compiler is gcc.
* if the compiler is <command>gcc</command>. This is used for declaring * This is used for declaring functions which take a variable number of
* functions which take a variable number of arguments, with the same * arguments, with the same syntax as printf(). It allows the compiler
* syntax as printf(). It allows the compiler to type-check the arguments * to type-check the arguments passed to the function.
* passed to the function.
* *
* Place the attribute after the function declaration, just before the * Place the attribute after the function declaration, just before the
* semicolon. * semicolon.
@ -2140,25 +2119,25 @@
* the format string (The arguments are numbered from 1) * the format string (The arguments are numbered from 1)
* @arg_idx: the index of the first of the format arguments * @arg_idx: the index of the first of the format arguments
* *
* Expands to the GNU C <literal>format</literal> function attribute * Expands to the GNU C format function attribute if the compiler is gcc.
* if the compiler is <command>gcc</command>. This is used for declaring * This is used for declaring functions which take a variable number of
* functions which take a variable number of arguments, with the same * arguments, with the same syntax as scanf(). It allows the compiler
* syntax as scanf(). It allows the compiler to type-check the arguments * to type-check the arguments passed to the function.
* passed to the function. See the GNU C documentation for details. *
* See the GNU C documentation for details.
*/ */
/** /**
* G_GNUC_FORMAT: * G_GNUC_FORMAT:
* @arg_idx: the index of the argument * @arg_idx: the index of the argument
* *
* Expands to the GNU C <literal>format_arg</literal> function attribute * Expands to the GNU C format_arg function attribute if the compiler
* if the compiler is <command>gcc</command>. This function attribute * is gcc. This function attribute specifies that a function takes a
* specifies that a function takes a format string for a printf(), * format string for a printf(), scanf(), strftime() or strfmon() style
* scanf(), strftime() or strfmon() style function and modifies it, * function and modifies it, so that the result can be passed to a printf(),
* so that the result can be passed to a printf(), scanf(), strftime() * scanf(), strftime() or strfmon() style function (with the remaining
* or strfmon() style function (with the remaining arguments to the * arguments to the format function the same as they would have been
* format function the same as they would have been for the unmodified * for the unmodified string).
* string).
* *
* Place the attribute after the function declaration, just before the * Place the attribute after the function declaration, just before the
* semicolon. * semicolon.
@ -2173,9 +2152,8 @@
/** /**
* G_GNUC_NULL_TERMINATED: * G_GNUC_NULL_TERMINATED:
* *
* Expands to the GNU C <literal>sentinel</literal> function attribute * Expands to the GNU C sentinel function attribute if the compiler is gcc.
* if the compiler is <command>gcc</command>, or "" if it isn't. This * This function attribute only applies to variadic functions and instructs
* function attribute only applies to variadic functions and instructs
* the compiler to check that the argument list is terminated with an * the compiler to check that the argument list is terminated with an
* explicit %NULL. * explicit %NULL.
* *
@ -2189,10 +2167,9 @@
/** /**
* G_GNUC_WARN_UNUSED_RESULT: * G_GNUC_WARN_UNUSED_RESULT:
* *
* Expands to the GNU C <literal>warn_unused_result</literal> function * Expands to the GNU C warn_unused_result function attribute if the compiler
* attribute if the compiler is <command>gcc</command>, or "" if it isn't. * is gcc. This function attribute makes the compiler emit a warning if the
* This function attribute makes the compiler emit a warning if the result * result of a function call is ignored.
* of a function call is ignored.
* *
* Place the attribute after the declaration, just before the semicolon. * Place the attribute after the declaration, just before the semicolon.
* *
@ -2204,30 +2181,28 @@
/** /**
* G_GNUC_FUNCTION: * G_GNUC_FUNCTION:
* *
* Expands to "" on all modern compilers, and to * Expands to "" on all modern compilers, and to __FUNCTION__ on gcc
* <literal>__FUNCTION__</literal> on <command>gcc</command> version 2.x. * version 2.x. Don't use it.
* Don't use it.
* *
* Deprecated: 2.16: Use #G_STRFUNC instead * Deprecated: 2.16: Use G_STRFUNC() instead
*/ */
/** /**
* G_GNUC_PRETTY_FUNCTION: * G_GNUC_PRETTY_FUNCTION:
* *
* Expands to "" on all modern compilers, and to * Expands to "" on all modern compilers, and to __PRETTY_FUNCTION__
* <literal>__PRETTY_FUNCTION__</literal> on <command>gcc</command> * on gcc version 2.x. Don't use it.
* version 2.x. Don't use it.
* *
* Deprecated: 2.16: Use #G_STRFUNC instead * Deprecated: 2.16: Use G_STRFUNC() instead
*/ */
/** /**
* G_GNUC_NO_INSTRUMENT: * G_GNUC_NO_INSTRUMENT:
* *
* Expands to the GNU C <literal>no_instrument_function</literal> function * Expands to the GNU C no_instrument_function function attribute if the
* attribute if the compiler is <command>gcc</command>. Functions with this * compiler is gcc. Functions with this attribute will not be instrumented
* attribute will not be instrumented for profiling, when the compiler is * for profiling, when the compiler is called with the
* called with the <option>-finstrument-functions</option> option. * <option>-finstrument-functions</option> option.
* *
* Place the attribute after the declaration, just before the semicolon. * Place the attribute after the declaration, just before the semicolon.
* *
@ -2244,8 +2219,8 @@
* details. * details.
* *
* When using a compiler that supports the GNU C hidden visibility attribute, * When using a compiler that supports the GNU C hidden visibility attribute,
* this macro expands to <literal>__attribute__((visibility("hidden")))</literal>. * this macro expands to __attribute__((visibility("hidden"))).
* When using the Sun Studio compiler, it expands to <literal>__hidden</literal>. * When using the Sun Studio compiler, it expands to __hidden.
* *
* Note that for portability, the attribute should be placed before the * Note that for portability, the attribute should be placed before the
* function declaration. While GCC allows the macro after the declaration, * function declaration. While GCC allows the macro after the declaration,
@ -2265,10 +2240,10 @@
/** /**
* G_GNUC_MAY_ALIAS: * G_GNUC_MAY_ALIAS:
* *
* Expands to the GNU C <literal>may_alias</literal> type attribute * Expands to the GNU C may_alias type attribute if the compiler is gcc.
* if the compiler is <command>gcc</command>. Types with this attribute * Types with this attribute will not be subjected to type-based alias
* will not be subjected to type-based alias analysis, but are assumed * analysis, but are assumed to alias with any other type, just like char.
* to alias with any other type, just like char. *
* See the GNU C documentation for details. * See the GNU C documentation for details.
* *
* Since: 2.14 * Since: 2.14
@ -2382,5 +2357,5 @@
* Since: 2.6 * Since: 2.6
*/ */
/* Epilogue {{{1 */ /* Epilogue {{{1 */
/* vim: set foldmethod=marker: */ /* vim: set foldmethod=marker: */

512
glib/garray.c
View File

File diff suppressed because it is too large Load Diff

24
glib/ggettext.c
View File

@ -520,11 +520,11 @@ g_dngettext (const gchar *domain,
* See the C_() macro for a different way to mark up translatable strings * See the C_() macro for a different way to mark up translatable strings
* with context. * with context.
* *
* <note><para>If you are using the Q_() macro, you need to make sure * If you are using the Q_() macro, you need to make sure that you pass
* that you pass <option>--keyword=Q_</option> to xgettext when extracting * <option>--keyword=Q_</option> to xgettext when extracting messages.
* messages. If you are using GNU gettext >= 0.15, you can also use * If you are using GNU gettext >= 0.15, you can also use
* <option>--keyword=Q_:1g</option> to let xgettext split the context * <option>--keyword=Q_:1g</option> to let xgettext split the context
* string off into a msgctxt line in the po file.</para></note> * string off into a msgctxt line in the po file.
* *
* Returns: the translated message * Returns: the translated message
* *
@ -545,10 +545,9 @@ g_dngettext (const gchar *domain,
* label2 = C_("Body part", "Back"); * label2 = C_("Body part", "Back");
* ]| * ]|
* *
* <note><para>If you are using the C_() macro, you need to make sure * If you are using the C_() macro, you need to make sure that you pass
* that you pass <option>--keyword=C_:1c,2</option> to xgettext when * <option>--keyword=C_:1c,2</option> to xgettext when extracting messages.
* extracting messages. Note that this only works with GNU * Note that this only works with GNU gettext >= 0.15.
* gettext >= 0.15.</para></note>
* *
* Returns: the translated message * Returns: the translated message
* *
@ -609,11 +608,10 @@ g_dngettext (const gchar *domain,
* } * }
* ]| * ]|
* *
* <note><para>If you are using the NC_() macro, you need to make sure * If you are using the NC_() macro, you need to make sure that you pass
* that you pass <option>--keyword=NC_:1c,2</option> to xgettext when * <option>--keyword=NC_:1c,2</option> to xgettext when extracting messages.
* extracting messages. Note that this only works with GNU gettext >= 0.15. * Note that this only works with GNU gettext >= 0.15. Intltool has support
* Intltool has support for the NC_() macro since version 0.40.1. * for the NC_() macro since version 0.40.1.
* </para></note>
* *
* Since: 2.18 * Since: 2.18
*/ */

7
glib/gkeyfile.c
View File

@ -3561,16 +3561,15 @@ g_key_file_has_key_full (GKeyFile *key_file,
* Looks whether the key file has the key @key in the group * Looks whether the key file has the key @key in the group
* @group_name. * @group_name.
* *
* <note>This function does not follow the rules for #GError strictly; * Note that this function does not follow the rules for #GError strictly;
* the return value both carries meaning and signals an error. To use * the return value both carries meaning and signals an error. To use
* this function, you must pass a #GError pointer in @error, and check * this function, you must pass a #GError pointer in @error, and check
* whether it is not %NULL to see if an error occurred.</note> * whether it is not %NULL to see if an error occurred.
* *
* Language bindings should use g_key_file_get_value() to test whether * Language bindings should use g_key_file_get_value() to test whether
* or not a key exists. * or not a key exists.
* *
* Return value: %TRUE if @key is a part of @group_name, %FALSE * Return value: %TRUE if @key is a part of @group_name, %FALSE otherwise
* otherwise.
* *
* Since: 2.6 * Since: 2.6
**/ **/

16
glib/glib-unix.c
View File

@ -63,19 +63,17 @@ g_unix_set_error_from_errno (GError **error,
/** /**
* g_unix_open_pipe: * g_unix_open_pipe:
* @fds: Array of two integers * @fds: Array of two integers
* @flags: Bitfield of file descriptor flags, see "man 2 fcntl" * @flags: Bitfield of file descriptor flags, as for fcntl()
* @error: a #GError * @error: a #GError
* *
* Similar to the UNIX pipe() call, but on modern systems like Linux * Similar to the UNIX pipe() call, but on modern systems like Linux
* uses the pipe2() system call, which atomically creates a pipe with * uses the pipe2() system call, which atomically creates a pipe with
* the configured flags. The only supported flag currently is * the configured flags. The only supported flag currently is
* <literal>FD_CLOEXEC</literal>. If for example you want to configure * %FD_CLOEXEC. If for example you want to configure %O_NONBLOCK, that
* <literal>O_NONBLOCK</literal>, that must still be done separately with * must still be done separately with fcntl().
* fcntl().
* *
* <note>This function does *not* take <literal>O_CLOEXEC</literal>, it takes * This function does not take %O_CLOEXEC, it takes %FD_CLOEXEC as if
* <literal>FD_CLOEXEC</literal> as if for fcntl(); these are * for fcntl(); these are different on Linux/glibc.
* different on Linux/glibc.</note>
* *
* Returns: %TRUE on success, %FALSE if not (and errno will be set). * Returns: %TRUE on success, %FALSE if not (and errno will be set).
* *
@ -138,8 +136,8 @@ g_unix_open_pipe (int *fds,
* @error: a #GError * @error: a #GError
* *
* Control the non-blocking state of the given file descriptor, * Control the non-blocking state of the given file descriptor,
* according to @nonblock. On most systems this uses <literal>O_NONBLOCK</literal>, but * according to @nonblock. On most systems this uses %O_NONBLOCK, but
* on some older ones may use <literal>O_NDELAY</literal>. * on some older ones may use %O_NDELAY.
* *
* Returns: %TRUE if successful * Returns: %TRUE if successful
* *

31
glib/glist.c
View File

@ -174,13 +174,10 @@ g_list_alloc (void)
* @list: a #GList * @list: a #GList
* *
* Frees all of the memory used by a #GList. * Frees all of the memory used by a #GList.
* The freed elements are returned to the slice allocator * The freed elements are returned to the slice allocator.
* *
* <note><para> * If list elements contain dynamically-allocated memory, you should
* If list elements contain dynamically-allocated memory, * either use g_list_free_full() or free them manually first.
* you should either use g_list_free_full() or free them manually
* first.
* </para></note>
*/ */
void void
g_list_free (GList *list) g_list_free (GList *list)
@ -299,10 +296,8 @@ g_list_append (GList *list,
* list = g_list_prepend (list, "first"); * list = g_list_prepend (list, "first");
* ]| * ]|
* *
* <note><para> * Do not use this function to prepend a new element to a different
* Do not use this function to prepend a new element to a different element * element than the start of the list. Use g_list_insert_before() instead.
* than the start of the list. Use g_list_insert_before() instead.
* </para></note>
* *
* Returns: a pointer to the newly prepended element, which is the new * Returns: a pointer to the newly prepended element, which is the new
* start of the #GList * start of the #GList
@ -625,12 +620,10 @@ g_list_delete_link (GList *list,
* *
* Copies a #GList. * Copies a #GList.
* *
* <note><para>
* Note that this is a "shallow" copy. If the list elements * Note that this is a "shallow" copy. If the list elements
* consist of pointers to data, the pointers are copied but * consist of pointers to data, the pointers are copied but
* the actual data is not. See g_list_copy_deep() if you need * the actual data is not. See g_list_copy_deep() if you need
* to copy the data as well. * to copy the data as well.
* </para></note>
* *
* Returns: the start of the new list that holds the same data as @list * Returns: the start of the new list that holds the same data as @list
*/ */
@ -955,11 +948,9 @@ g_list_first (GList *list)
* *
* Gets the number of elements in a #GList. * Gets the number of elements in a #GList.
* *
* <note><para>
* This function iterates over the whole list to count its elements. * This function iterates over the whole list to count its elements.
* Use a <link linkend="glib-Double-ended-Queues">GQueue</link> instead * Use a #GQueue instead of a GList if you regularly need the number
* of a GList if you regularly need the number of items. * of items.
* </para></note>
* *
* Returns: the number of elements in the #GList * Returns: the number of elements in the #GList
*/ */
@ -1071,12 +1062,10 @@ g_list_insert_sorted_real (GList *list,
* Inserts a new element into the list, using the given comparison * Inserts a new element into the list, using the given comparison
* function to determine its position. * function to determine its position.
* *
* <note><para>
* If you are adding many new elements to a list, and the number of * If you are adding many new elements to a list, and the number of
* new elements is much larger than the length of the list, use * new elements is much larger than the length of the list, use
* g_list_prepend() to add the new items and sort the list afterwards * g_list_prepend() to add the new items and sort the list afterwards
* with g_list_sort() * with g_list_sort().
* </para></note>
* *
* Returns: the (possibly changed) start of the #GList * Returns: the (possibly changed) start of the #GList
*/ */
@ -1101,12 +1090,10 @@ g_list_insert_sorted (GList *list,
* Inserts a new element into the list, using the given comparison * Inserts a new element into the list, using the given comparison
* function to determine its position. * function to determine its position.
* *
* <note><para>
* If you are adding many new elements to a list, and the number of * If you are adding many new elements to a list, and the number of
* new elements is much larger than the length of the list, use * new elements is much larger than the length of the list, use
* g_list_prepend() to add the new items and sort the list afterwards * g_list_prepend() to add the new items and sort the list afterwards
* with g_list_sort() * with g_list_sort().
* </para></note>
* *
* Returns: the (possibly changed) start of the #GList * Returns: the (possibly changed) start of the #GList
* *

48
glib/gmacros.h
View File

@ -42,18 +42,16 @@
* "long long" types even in the presence of '-ansi -pedantic'. * "long long" types even in the presence of '-ansi -pedantic'.
*/ */
#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 8) #if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 8)
# define G_GNUC_EXTENSION __extension__ #define G_GNUC_EXTENSION __extension__
#else #else
# define G_GNUC_EXTENSION #define G_GNUC_EXTENSION
#endif #endif
/* Provide macros to feature the GCC function attribute. /* Provide macros to feature the GCC function attribute.
*/ */
#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 96) #if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 96)
#define G_GNUC_PURE \ #define G_GNUC_PURE __attribute__((__pure__))
__attribute__((__pure__)) #define G_GNUC_MALLOC __attribute__((__malloc__))
#define G_GNUC_MALLOC \
__attribute__((__malloc__))
#else #else
#define G_GNUC_PURE #define G_GNUC_PURE
#define G_GNUC_MALLOC #define G_GNUC_MALLOC
@ -99,8 +97,7 @@
#endif /* !__GNUC__ */ #endif /* !__GNUC__ */
#if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1) #if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1)
#define G_GNUC_DEPRECATED \ #define G_GNUC_DEPRECATED __attribute__((__deprecated__))
__attribute__((__deprecated__))
#else #else
#define G_GNUC_DEPRECATED #define G_GNUC_DEPRECATED
#endif /* __GNUC__ */ #endif /* __GNUC__ */
@ -130,14 +127,13 @@
#endif #endif
#if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 3) #if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 3)
# define G_GNUC_MAY_ALIAS __attribute__((may_alias)) #define G_GNUC_MAY_ALIAS __attribute__((may_alias))
#else #else
# define G_GNUC_MAY_ALIAS #define G_GNUC_MAY_ALIAS
#endif #endif
#if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) #if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
#define G_GNUC_WARN_UNUSED_RESULT \ #define G_GNUC_WARN_UNUSED_RESULT __attribute__((warn_unused_result))
__attribute__((warn_unused_result))
#else #else
#define G_GNUC_WARN_UNUSED_RESULT #define G_GNUC_WARN_UNUSED_RESULT
#endif /* __GNUC__ */ #endif /* __GNUC__ */
@ -185,29 +181,29 @@
/* Provide a string identifying the current code position */ /* Provide a string identifying the current code position */
#if defined(__GNUC__) && (__GNUC__ < 3) && !defined(__cplusplus) #if defined(__GNUC__) && (__GNUC__ < 3) && !defined(__cplusplus)
# define G_STRLOC __FILE__ ":" G_STRINGIFY (__LINE__) ":" __PRETTY_FUNCTION__ "()" #define G_STRLOC __FILE__ ":" G_STRINGIFY (__LINE__) ":" __PRETTY_FUNCTION__ "()"
#else #else
# define G_STRLOC __FILE__ ":" G_STRINGIFY (__LINE__) #define G_STRLOC __FILE__ ":" G_STRINGIFY (__LINE__)
#endif #endif
/* Provide a string identifying the current function, non-concatenatable */ /* Provide a string identifying the current function, non-concatenatable */
#if defined (__GNUC__) && defined (__cplusplus) #if defined (__GNUC__) && defined (__cplusplus)
# define G_STRFUNC ((const char*) (__PRETTY_FUNCTION__)) #define G_STRFUNC ((const char*) (__PRETTY_FUNCTION__))
#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
# define G_STRFUNC ((const char*) (__func__)) #define G_STRFUNC ((const char*) (__func__))
#elif defined (__GNUC__) || (defined(_MSC_VER) && (_MSC_VER > 1300)) #elif defined (__GNUC__) || (defined(_MSC_VER) && (_MSC_VER > 1300))
# define G_STRFUNC ((const char*) (__FUNCTION__)) #define G_STRFUNC ((const char*) (__FUNCTION__))
#else #else
# define G_STRFUNC ((const char*) ("???")) #define G_STRFUNC ((const char*) ("???"))
#endif #endif
/* Guard C code in headers, while including them from C++ */ /* Guard C code in headers, while including them from C++ */
#ifdef __cplusplus #ifdef __cplusplus
# define G_BEGIN_DECLS extern "C" { #define G_BEGIN_DECLS extern "C" {
# define G_END_DECLS } #define G_END_DECLS }
#else #else
# define G_BEGIN_DECLS #define G_BEGIN_DECLS
# define G_END_DECLS #define G_END_DECLS
#endif #endif
/* Provide definitions for some commonly used macros. /* Provide definitions for some commonly used macros.
@ -259,10 +255,10 @@
*/ */
#if defined(__GNUC__) && __GNUC__ >= 4 #if defined(__GNUC__) && __GNUC__ >= 4
# define G_STRUCT_OFFSET(struct_type, member) \ #define G_STRUCT_OFFSET(struct_type, member) \
((glong) offsetof (struct_type, member)) ((glong) offsetof (struct_type, member))
#else #else
# define G_STRUCT_OFFSET(struct_type, member) \ #define G_STRUCT_OFFSET(struct_type, member) \
((glong) ((guint8*) &((struct_type*) 0)->member)) ((glong) ((guint8*) &((struct_type*) 0)->member))
#endif #endif
@ -279,8 +275,8 @@
* avoid portability issue or side effects when compiled with different compilers. * avoid portability issue or side effects when compiled with different compilers.
*/ */
#if !(defined (G_STMT_START) && defined (G_STMT_END)) #if !(defined (G_STMT_START) && defined (G_STMT_END))
# define G_STMT_START do #define G_STMT_START do
# define G_STMT_END while (0) #define G_STMT_END while (0)
#endif #endif
/* Deprecated -- do not use. */ /* Deprecated -- do not use. */

15
glib/gmem.c
View File

@ -66,18 +66,15 @@ static GMemVTable glib_mem_vtable = {
* *
* These functions provide support for allocating and freeing memory. * These functions provide support for allocating and freeing memory.
* *
* <note>
* If any call to allocate memory fails, the application is terminated. * If any call to allocate memory fails, the application is terminated.
* This also means that there is no need to check if the call succeeded. * This also means that there is no need to check if the call succeeded.
* </note>
* *
* <note> * It's important to match g_malloc() (and wrappers such as g_new()) with
* It's important to match g_malloc() with g_free(), plain malloc() with free(), * g_free(), g_slice_alloc() and wrappers such as g_slice_new()) with
* and (if you're using C++) new with delete and new[] with delete[]. Otherwise * g_slice_free(), plain malloc() with free(), and (if you're using C++)
* bad things can happen, since these allocators may use different memory * new with delete and new[] with delete[]. Otherwise bad things can happen,
* pools (and new/delete call constructors and destructors). See also * since these allocators may use different memory pools (and new/delete call
* g_mem_set_vtable(). * constructors and destructors). See also g_mem_set_vtable().
* </note>
*/ */
/* --- functions --- */ /* --- functions --- */

7
glib/gqueue.c
View File

@ -75,11 +75,8 @@ g_queue_new (void)
* if @queue was created with g_queue_new(). If queue elements contain * if @queue was created with g_queue_new(). If queue elements contain
* dynamically-allocated memory, they should be freed first. * dynamically-allocated memory, they should be freed first.
* *
* <note><para> * If queue elements contain dynamically-allocated memory, you should
* If queue elements contain dynamically-allocated memory, * either use g_queue_free_full() or free them manually first.
* you should either use g_queue_free_full() or free them manually
* first.
* </para></note>
**/ **/
void void
g_queue_free (GQueue *queue) g_queue_free (GQueue *queue)

8
glib/gsequence.c
View File

@ -769,13 +769,11 @@ g_sequence_sort_changed (GSequenceIter *iter,
* If you are simply searching for an existing element of the sequence, * If you are simply searching for an existing element of the sequence,
* consider using g_sequence_lookup(). * consider using g_sequence_lookup().
* *
* <note><para>
* This function will fail if the data contained in the sequence is * This function will fail if the data contained in the sequence is
* unsorted. Use g_sequence_insert_sorted() or * unsorted. Use g_sequence_insert_sorted() or
* g_sequence_insert_sorted_iter() to add data to your sequence or, if * g_sequence_insert_sorted_iter() to add data to your sequence or, if
* you want to add a large amount of data, call g_sequence_sort() after * you want to add a large amount of data, call g_sequence_sort() after
* doing unsorted insertions. * doing unsorted insertions.
* </para></note>
* *
* Return value: an #GSequenceIter pointing to the position where @data * Return value: an #GSequenceIter pointing to the position where @data
* would have been inserted according to @cmp_func and @cmp_data. * would have been inserted according to @cmp_func and @cmp_data.
@ -818,13 +816,11 @@ g_sequence_search (GSequence *seq,
* the first item comes before the second, and a positive value if * the first item comes before the second, and a positive value if
* the second item comes before the first. * the second item comes before the first.
* *
* <note><para>
* This function will fail if the data contained in the sequence is * This function will fail if the data contained in the sequence is
* unsorted. Use g_sequence_insert_sorted() or * unsorted. Use g_sequence_insert_sorted() or
* g_sequence_insert_sorted_iter() to add data to your sequence or, if * g_sequence_insert_sorted_iter() to add data to your sequence or, if
* you want to add a large amount of data, call g_sequence_sort() after * you want to add a large amount of data, call g_sequence_sort() after
* doing unsorted insertions. * doing unsorted insertions.
* </para></note>
* *
* Return value: an #GSequenceIter pointing to the position of the * Return value: an #GSequenceIter pointing to the position of the
* first item found equal to @data according to @cmp_func and * first item found equal to @data according to @cmp_func and
@ -1052,13 +1048,11 @@ g_sequence_insert_sorted_iter (GSequence *seq,
* If you are simply searching for an existing element of the sequence, * If you are simply searching for an existing element of the sequence,
* consider using g_sequence_lookup_iter(). * consider using g_sequence_lookup_iter().
* *
* <note><para>
* This function will fail if the data contained in the sequence is * This function will fail if the data contained in the sequence is
* unsorted. Use g_sequence_insert_sorted() or * unsorted. Use g_sequence_insert_sorted() or
* g_sequence_insert_sorted_iter() to add data to your sequence or, if * g_sequence_insert_sorted_iter() to add data to your sequence or, if
* you want to add a large amount of data, call g_sequence_sort() after * you want to add a large amount of data, call g_sequence_sort() after
* doing unsorted insertions. * doing unsorted insertions.
* </para></note>
* *
* Return value: a #GSequenceIter pointing to the position in @seq * Return value: a #GSequenceIter pointing to the position in @seq
* where @data would have been inserted according to @iter_cmp * where @data would have been inserted according to @iter_cmp
@ -1112,13 +1106,11 @@ g_sequence_search_iter (GSequence *seq,
* if the first iterator comes before the second, and a positive * if the first iterator comes before the second, and a positive
* value if the second iterator comes before the first. * value if the second iterator comes before the first.
* *
* <note><para>
* This function will fail if the data contained in the sequence is * This function will fail if the data contained in the sequence is
* unsorted. Use g_sequence_insert_sorted() or * unsorted. Use g_sequence_insert_sorted() or
* g_sequence_insert_sorted_iter() to add data to your sequence or, if * g_sequence_insert_sorted_iter() to add data to your sequence or, if
* you want to add a large amount of data, call g_sequence_sort() after * you want to add a large amount of data, call g_sequence_sort() after
* doing unsorted insertions. * doing unsorted insertions.
* </para></note>
* *
* Return value: an #GSequenceIter pointing to the position of * Return value: an #GSequenceIter pointing to the position of
* the first item found equal to @data according to @cmp_func * the first item found equal to @data according to @cmp_func

30
glib/gslist.c
View File

@ -128,11 +128,9 @@ g_slist_alloc (void)
* Frees all of the memory used by a #GSList. * Frees all of the memory used by a #GSList.
* The freed elements are returned to the slice allocator. * The freed elements are returned to the slice allocator.
* *
* <note><para>
* If list elements contain dynamically-allocated memory, * If list elements contain dynamically-allocated memory,
* you should either use g_slist_free_full() or free them manually * you should either use g_slist_free_full() or free them manually
* first. * first.
* </para></note>
*/ */
void void
g_slist_free (GSList *list) g_slist_free (GSList *list)
@ -185,17 +183,13 @@ g_slist_free_full (GSList *list,
* *
* Adds a new element on to the end of the list. * Adds a new element on to the end of the list.
* *
* <note><para>
* The return value is the new start of the list, which may * The return value is the new start of the list, which may
* have changed, so make sure you store the new value. * have changed, so make sure you store the new value.
* </para></note>
* *
* <note><para>
* Note that g_slist_append() has to traverse the entire list * Note that g_slist_append() has to traverse the entire list
* to find the end, which is inefficient when adding multiple * to find the end, which is inefficient when adding multiple
* elements. A common idiom to avoid the inefficiency is to prepend * elements. A common idiom to avoid the inefficiency is to prepend
* the elements and reverse the list when all elements have been added. * the elements and reverse the list when all elements have been added.
* </para></note>
* *
* |[ * |[
* /&ast; Notice that these are initialized to the empty list. &ast;/ * /&ast; Notice that these are initialized to the empty list. &ast;/
@ -242,10 +236,8 @@ g_slist_append (GSList *list,
* *
* Adds a new element on to the start of the list. * Adds a new element on to the start of the list.
* *
* <note><para>
* The return value is the new start of the list, which * The return value is the new start of the list, which
* may have changed, so make sure you store the new value. * may have changed, so make sure you store the new value.
* </para></note>
* *
* |[ * |[
* /&ast; Notice that it is initialized to the empty list. &ast;/ * /&ast; Notice that it is initialized to the empty list. &ast;/
@ -515,11 +507,11 @@ _g_slist_remove_link (GSList *list,
* link is set to %NULL, so that it becomes a * link is set to %NULL, so that it becomes a
* self-contained list with one element. * self-contained list with one element.
* *
* <note>Removing arbitrary nodes from a singly-linked list * Removing arbitrary nodes from a singly-linked list
* requires time that is proportional to the length of the list * requires time that is proportional to the length of the list
* (ie. O(n)). If you find yourself using g_slist_remove_link() * (ie. O(n)). If you find yourself using g_slist_remove_link()
* frequently, you should consider a different data structure, such * frequently, you should consider a different data structure,
* as the doubly-linked #GList.</note> * such as the doubly-linked #GList.
* *
* Returns: the new start of the #GSList, without the element * Returns: the new start of the #GSList, without the element
*/ */
@ -539,11 +531,11 @@ g_slist_remove_link (GSList *list,
* Compare this to g_slist_remove_link() which removes the node * Compare this to g_slist_remove_link() which removes the node
* without freeing it. * without freeing it.
* *
* <note>Removing arbitrary nodes from a singly-linked list * Removing arbitrary nodes from a singly-linked list requires time
* requires time that is proportional to the length of the list * that is proportional to the length of the list (ie. O(n)). If you
* (ie. O(n)). If you find yourself using g_slist_delete_link() * find yourself using g_slist_delete_link() frequently, you should
* frequently, you should consider a different data structure, such * consider a different data structure, such as the doubly-linked
* as the doubly-linked #GList.</note> * #GList.
* *
* Returns: the new head of @list * Returns: the new head of @list
*/ */
@ -563,12 +555,10 @@ g_slist_delete_link (GSList *list,
* *
* Copies a #GSList. * Copies a #GSList.
* *
* <note><para>
* Note that this is a "shallow" copy. If the list elements * Note that this is a "shallow" copy. If the list elements
* consist of pointers to data, the pointers are copied but * consist of pointers to data, the pointers are copied but
* the actual data isn't. See g_slist_copy_deep() if you need * the actual data isn't. See g_slist_copy_deep() if you need
* to copy the data as well. * to copy the data as well.
* </para></note>
* *
* Returns: a copy of @list * Returns: a copy of @list
*/ */
@ -828,9 +818,7 @@ g_slist_index (GSList *list,
* *
* Gets the last element in a #GSList. * Gets the last element in a #GSList.
* *
* <note><para>
* This function iterates over the whole list. * This function iterates over the whole list.
* </para></note>
* *
* Returns: the last element in the #GSList, * Returns: the last element in the #GSList,
* or %NULL if the #GSList has no elements * or %NULL if the #GSList has no elements
@ -853,10 +841,8 @@ g_slist_last (GSList *list)
* *
* Gets the number of elements in a #GSList. * Gets the number of elements in a #GSList.
* *
* <note><para>
* This function iterates over the whole list to * This function iterates over the whole list to
* count its elements. * count its elements.
* </para></note>
* *
* Returns: the number of elements in the #GSList * Returns: the number of elements in the #GSList
*/ */

157
glib/gspawn.c
View File

@ -109,17 +109,14 @@ G_DEFINE_QUARK (g-spawn-exit-error-quark, g_spawn_exit_error)
* You should call g_spawn_close_pid() on the returned child process * You should call g_spawn_close_pid() on the returned child process
* reference when you don't need it any more. * reference when you don't need it any more.
* *
* <note><para> * If you are writing a GTK+ application, and the program you are
* If you are writing a GTK+ application, and the program you * spawning is a graphical application, too, then you may want to
* are spawning is a graphical application, too, then you may * use gdk_spawn_on_screen() instead to ensure that the spawned program
* want to use gdk_spawn_on_screen() instead to ensure that * opens its windows on the right screen.
* the spawned program opens its windows on the right screen.
* </para></note>
* *
* <note><para> Note that the returned @child_pid on Windows is a * Note that the returned @child_pid on Windows is a handle to the child
* handle to the child process and not its identifier. Process handles * process and not its identifier. Process handles and process identifiers
* and process identifiers are different concepts on Windows. * are different concepts on Windows.
* </para></note>
* *
* Return value: %TRUE on success, %FALSE if error is set * Return value: %TRUE on success, %FALSE if error is set
**/ **/
@ -237,8 +234,8 @@ read_data (GString *str,
* function for full details on the other parameters and details on * function for full details on the other parameters and details on
* how these functions work on Windows. * how these functions work on Windows.
* *
* Return value: %TRUE on success, %FALSE if an error was set. * Return value: %TRUE on success, %FALSE if an error was set
**/ */
gboolean gboolean
g_spawn_sync (const gchar *working_directory, g_spawn_sync (const gchar *working_directory,
gchar **argv, gchar **argv,
@ -509,21 +506,19 @@ g_spawn_sync (const gchar *working_directory,
* level wide character command line passed to the spawned program * level wide character command line passed to the spawned program
* using the GetCommandLineW() function. * using the GetCommandLineW() function.
* *
* On Windows the low-level child process creation API * On Windows the low-level child process creation API CreateProcess()
* <function>CreateProcess()</function> doesn't use argument vectors, * doesn't use argument vectors, but a command line. The C runtime
* but a command line. The C runtime library's * library's spawn*() family of functions (which g_spawn_async_with_pipes()
* <function>spawn*()</function> family of functions (which * eventually calls) paste the argument vector elements together into
* g_spawn_async_with_pipes() eventually calls) paste the argument * a command line, and the C runtime startup code does a corresponding
* vector elements together into a command line, and the C runtime startup code * reconstruction of an argument vector from the command line, to be
* does a corresponding reconstruction of an argument vector from the * passed to main(). Complications arise when you have argument vector
* command line, to be passed to main(). Complications arise when you have * elements that contain spaces of double quotes. The spawn*() functions
* argument vector elements that contain spaces of double quotes. The * don't do any quoting or escaping, but on the other hand the startup
* <function>spawn*()</function> functions don't do any quoting or * code does do unquoting and unescaping in order to enable receiving
* escaping, but on the other hand the startup code does do unquoting * arguments with embedded spaces or double quotes. To work around this
* and unescaping in order to enable receiving arguments with embedded * asymmetry, g_spawn_async_with_pipes() will do quoting and escaping on
* spaces or double quotes. To work around this asymmetry, * argument vector elements that need it before calling the C runtime
* g_spawn_async_with_pipes() will do quoting and escaping on argument
* vector elements that need it before calling the C runtime
* spawn() function. * spawn() function.
* *
* The returned @child_pid on Windows is a handle to the child * The returned @child_pid on Windows is a handle to the child
@ -542,20 +537,19 @@ g_spawn_sync (const gchar *working_directory,
* call g_spawn_close_pid() on the @child_pid, in order to free * call g_spawn_close_pid() on the @child_pid, in order to free
* resources which may be associated with the child process. (On Unix, * resources which may be associated with the child process. (On Unix,
* using a child watch is equivalent to calling waitpid() or handling * using a child watch is equivalent to calling waitpid() or handling
* the <literal>SIGCHLD</literal> signal manually. On Windows, calling g_spawn_close_pid() * the %SIGCHLD signal manually. On Windows, calling g_spawn_close_pid()
* is equivalent to calling CloseHandle() on the process handle returned * is equivalent to calling CloseHandle() on the process handle returned
* in @child_pid). See g_child_watch_add(). * in @child_pid). See g_child_watch_add().
* *
* %G_SPAWN_LEAVE_DESCRIPTORS_OPEN means that the parent's open file * %G_SPAWN_LEAVE_DESCRIPTORS_OPEN means that the parent's open file
* descriptors will be inherited by the child; otherwise all * descriptors will be inherited by the child; otherwise all descriptors
* descriptors except stdin/stdout/stderr will be closed before * except stdin/stdout/stderr will be closed before calling exec() in the
* calling exec() in the child. %G_SPAWN_SEARCH_PATH * child. %G_SPAWN_SEARCH_PATH means that @argv[0] need not be an absolute
* means that <literal>argv[0]</literal> need not be an absolute path, it * path, it will be looked for in the <envar>PATH</envar> environment
* will be looked for in the <envar>PATH</envar> environment variable. * variable. %G_SPAWN_SEARCH_PATH_FROM_ENVP means need not be an absolute
* %G_SPAWN_SEARCH_PATH_FROM_ENVP means need not be an absolute path, it * path, it will be looked for in the <envar>PATH</envar> variable from
* will be looked for in the <envar>PATH</envar> variable from @envp. If * @envp. If both %G_SPAWN_SEARCH_PATH and %G_SPAWN_SEARCH_PATH_FROM_ENVP
* both %G_SPAWN_SEARCH_PATH and %G_SPAWN_SEARCH_PATH_FROM_ENVP are used, * are used, the value from @envp takes precedence over the environment.
* the value from @envp takes precedence over the environment.
* %G_SPAWN_STDOUT_TO_DEV_NULL means that the child's standard output will * %G_SPAWN_STDOUT_TO_DEV_NULL means that the child's standard output will
* be discarded, instead of going to the same location as the parent's * be discarded, instead of going to the same location as the parent's
* standard output. If you use this flag, @standard_output must be %NULL. * standard output. If you use this flag, @standard_output must be %NULL.
@ -566,42 +560,40 @@ g_spawn_sync (const gchar *working_directory,
* standard input (by default, the child's standard input is attached to * standard input (by default, the child's standard input is attached to
* /dev/null). If you use this flag, @standard_input must be %NULL. * /dev/null). If you use this flag, @standard_input must be %NULL.
* %G_SPAWN_FILE_AND_ARGV_ZERO means that the first element of @argv is * %G_SPAWN_FILE_AND_ARGV_ZERO means that the first element of @argv is
* the file to execute, while the remaining elements are the * the file to execute, while the remaining elements are the actual
* actual argument vector to pass to the file. Normally * argument vector to pass to the file. Normally g_spawn_async_with_pipes()
* g_spawn_async_with_pipes() uses @argv[0] as the file to execute, and * uses @argv[0] as the file to execute, and passes all of @argv to the child.
* passes all of @argv to the child.
* *
* @child_setup and @user_data are a function and user data. On POSIX * @child_setup and @user_data are a function and user data. On POSIX
* platforms, the function is called in the child after GLib has * platforms, the function is called in the child after GLib has
* performed all the setup it plans to perform (including creating * performed all the setup it plans to perform (including creating
* pipes, closing file descriptors, etc.) but before calling * pipes, closing file descriptors, etc.) but before calling exec().
* exec(). That is, @child_setup is called just * That is, @child_setup is called just before calling exec() in the
* before calling exec() in the child. Obviously * child. Obviously actions taken in this function will only affect
* actions taken in this function will only affect the child, not the * the child, not the parent.
* parent.
* *
* On Windows, there is no separate fork() and exec() * On Windows, there is no separate fork() and exec() functionality.
* functionality. Child processes are created and run with a single * Child processes are created and run with a single API call,
* API call, CreateProcess(). There is no sensible thing @child_setup * CreateProcess(). There is no sensible thing @child_setup
* could be used for on Windows so it is ignored and not called. * could be used for on Windows so it is ignored and not called.
* *
* If non-%NULL, @child_pid will on Unix be filled with the child's * If non-%NULL, @child_pid will on Unix be filled with the child's
* process ID. You can use the process ID to send signals to the * process ID. You can use the process ID to send signals to the child,
* child, or to use g_child_watch_add() (or waitpid()) if you specified the * or to use g_child_watch_add() (or waitpid()) if you specified the
* %G_SPAWN_DO_NOT_REAP_CHILD flag. On Windows, @child_pid will be * %G_SPAWN_DO_NOT_REAP_CHILD flag. On Windows, @child_pid will be
* filled with a handle to the child process only if you specified the * filled with a handle to the child process only if you specified the
* %G_SPAWN_DO_NOT_REAP_CHILD flag. You can then access the child * %G_SPAWN_DO_NOT_REAP_CHILD flag. You can then access the child
* process using the Win32 API, for example wait for its termination * process using the Win32 API, for example wait for its termination
* with the <function>WaitFor*()</function> functions, or examine its * with the WaitFor*() functions, or examine its exit code with
* exit code with GetExitCodeProcess(). You should close the handle * GetExitCodeProcess(). You should close the handle with CloseHandle()
* with CloseHandle() or g_spawn_close_pid() when you no longer need it. * or g_spawn_close_pid() when you no longer need it.
* *
* If non-%NULL, the @standard_input, @standard_output, @standard_error * If non-%NULL, the @standard_input, @standard_output, @standard_error
* locations will be filled with file descriptors for writing to the child's * locations will be filled with file descriptors for writing to the child's
* standard input or reading from its standard output or standard error. * standard input or reading from its standard output or standard error.
* The caller of g_spawn_async_with_pipes() must close these file descriptors * The caller of g_spawn_async_with_pipes() must close these file descriptors
* when they are no longer in use. If these parameters are %NULL, the corresponding * when they are no longer in use. If these parameters are %NULL, the
* pipe won't be created. * corresponding pipe won't be created.
* *
* If @standard_input is NULL, the child's standard input is attached to * If @standard_input is NULL, the child's standard input is attached to
* /dev/null unless %G_SPAWN_CHILD_INHERITS_STDIN is set. * /dev/null unless %G_SPAWN_CHILD_INHERITS_STDIN is set.
@ -615,11 +607,11 @@ g_spawn_sync (const gchar *working_directory,
* is set. * is set.
* *
* @error can be %NULL to ignore errors, or non-%NULL to report errors. * @error can be %NULL to ignore errors, or non-%NULL to report errors.
* If an error is set, the function returns %FALSE. Errors * If an error is set, the function returns %FALSE. Errors are reported
* are reported even if they occur in the child (for example if the * even if they occur in the child (for example if the executable in
* executable in <literal>argv[0]</literal> is not found). Typically * @argv[0] is not found). Typically the <literal>message</literal> field
* the <literal>message</literal> field of returned errors should be displayed * of returned errors should be displayed to users. Possible errors are
* to users. Possible errors are those from the #G_SPAWN_ERROR domain. * those from the #G_SPAWN_ERROR domain.
* *
* If an error occurs, @child_pid, @standard_input, @standard_output, * If an error occurs, @child_pid, @standard_input, @standard_output,
* and @standard_error will not be filled with valid values. * and @standard_error will not be filled with valid values.
@ -627,15 +619,13 @@ g_spawn_sync (const gchar *working_directory,
* If @child_pid is not %NULL and an error does not occur then the returned * If @child_pid is not %NULL and an error does not occur then the returned
* process reference must be closed using g_spawn_close_pid(). * process reference must be closed using g_spawn_close_pid().
* *
* <note><para>
* If you are writing a GTK+ application, and the program you * If you are writing a GTK+ application, and the program you
* are spawning is a graphical application, too, then you may * are spawning is a graphical application, too, then you may
* want to use gdk_spawn_on_screen_with_pipes() instead to ensure that * want to use gdk_spawn_on_screen_with_pipes() instead to ensure that
* the spawned program opens its windows on the right screen. * the spawned program opens its windows on the right screen.
* </para></note>
* *
* Return value: %TRUE on success, %FALSE if an error was set * Return value: %TRUE on success, %FALSE if an error was set
**/ */
gboolean gboolean
g_spawn_async_with_pipes (const gchar *working_directory, g_spawn_async_with_pipes (const gchar *working_directory,
gchar **argv, gchar **argv,
@ -759,7 +749,7 @@ g_spawn_command_line_sync (const gchar *command_line,
* *
* The same concerns on Windows apply as for g_spawn_command_line_sync(). * The same concerns on Windows apply as for g_spawn_command_line_sync().
* *
* Return value: %TRUE on success, %FALSE if error is set. * Return value: %TRUE on success, %FALSE if error is set
**/ **/
gboolean gboolean
g_spawn_command_line_async (const gchar *command_line, g_spawn_command_line_async (const gchar *command_line,
@ -798,24 +788,22 @@ g_spawn_command_line_async (const gchar *command_line,
* *
* The g_spawn_sync() and g_child_watch_add() family of APIs return an * The g_spawn_sync() and g_child_watch_add() family of APIs return an
* exit status for subprocesses encoded in a platform-specific way. * exit status for subprocesses encoded in a platform-specific way.
* On Unix, this is guaranteed to be in the same format * On Unix, this is guaranteed to be in the same format waitpid() returns,
* <literal>waitpid(2)</literal> returns, and on Windows it is * and on Windows it is guaranteed to be the result of GetExitCodeProcess().
* guaranteed to be the result of *
* <literal>GetExitCodeProcess()</literal>. Prior to the introduction * Prior to the introduction of this function in GLib 2.34, interpreting
* of this function in GLib 2.34, interpreting @exit_status required * @exit_status required use of platform-specific APIs, which is problematic
* use of platform-specific APIs, which is problematic for software * for software using GLib as a cross-platform layer.
* using GLib as a cross-platform layer.
* *
* Additionally, many programs simply want to determine whether or not * Additionally, many programs simply want to determine whether or not
* the child exited successfully, and either propagate a #GError or * the child exited successfully, and either propagate a #GError or
* print a message to standard error. In that common case, this * print a message to standard error. In that common case, this function
* function can be used. Note that the error message in @error will * can be used. Note that the error message in @error will contain
* contain human-readable information about the exit status. * human-readable information about the exit status.
* *
* The <literal>domain</literal> and <literal>code</literal> of @error * The @domain and @code of @error have special semantics in the case
* have special semantics in the case where the process has an "exit * where the process has an "exit code", as opposed to being killed by
* code", as opposed to being killed by a signal. On Unix, this * a signal. On Unix, this happens if WIFEXITED() would be true of
* happens if <literal>WIFEXITED</literal> would be true of
* @exit_status. On Windows, it is always the case. * @exit_status. On Windows, it is always the case.
* *
* The special semantics are that the actual exit code will be the * The special semantics are that the actual exit code will be the
@ -828,12 +816,13 @@ g_spawn_command_line_async (const gchar *command_line,
* *
* This function just offers convenience; you can of course also check * This function just offers convenience; you can of course also check
* the available platform via a macro such as %G_OS_UNIX, and use * the available platform via a macro such as %G_OS_UNIX, and use
* <literal>WIFEXITED()</literal> and <literal>WEXITSTATUS()</literal> * WIFEXITED() and WEXITSTATUS() on @exit_status directly. Do not attempt
* on @exit_status directly. Do not attempt to scan or parse the * to scan or parse the error message string; it may be translated and/or
* error message string; it may be translated and/or change in future * change in future versions of GLib.
* versions of GLib. *
* Returns: %TRUE if child exited successfully, %FALSE otherwise (and
* @error will be set)
* *
* Returns: %TRUE if child exited successfully, %FALSE otherwise (and @error will be set)
* Since: 2.34 * Since: 2.34
*/ */
gboolean gboolean

195
glib/gstrfuncs.c
View File

@ -398,15 +398,13 @@ g_memdup (gconstpointer mem,
* @n: the maximum number of bytes to copy from @str * @n: the maximum number of bytes to copy from @str
* *
* Duplicates the first @n bytes of a string, returning a newly-allocated * Duplicates the first @n bytes of a string, returning a newly-allocated
* buffer @n + 1 bytes long which will always be nul-terminated. * buffer @n + 1 bytes long which will always be nul-terminated. If @str
* If @str is less than @n bytes long the buffer is padded with nuls. * is less than @n bytes long the buffer is padded with nuls. If @str is
* If @str is %NULL it returns %NULL. * %NULL it returns %NULL. The returned value should be freed when no longer
* The returned value should be freed when no longer needed. * needed.
* *
* <note><para>
* To copy a number of characters from a UTF-8 encoded string, use * To copy a number of characters from a UTF-8 encoded string, use
* g_utf8_strncpy() instead. * g_utf8_strncpy() instead.
* </para></note>
* *
* Returns: a newly-allocated buffer containing the first @n bytes * Returns: a newly-allocated buffer containing the first @n bytes
* of @str, nul-terminated * of @str, nul-terminated
@ -1343,9 +1341,9 @@ g_strlcat (gchar *dest,
* it's often faster). It returns the size of the attempted result, * it's often faster). It returns the size of the attempted result,
* strlen (src), so if @retval >= @dest_size, truncation occurred. * strlen (src), so if @retval >= @dest_size, truncation occurred.
* *
* <note><para>Caveat: strlcpy() is supposedly more secure than * Caveat: strlcpy() is supposedly more secure than strcpy() or strncpy(),
* strcpy() or strncpy(), but if you really want to avoid screwups, * but if you really want to avoid screwups, g_strdup() is an even better
* g_strdup() is an even better idea.</para></note> * idea.
* *
* Returns: length of @src * Returns: length of @src
*/ */
@ -1397,20 +1395,19 @@ g_strlcpy (gchar *dest,
* guaranteeing nul-termination for @dest. The total size of @dest won't * guaranteeing nul-termination for @dest. The total size of @dest won't
* exceed @dest_size. * exceed @dest_size.
* *
* At most dest_size - 1 characters will be copied. * At most @dest_size - 1 characters will be copied. Unlike strncat(),
* Unlike strncat, dest_size is the full size of dest, not the space left over. * @dest_size is the full size of dest, not the space left over. This
* This function does NOT allocate memory. * function does not allocate memory. It always nul-terminates (unless
* This always NUL terminates (unless siz == 0 or there were no NUL characters * @dest_size == 0 or there were no nul characters in the @dest_size
* in the dest_size characters of dest to start with). * characters of dest to start with).
* *
* <note><para>Caveat: this is supposedly a more secure alternative to * Caveat: this is supposedly a more secure alternative to strcat() or
* strcat() or strncat(), but for real security g_strconcat() is harder * strncat(), but for real security g_strconcat() is harder to mess up.
* to mess up.</para></note>
* *
* Returns: size of attempted result, which is MIN (dest_size, strlen * Returns: size of attempted result, which is MIN (dest_size, strlen
* (original dest)) + strlen (src), so if retval >= dest_size, * (original dest)) + strlen (src), so if retval >= dest_size,
* truncation occurred. * truncation occurred.
**/ */
gsize gsize
g_strlcat (gchar *dest, g_strlcat (gchar *dest,
const gchar *src, const gchar *src,
@ -1450,17 +1447,16 @@ g_strlcat (gchar *dest,
/** /**
* g_ascii_strdown: * g_ascii_strdown:
* @str: a string. * @str: a string
* @len: length of @str in bytes, or -1 if @str is nul-terminated. * @len: length of @str in bytes, or -1 if @str is nul-terminated
* *
* Converts all upper case ASCII letters to lower case ASCII letters. * Converts all upper case ASCII letters to lower case ASCII letters.
* *
* Return value: a newly-allocated string, with all the upper case * Return value: a newly-allocated string, with all the upper case
* characters in @str converted to lower case, with * characters in @str converted to lower case, with semantics that
* semantics that exactly match g_ascii_tolower(). (Note * exactly match g_ascii_tolower(). (Note that this is unlike the
* that this is unlike the old g_strdown(), which modified * old g_strdown(), which modified the string in place.)
* the string in place.) */
**/
gchar* gchar*
g_ascii_strdown (const gchar *str, g_ascii_strdown (const gchar *str,
gssize len) gssize len)
@ -1481,17 +1477,16 @@ g_ascii_strdown (const gchar *str,
/** /**
* g_ascii_strup: * g_ascii_strup:
* @str: a string. * @str: a string
* @len: length of @str in bytes, or -1 if @str is nul-terminated. * @len: length of @str in bytes, or -1 if @str is nul-terminated
* *
* Converts all lower case ASCII letters to upper case ASCII letters. * Converts all lower case ASCII letters to upper case ASCII letters.
* *
* Return value: a newly allocated string, with all the lower case * Return value: a newly allocated string, with all the lower case
* characters in @str converted to upper case, with * characters in @str converted to upper case, with semantics that
* semantics that exactly match g_ascii_toupper(). (Note * exactly match g_ascii_toupper(). (Note that this is unlike the
* that this is unlike the old g_strup(), which modified * old g_strup(), which modified the string in place.)
* the string in place.) */
**/
gchar* gchar*
g_ascii_strup (const gchar *str, g_ascii_strup (const gchar *str,
gssize len) gssize len)
@ -1512,7 +1507,7 @@ g_ascii_strup (const gchar *str,
/** /**
* g_str_is_ascii: * g_str_is_ascii:
* @string: a string. * @string: a string
* *
* Determines if a string is pure ASCII. A string is pure ASCII if it * Determines if a string is pure ASCII. A string is pure ASCII if it
* contains no bytes with the high bit set. * contains no bytes with the high bit set.
@ -1520,7 +1515,7 @@ g_ascii_strup (const gchar *str,
* Returns: %TRUE if @string is ascii * Returns: %TRUE if @string is ascii
* *
* Since: 2.40 * Since: 2.40
**/ */
gboolean gboolean
g_str_is_ascii (const gchar *string) g_str_is_ascii (const gchar *string)
{ {
@ -1566,15 +1561,16 @@ g_strdown (gchar *string)
/** /**
* g_strup: * g_strup:
* @string: the string to convert. * @string: the string to convert
* *
* Converts a string to upper case. * Converts a string to upper case.
* *
* Return value: the string * Return value: the string
* *
* Deprecated:2.2: This function is totally broken for the reasons discussed * Deprecated:2.2: This function is totally broken for the reasons
* in the g_strncasecmp() docs - use g_ascii_strup() or g_utf8_strup() instead. * discussed in the g_strncasecmp() docs - use g_ascii_strup()
**/ * or g_utf8_strup() instead.
*/
gchar* gchar*
g_strup (gchar *string) g_strup (gchar *string)
{ {
@ -1637,7 +1633,7 @@ g_strreverse (gchar *string)
/** /**
* g_ascii_tolower: * g_ascii_tolower:
* @c: any character. * @c: any character
* *
* Convert a character to ASCII lower case. * Convert a character to ASCII lower case.
* *
@ -1646,13 +1642,12 @@ g_strreverse (gchar *string)
* all non-ASCII characters unchanged, even if they are lower case * all non-ASCII characters unchanged, even if they are lower case
* letters in a particular character set. Also unlike the standard * letters in a particular character set. Also unlike the standard
* library function, this takes and returns a char, not an int, so * library function, this takes and returns a char, not an int, so
* don't call it on <literal>EOF</literal> but no need to worry about casting to #guchar * don't call it on %EOF but no need to worry about casting to #guchar
* before passing a possibly non-ASCII character in. * before passing a possibly non-ASCII character in.
* *
* Return value: the result of converting @c to lower case. * Return value: the result of converting @c to lower case. If @c is
* If @c is not an ASCII upper case letter, * not an ASCII upper case letter, @c is returned unchanged.
* @c is returned unchanged. */
**/
gchar gchar
g_ascii_tolower (gchar c) g_ascii_tolower (gchar c)
{ {
@ -1661,7 +1656,7 @@ g_ascii_tolower (gchar c)
/** /**
* g_ascii_toupper: * g_ascii_toupper:
* @c: any character. * @c: any character
* *
* Convert a character to ASCII upper case. * Convert a character to ASCII upper case.
* *
@ -1670,13 +1665,12 @@ g_ascii_tolower (gchar c)
* all non-ASCII characters unchanged, even if they are upper case * all non-ASCII characters unchanged, even if they are upper case
* letters in a particular character set. Also unlike the standard * letters in a particular character set. Also unlike the standard
* library function, this takes and returns a char, not an int, so * library function, this takes and returns a char, not an int, so
* don't call it on <literal>EOF</literal> but no need to worry about casting to #guchar * don't call it on %EOF but no need to worry about casting to #guchar
* before passing a possibly non-ASCII character in. * before passing a possibly non-ASCII character in.
* *
* Return value: the result of converting @c to upper case. * Return value: the result of converting @c to upper case. If @c is not
* If @c is not an ASCII lower case letter, * an ASCII lower case letter, @c is returned unchanged.
* @c is returned unchanged. */
**/
gchar gchar
g_ascii_toupper (gchar c) g_ascii_toupper (gchar c)
{ {
@ -1685,16 +1679,15 @@ g_ascii_toupper (gchar c)
/** /**
* g_ascii_digit_value: * g_ascii_digit_value:
* @c: an ASCII character. * @c: an ASCII character
* *
* Determines the numeric value of a character as a decimal * Determines the numeric value of a character as a decimal digit.
* digit. Differs from g_unichar_digit_value() because it takes * Differs from g_unichar_digit_value() because it takes a char, so
* a char, so there's no worry about sign extension if characters * there's no worry about sign extension if characters are signed.
* are signed.
* *
* Return value: If @c is a decimal digit (according to * Return value: If @c is a decimal digit (according to g_ascii_isdigit()),
* g_ascii_isdigit()), its numeric value. Otherwise, -1. * its numeric value. Otherwise, -1.
**/ */
int int
g_ascii_digit_value (gchar c) g_ascii_digit_value (gchar c)
{ {
@ -1712,9 +1705,9 @@ g_ascii_digit_value (gchar c)
* a char, so there's no worry about sign extension if characters * a char, so there's no worry about sign extension if characters
* are signed. * are signed.
* *
* Return value: If @c is a hex digit (according to * Return value: If @c is a hex digit (according to g_ascii_isxdigit()),
* g_ascii_isxdigit()), its numeric value. Otherwise, -1. * its numeric value. Otherwise, -1.
**/ */
int int
g_ascii_xdigit_value (gchar c) g_ascii_xdigit_value (gchar c)
{ {
@ -1727,8 +1720,8 @@ g_ascii_xdigit_value (gchar c)
/** /**
* g_ascii_strcasecmp: * g_ascii_strcasecmp:
* @s1: string to compare with @s2. * @s1: string to compare with @s2
* @s2: string to compare with @s1. * @s2: string to compare with @s1
* *
* Compare two strings, ignoring the case of ASCII characters. * Compare two strings, ignoring the case of ASCII characters.
* *
@ -1748,7 +1741,7 @@ g_ascii_xdigit_value (gchar c)
* *
* Return value: 0 if the strings match, a negative value if @s1 &lt; @s2, * Return value: 0 if the strings match, a negative value if @s1 &lt; @s2,
* or a positive value if @s1 &gt; @s2. * or a positive value if @s1 &gt; @s2.
**/ */
gint gint
g_ascii_strcasecmp (const gchar *s1, g_ascii_strcasecmp (const gchar *s1,
const gchar *s2) const gchar *s2)
@ -1772,9 +1765,9 @@ g_ascii_strcasecmp (const gchar *s1,
/** /**
* g_ascii_strncasecmp: * g_ascii_strncasecmp:
* @s1: string to compare with @s2. * @s1: string to compare with @s2
* @s2: string to compare with @s1. * @s2: string to compare with @s1
* @n: number of characters to compare. * @n: number of characters to compare
* *
* Compare @s1 and @s2, ignoring the case of ASCII characters and any * Compare @s1 and @s2, ignoring the case of ASCII characters and any
* characters after the first @n in each string. * characters after the first @n in each string.
@ -1789,7 +1782,7 @@ g_ascii_strcasecmp (const gchar *s1,
* *
* Return value: 0 if the strings match, a negative value if @s1 &lt; @s2, * Return value: 0 if the strings match, a negative value if @s1 &lt; @s2,
* or a positive value if @s1 &gt; @s2. * or a positive value if @s1 &gt; @s2.
**/ */
gint gint
g_ascii_strncasecmp (const gchar *s1, g_ascii_strncasecmp (const gchar *s1,
const gchar *s2, const gchar *s2,
@ -1818,8 +1811,8 @@ g_ascii_strncasecmp (const gchar *s1,
/** /**
* g_strcasecmp: * g_strcasecmp:
* @s1: a string. * @s1: a string
* @s2: a string to compare with @s1. * @s2: a string to compare with @s1
* *
* A case-insensitive string comparison, corresponding to the standard * A case-insensitive string comparison, corresponding to the standard
* strcasecmp() function on platforms which support it. * strcasecmp() function on platforms which support it.
@ -1827,9 +1820,9 @@ g_ascii_strncasecmp (const gchar *s1,
* Return value: 0 if the strings match, a negative value if @s1 &lt; @s2, * Return value: 0 if the strings match, a negative value if @s1 &lt; @s2,
* or a positive value if @s1 &gt; @s2. * or a positive value if @s1 &gt; @s2.
* *
* Deprecated:2.2: See g_strncasecmp() for a discussion of why this function * Deprecated:2.2: See g_strncasecmp() for a discussion of why this
* is deprecated and how to replace it. * function is deprecated and how to replace it.
**/ */
gint gint
g_strcasecmp (const gchar *s1, g_strcasecmp (const gchar *s1,
const gchar *s2) const gchar *s2)
@ -1863,33 +1856,33 @@ g_strcasecmp (const gchar *s1,
/** /**
* g_strncasecmp: * g_strncasecmp:
* @s1: a string. * @s1: a string
* @s2: a string to compare with @s1. * @s2: a string to compare with @s1
* @n: the maximum number of characters to compare. * @n: the maximum number of characters to compare
* *
* A case-insensitive string comparison, corresponding to the standard * A case-insensitive string comparison, corresponding to the standard
* strncasecmp() function on platforms which support it. * strncasecmp() function on platforms which support it. It is similar
* It is similar to g_strcasecmp() except it only compares the first @n * to g_strcasecmp() except it only compares the first @n characters of
* characters of the strings. * the strings.
* *
* Return value: 0 if the strings match, a negative value if @s1 &lt; @s2, * Return value: 0 if the strings match, a negative value if @s1 &lt; @s2,
* or a positive value if @s1 &gt; @s2. * or a positive value if @s1 &gt; @s2.
* *
* Deprecated:2.2: The problem with g_strncasecmp() is that it does the * Deprecated:2.2: The problem with g_strncasecmp() is that it does
* comparison by calling toupper()/tolower(). These functions are * the comparison by calling toupper()/tolower(). These functions
* locale-specific and operate on single bytes. However, it is impossible * are locale-specific and operate on single bytes. However, it is
* to handle things correctly from an I18N standpoint by operating on * impossible to handle things correctly from an internationalization
* bytes, since characters may be multibyte. Thus g_strncasecmp() is * standpoint by operating on bytes, since characters may be multibyte.
* broken if your string is guaranteed to be ASCII, since it's * Thus g_strncasecmp() is broken if your string is guaranteed to be
* locale-sensitive, and it's broken if your string is localized, since * ASCII, since it is locale-sensitive, and it's broken if your string
* it doesn't work on many encodings at all, including UTF-8, EUC-JP, * is localized, since it doesn't work on many encodings at all,
* etc. * including UTF-8, EUC-JP, etc.
* *
* There are therefore two replacement techniques: g_ascii_strncasecmp(), * There are therefore two replacement techniques: g_ascii_strncasecmp(),
* which only works on ASCII and is not locale-sensitive, and * which only works on ASCII and is not locale-sensitive, and
* g_utf8_casefold() followed by strcmp() on the resulting strings, which is * g_utf8_casefold() followed by strcmp() on the resulting strings,
* good for case-insensitive sorting of UTF-8. * which is good for case-insensitive sorting of UTF-8.
**/ */
gint gint
g_strncasecmp (const gchar *s1, g_strncasecmp (const gchar *s1,
const gchar *s2, const gchar *s2,
@ -1926,8 +1919,8 @@ g_strncasecmp (const gchar *s1,
/** /**
* g_strdelimit: * g_strdelimit:
* @string: the string to convert * @string: the string to convert
* @delimiters: (allow-none): a string containing the current delimiters, or %NULL * @delimiters: (allow-none): a string containing the current delimiters,
* to use the standard delimiters defined in #G_STR_DELIMITERS * or %NULL to use the standard delimiters defined in #G_STR_DELIMITERS
* @new_delimiter: the new delimiter character * @new_delimiter: the new delimiter character
* *
* Converts any delimiter characters in @string to @new_delimiter. * Converts any delimiter characters in @string to @new_delimiter.
@ -1968,10 +1961,10 @@ g_strdelimit (gchar *string,
* @valid_chars: bytes permitted in @string * @valid_chars: bytes permitted in @string
* @substitutor: replacement character for disallowed bytes * @substitutor: replacement character for disallowed bytes
* *
* For each character in @string, if the character is not in * For each character in @string, if the character is not in @valid_chars,
* @valid_chars, replaces the character with @substitutor. * replaces the character with @substitutor. Modifies @string in place,
* Modifies @string in place, and return @string itself, not * and return @string itself, not a copy. The return value is to allow
* a copy. The return value is to allow nesting such as * nesting such as
* |[ * |[
* g_ascii_strup (g_strcanon (str, "abc", '?')) * g_ascii_strup (g_strcanon (str, "abc", '?'))
* ]| * ]|
@ -2424,7 +2417,7 @@ g_strsplit_set (const gchar *string,
* Frees a %NULL-terminated array of strings, and the array itself. * Frees a %NULL-terminated array of strings, and the array itself.
* If called on a %NULL value, g_strfreev() simply returns. * If called on a %NULL value, g_strfreev() simply returns.
**/ */
void void
g_strfreev (gchar **str_array) g_strfreev (gchar **str_array)
{ {
@ -2480,7 +2473,8 @@ g_strdupv (gchar **str_array)
/** /**
* g_strjoinv: * g_strjoinv:
* @separator: (allow-none): a string to insert between each of the strings, or %NULL * @separator: (allow-none): a string to insert between each of the
* strings, or %NULL
* @str_array: a %NULL-terminated array of strings to join * @str_array: a %NULL-terminated array of strings to join
* *
* Joins a number of strings together to form one long string, with the * Joins a number of strings together to form one long string, with the
@ -2532,7 +2526,8 @@ g_strjoinv (const gchar *separator,
/** /**
* g_strjoin: * g_strjoin:
* @separator: (allow-none): a string to insert between each of the strings, or %NULL * @separator: (allow-none): a string to insert between each of the
* strings, or %NULL
* @...: a %NULL-terminated list of strings to join * @...: a %NULL-terminated list of strings to join
* *
* Joins a number of strings together to form one long string, with the * Joins a number of strings together to form one long string, with the

7
glib/gthread-posix.c
View File

@ -195,10 +195,10 @@ g_mutex_clear (GMutex *mutex)
* current thread will block until @mutex is unlocked by the other * current thread will block until @mutex is unlocked by the other
* thread. * thread.
* *
* <note>#GMutex is neither guaranteed to be recursive nor to be * #GMutex is neither guaranteed to be recursive nor to be
* non-recursive. As such, calling g_mutex_lock() on a #GMutex that has * non-recursive. As such, calling g_mutex_lock() on a #GMutex that has
* already been locked by the same thread results in undefined behaviour * already been locked by the same thread results in undefined behaviour
* (including but not limited to deadlocks).</note> * (including but not limited to deadlocks).
*/ */
void void
g_mutex_lock (GMutex *mutex) g_mutex_lock (GMutex *mutex)
@ -236,11 +236,10 @@ g_mutex_unlock (GMutex *mutex)
* it immediately returns %FALSE. Otherwise it locks @mutex and returns * it immediately returns %FALSE. Otherwise it locks @mutex and returns
* %TRUE. * %TRUE.
* *
* <note>#GMutex is neither guaranteed to be recursive nor to be * #GMutex is neither guaranteed to be recursive nor to be
* non-recursive. As such, calling g_mutex_lock() on a #GMutex that has * non-recursive. As such, calling g_mutex_lock() on a #GMutex that has
* already been locked by the same thread results in undefined behaviour * already been locked by the same thread results in undefined behaviour
* (including but not limited to deadlocks or arbitrary return values). * (including but not limited to deadlocks or arbitrary return values).
* </note>
* Returns: %TRUE if @mutex could be locked * Returns: %TRUE if @mutex could be locked
*/ */

2
glib/gthread.c
View File

@ -907,12 +907,10 @@ g_thread_new_internal (const gchar *name,
* Calling <literal>g_thread_exit (retval)</literal> is equivalent to * Calling <literal>g_thread_exit (retval)</literal> is equivalent to
* returning @retval from the function @func, as given to g_thread_new(). * returning @retval from the function @func, as given to g_thread_new().
* *
* <note><para>
* You must only call g_thread_exit() from a thread that you created * You must only call g_thread_exit() from a thread that you created
* yourself with g_thread_new() or related APIs. You must not call * yourself with g_thread_new() or related APIs. You must not call
* this function from a thread created with another threading library * this function from a thread created with another threading library
* or or from within a #GThreadPool. * or or from within a #GThreadPool.
* </para></note>
*/ */
void void
g_thread_exit (gpointer retval) g_thread_exit (gpointer retval)

4
glib/gutils.c
View File

@ -795,7 +795,6 @@ g_get_real_name (void)
* If the path given in <envar>HOME</envar> is non-absolute, does not * If the path given in <envar>HOME</envar> is non-absolute, does not
* exist, or is not a directory, the result is undefined. * exist, or is not a directory, the result is undefined.
* *
* <note><para>
* Before version 2.36 this function would ignore the * Before version 2.36 this function would ignore the
* <envar>HOME</envar> environment variable, taking the value from the * <envar>HOME</envar> environment variable, taking the value from the
* <filename>passwd</filename> database instead. This was changed to * <filename>passwd</filename> database instead. This was changed to
@ -803,13 +802,12 @@ g_get_real_name (void)
* basedir specification) and to increase testability of programs * basedir specification) and to increase testability of programs
* based on GLib (by making it easier to run them from test * based on GLib (by making it easier to run them from test
* frameworks). * frameworks).
* </para><para> *
* If your program has a strong requirement for either the new or the * If your program has a strong requirement for either the new or the
* old behaviour (and if you don't wish to increase your GLib * old behaviour (and if you don't wish to increase your GLib
* dependency to ensure that the new behaviour is in effect) then you * dependency to ensure that the new behaviour is in effect) then you
* should either directly check the <envar>HOME</envar> environment * should either directly check the <envar>HOME</envar> environment
* variable yourself or unset it before calling any functions in GLib. * variable yourself or unset it before calling any functions in GLib.
* </para></note>
* *
* Returns: the current user's home directory * Returns: the current user's home directory
*/ */

24
gobject/gbinding.c
View File

@ -94,10 +94,10 @@
* either one of the #GObject instances it refers to are finalized, or when * either one of the #GObject instances it refers to are finalized, or when
* the #GBinding instance loses its last reference. * the #GBinding instance loses its last reference.
* *
* <note><para>Bindings for languages with garbage collection can use * Bindings for languages with garbage collection can use
* g_binding_unbind() to explicitly release a binding between the source * g_binding_unbind() to explicitly release a binding between the source
* and target properties, instead of relying on the last reference on the * and target properties, instead of relying on the last reference on the
* binding, source, and target instances to drop.</para></note> * binding, source, and target instances to drop.
* *
* #GBinding is available since GObject 2.26 * #GBinding is available since GObject 2.26
*/ */
@ -704,7 +704,7 @@ g_binding_init (GBinding *binding)
* g_binding_get_flags: * g_binding_get_flags:
* @binding: a #GBinding * @binding: a #GBinding
* *
* Retrieves the flags passed when constructing the #GBinding * Retrieves the flags passed when constructing the #GBinding.
* *
* Return value: the #GBindingFlags used by the #GBinding * Return value: the #GBindingFlags used by the #GBinding
* *
@ -722,7 +722,7 @@ g_binding_get_flags (GBinding *binding)
* g_binding_get_source: * g_binding_get_source:
* @binding: a #GBinding * @binding: a #GBinding
* *
* Retrieves the #GObject instance used as the source of the binding * Retrieves the #GObject instance used as the source of the binding.
* *
* Return value: (transfer none): the source #GObject * Return value: (transfer none): the source #GObject
* *
@ -740,7 +740,7 @@ g_binding_get_source (GBinding *binding)
* g_binding_get_target: * g_binding_get_target:
* @binding: a #GBinding * @binding: a #GBinding
* *
* Retrieves the #GObject instance used as the target of the binding * Retrieves the #GObject instance used as the target of the binding.
* *
* Return value: (transfer none): the target #GObject * Return value: (transfer none): the target #GObject
* *
@ -759,7 +759,7 @@ g_binding_get_target (GBinding *binding)
* @binding: a #GBinding * @binding: a #GBinding
* *
* Retrieves the name of the property of #GBinding:source used as the source * Retrieves the name of the property of #GBinding:source used as the source
* of the binding * of the binding.
* *
* Return value: the name of the source property * Return value: the name of the source property
* *
@ -778,7 +778,7 @@ g_binding_get_source_property (GBinding *binding)
* @binding: a #GBinding * @binding: a #GBinding
* *
* Retrieves the name of the property of #GBinding:target used as the target * Retrieves the name of the property of #GBinding:target used as the target
* of the binding * of the binding.
* *
* Return value: the name of the target property * Return value: the name of the target property
* *
@ -799,10 +799,10 @@ g_binding_get_target_property (GBinding *binding)
* Explicitly releases the binding between the source and the target * Explicitly releases the binding between the source and the target
* property expressed by @binding. * property expressed by @binding.
* *
* <note>This function will release the reference that is being held on * This function will release the reference that is being held on
* the @binding instance; if you want to hold on to the #GBinding instance * the @binding instance; if you want to hold on to the #GBinding instance
* after calling g_binding_unbind(), you will need to hold a reference * after calling g_binding_unbind(), you will need to hold a reference
* to it.</note> * to it.
* *
* Since: 2.38 * Since: 2.38
*/ */
@ -848,11 +848,11 @@ g_binding_unbind (GBinding *binding)
* *
* A #GObject can have multiple bindings. * A #GObject can have multiple bindings.
* *
* <note>The same @user_data parameter will be used for both @transform_to * The same @user_data parameter will be used for both @transform_to
* and @transform_from transformation functions; the @notify function will * and @transform_from transformation functions; the @notify function will
* be called once, when the binding is removed. If you need different data * be called once, when the binding is removed. If you need different data
* for each transformation function, please use * for each transformation function, please use
* g_object_bind_property_with_closures() instead.</note> * g_object_bind_property_with_closures() instead.
* *
* Return value: (transfer none): the #GBinding instance representing the * Return value: (transfer none): the #GBinding instance representing the
* binding between the two #GObject instances. The binding is released * binding between the two #GObject instances. The binding is released
@ -1181,7 +1181,7 @@ bind_with_closures_free_func (gpointer data)
* the binding. * the binding.
* *
* This function is the language bindings friendly version of * This function is the language bindings friendly version of
* g_object_bind_property_full(), using #GClosure<!-- -->s instead of * g_object_bind_property_full(), using #GClosures instead of
* function pointers. * function pointers.
* *
* Rename to: g_object_bind_property_full * Rename to: g_object_bind_property_full

2
gobject/gobject.c
View File

@ -815,7 +815,6 @@ g_object_interface_find_property (gpointer g_iface,
* a property implementation in a parent class or to provide * a property implementation in a parent class or to provide
* the implementation of a property from an interface. * the implementation of a property from an interface.
* *
* <note>
* Internally, overriding is implemented by creating a property of type * Internally, overriding is implemented by creating a property of type
* #GParamSpecOverride; generally operations that query the properties of * #GParamSpecOverride; generally operations that query the properties of
* the object class, such as g_object_class_find_property() or * the object class, such as g_object_class_find_property() or
@ -826,7 +825,6 @@ g_object_interface_find_property (gpointer g_iface,
* correct. For virtually all uses, this makes no difference. If you * correct. For virtually all uses, this makes no difference. If you
* need to get the overridden property, you can call * need to get the overridden property, you can call
* g_param_spec_get_redirect_target(). * g_param_spec_get_redirect_target().
* </note>
* *
* Since: 2.4 * Since: 2.4
*/ */