atk 0.90.4-x86-mingw32 → 0.90.5-x86-mingw32

data/vendor/local/include/glib-2.0/glib/gmarkup.h

@@ -113,7 +113,7 @@ gboolean             g_markup_parse_context_parse (GMarkupParseContext *context,
                                                    gssize               text_len,  
                                                    GError             **error);
 void                 g_markup_parse_context_push  (GMarkupParseContext *context,
-                                                   GMarkupParser       *parser,
+                                                   const GMarkupParser *parser,
                                                    gpointer             user_data);
 gpointer             g_markup_parse_context_pop   (GMarkupParseContext *context);
                                                    

data/vendor/local/include/glib-2.0/glib/gmem.h

@@ -36,10 +36,29 @@
 
 G_BEGIN_DECLS
 
+/**
+ * GMemVTable:
+ * @malloc: function to use for allocating memory.
+ * @realloc: function to use for reallocating memory.
+ * @free: function to use to free memory.
+ * @calloc: function to use for allocating zero-filled memory.
+ * @try_malloc: function to use for allocating memory without a default error handler.
+ * @try_realloc: function to use for reallocating memory without a default error handler.
+ * 
+ * A set of functions used to perform memory allocation. The same #GMemVTable must
+ * be used for all allocations in the same program; a call to g_mem_set_vtable(),
+ * if it exists, should be prior to any use of GLib.
+ */
 typedef struct _GMemVTable GMemVTable;
 
 
 #if GLIB_SIZEOF_VOID_P > GLIB_SIZEOF_LONG
+/**
+ * G_MEM_ALIGN:
+ * 
+ * Indicates the number of bytes to which memory will be aligned on the
+ * current platform.
+ */
 #  define G_MEM_ALIGN	GLIB_SIZEOF_VOID_P
 #else	/* GLIB_SIZEOF_VOID_P <= GLIB_SIZEOF_LONG */
 #  define G_MEM_ALIGN	GLIB_SIZEOF_LONG
