Enumerations

URI was ill-formed

a requested field was not found

a requested application did not register a bookmark

a requested URI was not found

document was ill formed

the text being parsed was in an unknown encoding

an error occurred while writing

requested file was not found

Catch-all for unknown values

Use the MD5 hashing algorithm

Use the SHA-1 hashing algorithm

Use the SHA-256 hashing algorithm

Use the SHA-512 hashing algorithm (Since: 2.36)

Use the SHA-384 hashing algorithm (Since: 2.51)

Catch-all for unknown values

Conversion between the requested character sets is not supported.

Invalid byte sequence in conversion input; or the character sequence could not be represented in the target character set.

Conversion failed for some reason.

Partial character sequence at end of input.

URI is invalid.

Pathname is not an absolute path.

No memory available. Since: 2.40

An embedded NUL character is present in conversion output where a NUL-terminated string is expected. Since: 2.56

Catch-all for unknown values

a day

a month

a year

Catch-all for unknown values

invalid value

January

February

March

April

May

June

July

August

September

October

November

December

Catch-all for unknown values

invalid value

Monday

Tuesday

Wednesday

Thursday

Friday

Saturday

Sunday

Catch-all for unknown values

unknown error

unexpected end of file

unterminated string constant

unterminated comment

non-digit character in a number

digit beyond radix in a number

non-decimal floating point number

malformed floating point number

Catch-all for unknown values

Operation not permitted; only the owner of the file (or other resource) or processes with special privileges can perform the operation.

File is a directory; you cannot open a directory for writing, or create or remove hard links to it.

Permission denied; the file permissions do not allow the attempted operation.

Filename too long.

No such file or directory. This is a "file doesn't exist" error for ordinary files that are referenced in contexts where they are expected to already exist.

A file that isn't a directory was specified when a directory is required.

No such device or address. The system tried to use the device represented by a file you specified, and it couldn't find the device. This can mean that the device file was installed incorrectly, or that the physical device is missing or not correctly attached to the computer.

The underlying file system of the specified file does not support memory mapping.

The directory containing the new link can't be modified because it's on a read-only file system.

Text file busy.

You passed in a pointer to bad memory. (GLib won't reliably return this, don't pass in pointers to bad memory.)

Too many levels of symbolic links were encountered in looking up a file name. This often indicates a cycle of symbolic links.

No space left on device; write operation on a file failed because the disk is full.

No memory available. The system cannot allocate more virtual memory because its capacity is full.

The current process has too many files open and can't open any more. Duplicate descriptors do count toward this limit.

There are too many distinct file openings in the entire system.

Bad file descriptor; for example, I/O on a descriptor that has been closed or reading from a descriptor open only for writing (or vice versa).

Invalid argument. This is used to indicate various kinds of problems with passing the wrong argument to a library function.

Broken pipe; there is no process reading from the other end of a pipe. Every library function that returns this error code also generates a 'SIGPIPE' signal; this signal terminates the program if not handled or blocked. Thus, your program will never actually see this code unless it has handled or blocked 'SIGPIPE'.

Resource temporarily unavailable; the call might work if you try again later.

Interrupted function call; an asynchronous signal occurred and prevented completion of the call. When this happens, you should try the call again.

Input/output error; usually used for physical read or write errors. i.e. the disk or other physical device hardware is returning errors.

Operation not permitted; only the owner of the file (or other resource) or processes with special privileges can perform the operation.

Function not implemented; this indicates that the system is missing some functionality.

Does not correspond to a UNIX error code; this is the standard "failed for unspecified reason" error code present in all GError error code enumerations. Returned if no specific code applies.

Catch-all for unknown values

File too large.

Invalid argument.

IO error.

File is a directory.

No space left on device.

No such device or address.

Value too large for defined datatype.

Broken pipe.

Some other error.

Catch-all for unknown values

no error

an EAGAIN error occurred

an EINVAL error occurred

another error occurred

Catch-all for unknown values

An error occurred.

Success.

End of file.

Resource temporarily unavailable.

Catch-all for unknown values

the text being parsed was in an unknown encoding

document was ill-formed

the file was not found

a requested key was not found

a requested group was not found

a value could not be parsed

Catch-all for unknown values

Log writer has handled the log entry.

Log writer could not handle the log entry.

Catch-all for unknown values

text being parsed was not valid UTF-8

document contained nothing, or only whitespace

document was ill-formed

error should be set by MarkupParser functions; element wasn't known

error should be set by MarkupParser functions; attribute wasn't known

error should be set by MarkupParser functions; content was invalid

error should be set by MarkupParser functions; a required attribute was missing

Catch-all for unknown values

standardize differences that do not affect the text content, such as the above-mentioned accent representation

another name for NormalizeModeDefault

like NormalizeModeDefault, but with composed forms rather than a maximally decomposed form

another name for NormalizeModeDefaultCompose

beyond NormalizeModeDefault also standardize the "compatibility" characters in Unicode, such as SUPERSCRIPT THREE to the standard forms (in this case DIGIT THREE). Formatting information may be lost but for most text operations such characters should be considered the same

another name for NormalizeModeAll

like NormalizeModeAll, but with composed forms rather than a maximally decomposed form

another name for NormalizeModeAllCompose

Catch-all for unknown values

String was not a valid number.

String was a number, but out of bounds.

Catch-all for unknown values