@@ -85,7 +104,7 @@ gpointer g_try_realloc_n  (gpointer	 mem,
 	  gsize __n = (gsize) (n_structs);			\
 	  gsize __s = sizeof (struct_type);			\
 	  gpointer __p;						\
-	  if (__s == 1)			\
+	  if (__s == 1)						\
 	    __p = g_##func (__n);				\
 	  else if (__builtin_constant_p (__n) &&		\
 	           (__s == 0 || __n <= G_MAXSIZE / __s))	\
@@ -120,11 +139,98 @@ gpointer g_try_realloc_n  (gpointer	 mem,
 
 #endif
 
+/**
+ * g_new:
+ * @struct_type: the type of the elements to allocate
+ * @n_structs: the number of elements to allocate
+ * 
+ * Allocates @n_structs elements of type @struct_type.
+ * The returned pointer is cast to a pointer to the given type.
+ * If @n_structs is 0 it returns %NULL.
+ * Care is taken to avoid overflow when calculating the size of the allocated block.
+ * 
+ * Since the returned pointer is already casted to the right type,
+ * it is normally unnecessary to cast it explicitly, and doing
+ * so might hide memory allocation errors.
+ * 
+ * Returns: a pointer to the allocated memory, cast to a pointer to @struct_type
+ */
 #define g_new(struct_type, n_structs)			_G_NEW (struct_type, n_structs, malloc)
+/**
+ * g_new0:
+ * @struct_type: the type of the elements to allocate.
+ * @n_structs: the number of elements to allocate.
+ * 
+ * Allocates @n_structs elements of type @struct_type, initialized to 0's.
+ * The returned pointer is cast to a pointer to the given type.
+ * If @n_structs is 0 it returns %NULL.
+ * Care is taken to avoid overflow when calculating the size of the allocated block.
+ * 
+ * Since the returned pointer is already casted to the right type,
+ * it is normally unnecessary to cast it explicitly, and doing
+ * so might hide memory allocation errors.
+ * 
+ * Returns: a pointer to the allocated memory, cast to a pointer to @struct_type.
+ */
 #define g_new0(struct_type, n_structs)			_G_NEW (struct_type, n_structs, malloc0)
+/**
+ * g_renew:
+ * @struct_type: the type of the elements to allocate
+ * @mem: the currently allocated memory
+ * @n_structs: the number of elements to allocate
+ * 
+ * Reallocates the memory pointed to by @mem, so that it now has space for
+ * @n_structs elements of type @struct_type. It returns the new address of
+ * the memory, which may have been moved.
+ * Care is taken to avoid overflow when calculating the size of the allocated block.
+ * 
+ * Returns: a pointer to the new allocated memory, cast to a pointer to @struct_type
+ */
 #define g_renew(struct_type, mem, n_structs)		_G_RENEW (struct_type, mem, n_structs, realloc)
+/**
+ * g_try_new:
+ * @struct_type: the type of the elements to allocate
+ * @n_structs: the number of elements to allocate
+ * 
+ * Attempts to allocate @n_structs elements of type @struct_type, and returns
+ * %NULL on failure. Contrast with g_new(), which aborts the program on failure.
+ * The returned pointer is cast to a pointer to the given type.
+ * The function returns %NULL when @n_structs is 0 of if an overflow occurs.
+ * 
+ * Since: 2.8
+ * Returns: a pointer to the allocated memory, cast to a pointer to @struct_type
+ */
 #define g_try_new(struct_type, n_structs)		_G_NEW (struct_type, n_structs, try_malloc)
+/**
+ * g_try_new0:
+ * @struct_type: the type of the elements to allocate
+ * @n_structs: the number of elements to allocate
+ * 
+ * Attempts to allocate @n_structs elements of type @struct_type, initialized
+ * to 0's, and returns %NULL on failure. Contrast with g_new0(), which aborts
+ * the program on failure.
+ * The returned pointer is cast to a pointer to the given type.
+ * The function returns %NULL when @n_structs is 0 of if an overflow occurs.
+ * 
+ * Since: 2.8
+ * Returns: a pointer to the allocated memory, cast to a pointer to @struct_type
+ */
 #define g_try_new0(struct_type, n_structs)		_G_NEW (struct_type, n_structs, try_malloc0)
+/**
+ * g_try_renew:
+ * @struct_type: the type of the elements to allocate
+ * @mem: the currently allocated memory
+ * @n_structs: the number of elements to allocate
+ * 
+ * Attempts to reallocate the memory pointed to by @mem, so that it now has
+ * space for @n_structs elements of type @struct_type, and returns %NULL on
+ * failure. Contrast with g_renew(), which aborts the program on failure.
+ * It returns the new address of the memory, which may have been moved.
+ * The function returns %NULL if an overflow occurs.
+ * 
+ * Since: 2.8
+ * Returns: a pointer to the new allocated memory, cast to a pointer to @struct_type
+ */
 #define g_try_renew(struct_type, mem, n_structs)	_G_RENEW (struct_type, mem, n_structs, try_realloc)
 
 

data/vendor/local/include/glib-2.0/glib/gnode.h

@@ -250,7 +250,8 @@ GNode*	 g_node_last_sibling	 (GNode		  *node);
  *
  * Gets the previous sibling of a #GNode.
  *
- * Returns: the previous sibling of @node, or %NULL if @node is %NULL
+ * Returns: the previous sibling of @node, or %NULL if @node is the first
+ *     node or %NULL
  */
 #define	 g_node_prev_sibling(node)	((node) ? \
 					 ((GNode*) (node))->prev : NULL)
@@ -261,7 +262,8 @@ GNode*	 g_node_last_sibling	 (GNode		  *node);
  *
  * Gets the next sibling of a #GNode.
  *
- * Returns: the next sibling of @node, or %NULL if @node is %NULL
+ * Returns: the next sibling of @node, or %NULL if @node is the last node
+ *     or %NULL
  */
 #define	 g_node_next_sibling(node)	((node) ? \
 					 ((GNode*) (node))->next : NULL)

data/vendor/local/include/glib-2.0/glib/gpoll.h

@@ -59,10 +59,34 @@ G_BEGIN_DECLS
  * Windows.
  */
 typedef struct _GPollFD GPollFD;
-typedef gint	(*GPollFunc)	(GPollFD *ufds,
-				 guint	  nfsd,
-				 gint     timeout_);
 