the function has not been called yet.

the function call is currently in progress.

the function has been called.

Catch-all for unknown values

No extra argument. This is useful for simple flags.

The option takes a UTF-8 string argument.

The option takes an integer argument.

The option provides a callback (of type OptionArgFunc) to parse the extra argument.

The option takes a filename as argument, which will be in the GLib filename encoding rather than UTF-8.

The option takes a string argument, multiple uses of the option are collected into an array of strings.

The option takes a filename as argument, multiple uses of the option are collected into an array of strings.

The option takes a double argument. The argument can be formatted either for the user's locale or for the "C" locale. Since 2.12

The option takes a 64-bit integer. Like OptionArgInt but for larger numbers. The number can be in decimal base, or in hexadecimal (when prefixed with 0x, for example, 0xffffffff). Since 2.12

Catch-all for unknown values

An option was not known to the parser. This error will only be reported, if the parser hasn't been instructed to ignore unknown options, see optionContextSetIgnoreUnknownOptions.

A value couldn't be parsed.

A OptionArgFunc callback failed.

Catch-all for unknown values

Compilation of the regular expression failed.

Optimization of the regular expression failed.

Replacement failed due to an ill-formed replacement string.

The match process failed.

Internal error of the regular expression engine. Since 2.16

"\" at end of pattern. Since 2.16

"\c" at end of pattern. Since 2.16

Unrecognized character follows "\". Since 2.16

Numbers out of order in "{}" quantifier. Since 2.16

Number too big in "{}" quantifier. Since 2.16

Missing terminating "]" for character class. Since 2.16

Invalid escape sequence in character class. Since 2.16

Range out of order in character class. Since 2.16

Nothing to repeat. Since 2.16

Unrecognized character after "(?", "(?<" or "(?P". Since 2.16

POSIX named classes are supported only within a class. Since 2.16

Missing terminating ")" or ")" without opening "(". Since 2.16

Reference to non-existent subpattern. Since 2.16

Missing terminating ")" after comment. Since 2.16

Regular expression too large. Since 2.16

Failed to get memory. Since 2.16

Lookbehind assertion is not fixed length. Since 2.16

Malformed number or name after "(?(". Since 2.16

Conditional group contains more than two branches. Since 2.16

Assertion expected after "(?(". Since 2.16

Unknown POSIX class name. Since 2.16

POSIX collating elements are not supported. Since 2.16

Character value in "\x{...}" sequence is too large. Since 2.16

Invalid condition "(?(0)". Since 2.16

\C not allowed in lookbehind assertion. Since 2.16

Recursive call could loop indefinitely. Since 2.16

Missing terminator in subpattern name. Since 2.16

Two named subpatterns have the same name. Since 2.16

Malformed "\P" or "\p" sequence. Since 2.16

Unknown property name after "\P" or "\p". Since 2.16

Subpattern name is too long (maximum 32 characters). Since 2.16

Too many named subpatterns (maximum 10,000). Since 2.16

Octal value is greater than "\377". Since 2.16

"DEFINE" group contains more than one branch. Since 2.16

Repeating a "DEFINE" group is not allowed. This error is never raised. Since: 2.16 Deprecated: 2.34

Inconsistent newline options. Since 2.16

"\g" is not followed by a braced, angle-bracketed, or quoted name or number, or by a plain number. Since: 2.16

relative reference must not be zero. Since: 2.34

the backtracing control verb used does not allow an argument. Since: 2.34

unknown backtracing control verb. Since: 2.34

number is too big in escape sequence. Since: 2.34

Missing subpattern name. Since: 2.34

Missing digit. Since 2.34

In JavaScript compatibility mode, "[" is an invalid data character. Since: 2.34

different names for subpatterns of the same number are not allowed. Since: 2.34

the backtracing control verb requires an argument. Since: 2.34

"\c" must be followed by an ASCII character. Since: 2.34

"\k" is not followed by a braced, angle-bracketed, or quoted name. Since: 2.34

"\N" is not supported in a class. Since: 2.34

too many forward references. Since: 2.34

the name is too long in "(*MARK)", "(*PRUNE)", "(*SKIP)", or "(*THEN)". Since: 2.34

the character value in the \u sequence is too large. Since: 2.34

Catch-all for unknown values

the current position in the file.

the start of the file.

the end of the file.

Catch-all for unknown values

Mismatched or otherwise mangled quoting.

String to be parsed was empty.

Some other error.

Catch-all for unknown values

No description available in the introspection data.

No description available in the introspection data.

No description available in the introspection data.

No description available in the introspection data.

No description available in the introspection data.

No description available in the introspection data.

Catch-all for unknown values

Fork failed due to lack of memory.

Read or select on pipes failed.

Changing to working directory failed.

execv() returned EACCES

execv() returned EPERM

execv() returned E2BIG

deprecated alias for SpawnErrorTooBig (deprecated since GLib 2.32)

execv() returned ENOEXEC

execv() returned ENAMETOOLONG

execv() returned ENOENT

execv() returned ENOMEM

execv() returned ENOTDIR

execv() returned ELOOP

execv() returned ETXTBUSY

execv() returned EIO

execv() returned ENFILE

execv() returned EMFILE

execv() returned EINVAL

execv() returned EISDIR

execv() returned ELIBBAD

Some other fatal failure, error->message should explain.

Catch-all for unknown values