+/**
+ * GPollFunc:
+ * @ufds: an array of #GPollFD elements
+ * @nfsd: the number of elements in @ufds
+ * @timeout_: the maximum time to wait for an event of the file descriptors.
+ *     A negative value indicates an infinite timeout.
+ *
+ * Specifies the type of function passed to g_main_context_set_poll_func().
+ * The semantics of the function should match those of the poll() system call.
+ *
+ * Returns: the number of #GPollFD elements which have events or errors
+ *     reported, or -1 if an error occurred.
+ */
+typedef gint    (*GPollFunc)    (GPollFD *ufds,
+                                 guint    nfsd,
+                                 gint     timeout_);
+
+/**
+ * GPollFD:
+ * @fd: the file descriptor to poll (or a <type>HANDLE</type> on Win32)
+ * @events: a bitwise combination from #GIOCondition, specifying which
+ *     events should be polled for. Typically for reading from a file
+ *     descriptor you would use %G_IO_IN | %G_IO_HUP | %G_IO_ERR, and
+ *     for writing you would use %G_IO_OUT | %G_IO_ERR.
+ * @revents: a bitwise combination of flags from #GIOCondition, returned
+ *     from the poll() function to indicate which events occurred.
+ */
 struct _GPollFD
 {
 #if defined (G_OS_WIN32) && GLIB_SIZEOF_VOID_P == 8

data/vendor/local/include/glib-2.0/glib/gregex.h

@@ -31,6 +31,89 @@
 
 G_BEGIN_DECLS
 
+/**
+ * GRegexError:
+ * @G_REGEX_ERROR_COMPILE: Compilation of the regular expression failed.
+ * @G_REGEX_ERROR_OPTIMIZE: Optimization of the regular expression failed.
+ * @G_REGEX_ERROR_REPLACE: Replacement failed due to an ill-formed replacement
+ *     string.
+ * @G_REGEX_ERROR_MATCH: The match process failed.
+ * @G_REGEX_ERROR_INTERNAL: Internal error of the regular expression engine.
+ *     Since 2.16
+ * @G_REGEX_ERROR_STRAY_BACKSLASH: "\\" at end of pattern. Since 2.16
+ * @G_REGEX_ERROR_MISSING_CONTROL_CHAR: "\\c" at end of pattern. Since 2.16
+ * @G_REGEX_ERROR_UNRECOGNIZED_ESCAPE: Unrecognized character follows "\\".
+ *     Since 2.16
+ * @G_REGEX_ERROR_QUANTIFIERS_OUT_OF_ORDER: Numbers out of order in "{}"
+ *     quantifier. Since 2.16
+ * @G_REGEX_ERROR_QUANTIFIER_TOO_BIG: Number too big in "{}" quantifier.
+ *     Since 2.16
+ * @G_REGEX_ERROR_UNTERMINATED_CHARACTER_CLASS: Missing terminating "]" for
+ *     character class. Since 2.16
+ * @G_REGEX_ERROR_INVALID_ESCAPE_IN_CHARACTER_CLASS: Invalid escape sequence
+ *     in character class. Since 2.16
+ * @G_REGEX_ERROR_RANGE_OUT_OF_ORDER: Range out of order in character class.
+ *     Since 2.16
+ * @G_REGEX_ERROR_NOTHING_TO_REPEAT: Nothing to repeat. Since 2.16
+ * @G_REGEX_ERROR_UNRECOGNIZED_CHARACTER: Unrecognized character after "(?",
+ *     "(?<" or "(?P". Since 2.16
+ * @G_REGEX_ERROR_POSIX_NAMED_CLASS_OUTSIDE_CLASS: POSIX named classes are
+ *     supported only within a class. Since 2.16
+ * @G_REGEX_ERROR_UNMATCHED_PARENTHESIS: Missing terminating ")" or ")"
+ *     without opening "(". Since 2.16
+ * @G_REGEX_ERROR_INEXISTENT_SUBPATTERN_REFERENCE: Reference to non-existent
+ *     subpattern. Since 2.16
+ * @G_REGEX_ERROR_UNTERMINATED_COMMENT: Missing terminating ")" after comment.
+ *     Since 2.16
+ * @G_REGEX_ERROR_EXPRESSION_TOO_LARGE: Regular expression too large.
+ *     Since 2.16
+ * @G_REGEX_ERROR_MEMORY_ERROR: Failed to get memory. Since 2.16
+ * @G_REGEX_ERROR_VARIABLE_LENGTH_LOOKBEHIND: Lookbehind assertion is not
+ *     fixed length. Since 2.16
+ * @G_REGEX_ERROR_MALFORMED_CONDITION: Malformed number or name after "(?(".
+ *     Since 2.16
+ * @G_REGEX_ERROR_TOO_MANY_CONDITIONAL_BRANCHES: Conditional group contains
+ *     more than two branches. Since 2.16
+ * @G_REGEX_ERROR_ASSERTION_EXPECTED: Assertion expected after "(?(".
+ *     Since 2.16
+ * @G_REGEX_ERROR_UNKNOWN_POSIX_CLASS_NAME: Unknown POSIX class name.
+ *     Since 2.16
+ * @G_REGEX_ERROR_POSIX_COLLATING_ELEMENTS_NOT_SUPPORTED: POSIX collating
+ *     elements are not supported. Since 2.16
+ * @G_REGEX_ERROR_HEX_CODE_TOO_LARGE: Character value in "\\x{...}" sequence
+ *     is too large. Since 2.16
+ * @G_REGEX_ERROR_INVALID_CONDITION: Invalid condition "(?(0)". Since 2.16
+ * @G_REGEX_ERROR_SINGLE_BYTE_MATCH_IN_LOOKBEHIND: \\C not allowed in
+ *     lookbehind assertion. Since 2.16
+ * @G_REGEX_ERROR_INFINITE_LOOP: Recursive call could loop indefinitely.
+ *     Since 2.16
+ * @G_REGEX_ERROR_MISSING_SUBPATTERN_NAME_TERMINATOR: Missing terminator
+ *     in subpattern name. Since 2.16
+ * @G_REGEX_ERROR_DUPLICATE_SUBPATTERN_NAME: Two named subpatterns have
+ *     the same name. Since 2.16
+ * @G_REGEX_ERROR_MALFORMED_PROPERTY: Malformed "\\P" or "\\p" sequence.
+ *     Since 2.16
+ * @G_REGEX_ERROR_UNKNOWN_PROPERTY: Unknown property name after "\\P" or
+ *     "\\p". Since 2.16
+ * @G_REGEX_ERROR_SUBPATTERN_NAME_TOO_LONG: Subpattern name is too long
+ *     (maximum 32 characters). Since 2.16
+ * @G_REGEX_ERROR_TOO_MANY_SUBPATTERNS: Too many named subpatterns (maximum
+ *     10,000). Since 2.16
+ * @G_REGEX_ERROR_INVALID_OCTAL_VALUE: Octal value is greater than "\\377".
+ *     Since 2.16
+ * @G_REGEX_ERROR_TOO_MANY_BRANCHES_IN_DEFINE: "DEFINE" group contains more
+ *     than one branch. Since 2.16
+ * @G_REGEX_ERROR_DEFINE_REPETION: Repeating a "DEFINE" group is not allowed.
+ *     Since 2.16
+ * @G_REGEX_ERROR_INCONSISTENT_NEWLINE_OPTIONS: Inconsistent newline options.
+ *     Since 2.16
+ * @G_REGEX_ERROR_MISSING_BACK_REFERENCE: "\\g" is not followed by a braced
+ *     name or an optionally braced non-zero number. Since 2.16
+ *
+ * Error codes returned by regular expressions functions.
+ *
+ * Since: 2.14
+ */
 typedef enum
 {
   G_REGEX_ERROR_COMPILE,
@@ -79,10 +162,82 @@ typedef enum
   G_REGEX_ERROR_MISSING_BACK_REFERENCE = 157
 } GRegexError;
 
+/**
+ * G_REGEX_ERROR:
+ *
+ * Error domain for regular expressions. Errors in this domain will be
+ * from the #GRegexError enumeration. See #GError for information on
+ * error domains.
+ *
+ * Since: 2.14
+ */
 #define G_REGEX_ERROR g_regex_error_quark ()
 
 GQuark g_regex_error_quark (void);
 
+/**
+ * GRegexCompileFlags:
+ * @G_REGEX_CASELESS: Letters in the pattern match both upper- and
+ *     lowercase letters. This option can be changed within a pattern
+ *     by a "(?i)" option setting.
+ * @G_REGEX_MULTILINE: By default, GRegex treats the strings as consisting
+ *     of a single line of characters (even if it actually contains
+ *     newlines). The "start of line" metacharacter ("^") matches only
+ *     at the start of the string, while the "end of line" metacharacter
+ *     ("$") matches only at the end of the string, or before a terminating
+ *     newline (unless #G_REGEX_DOLLAR_ENDONLY is set). When
+ *     #G_REGEX_MULTILINE is set, the "start of line" and "end of line"
+ *     constructs match immediately following or immediately before any
+ *     newline in the string, respectively, as well as at the very start
+ *     and end. This can be changed within a pattern by a "(?m)" option
+ *     setting.
+ * @G_REGEX_DOTALL: A dot metacharater (".") in the pattern matches all
+ *     characters, including newlines. Without it, newlines are excluded.
+ *     This option can be changed within a pattern by a ("?s") option setting.
+ * @G_REGEX_EXTENDED: Whitespace data characters in the pattern are
+ *     totally ignored except when escaped or inside a character class.
+ *     Whitespace does not include the VT character (code 11). In addition,
+ *     characters between an unescaped "#" outside a character class and
+ *     the next newline character, inclusive, are also ignored. This can
+ *     be changed within a pattern by a "(?x)" option setting.
+ * @G_REGEX_ANCHORED: The pattern is forced to be "anchored", that is,
+ *     it is constrained to match only at the first matching point in the
+ *     string that is being searched. This effect can also be achieved by
+ *     appropriate constructs in the pattern itself such as the "^"
+ *     metacharater.
+ * @G_REGEX_DOLLAR_ENDONLY: A dollar metacharacter ("$") in the pattern
+ *     matches only at the end of the string. Without this option, a
+ *     dollar also matches immediately before the final character if
+ *     it is a newline (but not before any other newlines). This option
+ *     is ignored if #G_REGEX_MULTILINE is set.
+ * @G_REGEX_UNGREEDY: Inverts the "greediness" of the quantifiers so that
+ *     they are not greedy by default, but become greedy if followed by "?".
+ *     It can also be set by a "(?U)" option setting within the pattern.
+ * @G_REGEX_RAW: Usually strings must be valid UTF-8 strings, using this
+ *     flag they are considered as a raw sequence of bytes.
+ *     @G_REGEX_NO_AUTO_CAPTURE: Disables the use of numbered capturing
+ *     parentheses in the pattern. Any opening parenthesis that is not
+ *     followed by "?" behaves as if it were followed by "?:" but named
+ *     parentheses can still be used for capturing (and they acquire numbers
+ *     in the usual way).
+ * @G_REGEX_OPTIMIZE: Optimize the regular expression. If the pattern will
+ *     be used many times, then it may be worth the effort to optimize it
+ *     to improve the speed of matches.
+ * @G_REGEX_DUPNAMES: Names used to identify capturing subpatterns need not
+ *     be unique. This can be helpful for certain types of pattern when it
+ *     is known that only one instance of the named subpattern can ever be
+ *     matched.
+ * @G_REGEX_NEWLINE_CR: Usually any newline character is recognized, if this
+ *     option is set, the only recognized newline character is '\r'.
+ * @G_REGEX_NEWLINE_LF: Usually any newline character is recognized, if this
+ *     option is set, the only recognized newline character is '\n'.
+ * @G_REGEX_NEWLINE_CRLF: Usually any newline character is recognized, if this
+ *     option is set, the only recognized newline character sequence is '\r\n'.
+ *
+ * Flags specifying compile-time options.
+ *
+ * Since: 2.14
+ */
 /* Remember to update G_REGEX_COMPILE_MASK in gregex.c after
  * adding a new flag. */
 typedef enum
@@ -103,6 +258,49 @@ typedef enum
   G_REGEX_NEWLINE_CRLF      = G_REGEX_NEWLINE_CR | G_REGEX_NEWLINE_LF
 } GRegexCompileFlags;
 
+/**
+ * GRegexMatchFlags:
+ * @G_REGEX_MATCH_ANCHORED: The pattern is forced to be "anchored", that is,
+ *     it is constrained to match only at the first matching point in the
+ *     string that is being searched. This effect can also be achieved by
+ *     appropriate constructs in the pattern itself such as the "^"
+ *     metacharater.
+ * @G_REGEX_MATCH_NOTBOL: Specifies that first character of the string is
+ *     not the beginning of a line, so the circumflex metacharacter should
+ *     not match before it. Setting this without #G_REGEX_MULTILINE (at
+ *     compile time) causes circumflex never to match. This option affects
+ *     only the behaviour of the circumflex metacharacter, it does not
+ *     affect "\A".
+ * @G_REGEX_MATCH_NOTEOL: Specifies that the end of the subject string is
+ *     not the end of a line, so the dollar metacharacter should not match
+ *     it nor (except in multiline mode) a newline immediately before it.
+ *     Setting this without #G_REGEX_MULTILINE (at compile time) causes
+ *     dollar never to match. This option affects only the behaviour of
+ *     the dollar metacharacter, it does not affect "\Z" or "\z".
+ * @G_REGEX_MATCH_NOTEMPTY: An empty string is not considered to be a valid
+ *     match if this option is set. If there are alternatives in the pattern,
+ *     they are tried. If all the alternatives match the empty string, the
+ *     entire match fails. For example, if the pattern "a?b?" is applied to
+ *     a string not beginning with "a" or "b", it matches the empty string
+ *     at the start of the string. With this flag set, this match is not
+ *     valid, so GRegex searches further into the string for occurrences
+ *     of "a" or "b".
+ * @G_REGEX_MATCH_PARTIAL: Turns on the partial matching feature, for more
+ *     documentation on partial matching see g_match_info_is_partial_match().
+ * @G_REGEX_MATCH_NEWLINE_CR: Overrides the newline definition set when
+ *     creating a new #GRegex, setting the '\r' character as line terminator.
+ * @G_REGEX_MATCH_NEWLINE_LF: Overrides the newline definition set when
+ *     creating a new #GRegex, setting the '\n' character as line terminator.
+ * @G_REGEX_MATCH_NEWLINE_CRLF: Overrides the newline definition set when
+ *     creating a new #GRegex, setting the '\r\n' characters as line terminator.
+ * @G_REGEX_MATCH_NEWLINE_ANY: Overrides the newline definition set when
+ *     creating a new #GRegex, any newline character or character sequence
+ *     is recognized.
+ *
+ * Flags specifying match-time options.
+ *
+ * Since: 2.14
+ */
 /* Remember to update G_REGEX_MATCH_MASK in gregex.c after
  * adding a new flag. */
 typedef enum
@@ -118,9 +316,36 @@ typedef enum
   G_REGEX_MATCH_NEWLINE_ANY   = 1 << 22
 } GRegexMatchFlags;
 
+/**
+ * GRegex:
+ *
+ * A GRegex is the "compiled" form of a regular expression pattern. This
+ * structure is opaque and its fields cannot be accessed directly.
+ *
+ * Since: 2.14
+ */
 typedef struct _GRegex		GRegex;
+
+
 typedef struct _GMatchInfo	GMatchInfo;
 
+/**
+ * GRegexEvalCallback:
+ * @match_info: the #GMatchInfo generated by the match.
+ *     Use g_match_info_get_regex() and g_match_info_get_string() if you
+ *     need the #GRegex or the matched string.
+ * @result: a #GString containing the new string
+ * @user_data: user data passed to g_regex_replace_eval()
+ *
+ * Specifies the type of the function passed to g_regex_replace_eval().
+ * It is called for each occurance of the pattern in the string passed
+ * to g_regex_replace_eval(), and it should append the replacement to
+ * @result.
+ *
+ * Returns: %FALSE to continue the replacement process, %TRUE to stop it
+ *
+ * Since: 2.14
+ */
 typedef gboolean (*GRegexEvalCallback)		(const GMatchInfo *match_info,
 						 GString          *result,
 						 gpointer          user_data);
@@ -140,6 +365,9 @@ gint		  g_regex_get_string_number	(const GRegex        *regex,
 gchar		 *g_regex_escape_string		(const gchar         *string,
 						 gint                 length);
 
+GRegexCompileFlags g_regex_get_compile_flags    (const GRegex        *regex);
+GRegexMatchFlags   g_regex_get_match_flags      (const GRegex        *regex);
+
 /* Matching. */
 gboolean	  g_regex_match_simple		(const gchar         *pattern,
 						 const gchar         *string,