diff options
Diffstat (limited to '')
| -rw-r--r-- | doc/libconfig.info | 2182 |
1 files changed, 2182 insertions, 0 deletions
diff --git a/doc/libconfig.info b/doc/libconfig.info new file mode 100644 index 0000000..51dbfc6 --- /dev/null +++ b/doc/libconfig.info @@ -0,0 +1,2182 @@ +This is libconfig.info, produced by makeinfo version 4.11 from +libconfig.texi. + +INFO-DIR-SECTION Software libraries +START-INFO-DIR-ENTRY +* libconfig: (libconfig). A Library For Processing Structured Configuration Files +END-INFO-DIR-ENTRY + + +File: libconfig.info, Node: Top, Next: Introduction, Up: (dir) + +libconfig +********* + +* Menu: + +* Introduction:: +* Configuration Files:: +* The C API:: +* The C++ API:: +* Configuration File Grammar:: +* License:: +* Function Index:: +* Type Index:: +* Concept Index:: + + +File: libconfig.info, Node: Introduction, Next: Configuration Files, Prev: Top, Up: Top + +* Menu: + +* Why Another Configuration File Library?:: +* Using the Library from a C Program:: +* Using the Library from a C++ Program:: +* Multithreading Issues:: +* Internationalization Issues:: +* Compiling Using pkg-config:: + +1 Introduction +************** + +Libconfig is a library for reading, manipulating, and writing +structured configuration files. The library features a fully reentrant +parser and includes bindings for both the C and C++ programming +languages. + + The library runs on modern POSIX-compilant systems, such as Linux, +Solaris, and Mac OS X (Darwin), as well as on Microsoft Windows 2000/XP +and later (with either Microsoft Visual Studio 2005 or later, or the +GNU toolchain via the MinGW environment). + + +File: libconfig.info, Node: Why Another Configuration File Library?, Next: Using the Library from a C Program, Up: Introduction + +1.1 Why Another Configuration File Library? +=========================================== + +There are several open-source configuration file libraries available as +of this writing. This library was written because each of those +libraries falls short in one or more ways. The main features of +libconfig that set it apart from the other libraries are: + + * A fully reentrant parser. Independent configurations can be parsed + in concurrent threads at the same time. + + * Both C and C++ bindings, as well as hooks to allow for the + creation of wrappers in other languages. + + * A simple, structured configuration file format that is more + readable and compact than XML and more flexible than the obsolete + but prevalent Windows "INI" file format. + + * A low-footprint implementation (just 38K for the C library and 66K + for the C++ library) that is suitable for memory-constrained + systems. + + * Proper documentation. + + + +File: libconfig.info, Node: Using the Library from a C Program, Next: Using the Library from a C++ Program, Prev: Why Another Configuration File Library?, Up: Introduction + +1.2 Using the Library from a C Program +====================================== + +To use the library from C code, include the following preprocessor +directive in your source files: + + + #include <libconfig.h> + + + To link with the library, specify `-lconfig' as an argument to the +linker. + + +File: libconfig.info, Node: Using the Library from a C++ Program, Next: Multithreading Issues, Prev: Using the Library from a C Program, Up: Introduction + +1.3 Using the Library from a C++ Program +======================================== + +To use the library from C++, include the following preprocessor +directive in your source files: + + + #include <libconfig.h++> + + + Or, alternatively: + + + #include <libconfig.hh> + + + The C++ API classes are defined in the namespace `libconfig', hence +the following statement may optionally be used: + + + using namespace libconfig; + + + To link with the library, specify `-lconfig++' as an argument to the +linker. + + +File: libconfig.info, Node: Multithreading Issues, Next: Internationalization Issues, Prev: Using the Library from a C++ Program, Up: Introduction + +1.4 Multithreading Issues +========================= + +Libconfig is fully "reentrant"; the functions in the library do not +make use of global variables and do not maintain state between +successive calls. Therefore two independent configurations may be safely +manipulated concurrently by two distinct threads. + + Libconfig is not "thread-safe". The library is not aware of the +presence of threads and knows nothing about the host system's threading +model. Therefore, if an instance of a configuration is to be accessed +from multiple threads, it must be suitably protected by synchronization +mechanisms like read-write locks or mutexes; the standard rules for +safe multithreaded access to shared data must be observed. + + Libconfig is not "async-safe". Calls should not be made into the +library from signal handlers, because some of the C library routines +that it uses may not be async-safe. + + Libconfig is not guaranteed to be "cancel-safe". Since it is not +aware of the host system's threading model, the library does not +contain any thread cancellation points. In most cases this will not be +an issue for multithreaded programs. However, be aware that some of the +routines in the library (namely those that read/write configurations +from/to files or streams) perform I/O using C library routines which +may potentially block; whether or not these C library routines are +cancel-safe depends on the host system. + + +File: libconfig.info, Node: Internationalization Issues, Next: Compiling Using pkg-config, Prev: Multithreading Issues, Up: Introduction + +1.5 Internationalization Issues +=============================== + +Libconfig does not natively support Unicode configuration files, but +string values may contain Unicode text encoded in UTF-8; such strings +will be treated as ordinary 8-bit ASCII text by the library. It is the +responsibility of the calling program to perform the necessary +conversions to/from wide (wchar_t) strings using the wide string +conversion functions such as mbsrtowcs() and wcsrtombs() or the iconv() +function of the libiconv library. + + The textual representation of a floating point value varies by +locale. However, the libconfig grammar specifies that floating point +values are represented using a period (`.') as the radix symbol; this +is consistent with the grammar of most programming languages. When a +configuration is read in or written out, libconfig temporarily changes +the LC_NUMERIC category of the locale of the calling thread to the "C" +locale to ensure consistent handling of floating point values +regardless of the locale(s) in use by the calling program. + + Note that the MinGW environment does not (as of this writing) provide +functions for changing the locale of the calling thread. Therefore, +when using libconfig in that environment, the calling program is +responsible for changing the LC_NUMERIC category of the locale to the +"C" locale before reading or writing a configuration. + + +File: libconfig.info, Node: Compiling Using pkg-config, Prev: Internationalization Issues, Up: Introduction + +1.6 Compiling Using pkg-config +============================== + +On UNIX systems you can use the pkg-config utility (version 0.20 or +later) to automatically select the appropriate compiler and linker +switches for libconfig. Ensure that the environment variable +`PKG_CONFIG_PATH' contains the absolute path to the `lib/pkgconfig' +subdirectory of the libconfig installation. Then, you can compile and +link C programs with libconfig as follows: + + gcc `pkg-config --cflags libconfig` myprogram.c -o myprogram \ + `pkg-config --libs libconfig` + + + And similarly, for C++ programs: + + g++ `pkg-config --cflags libconfig++` myprogram.cpp -o myprogram \ + `pkg-config --libs libconfig++` + + + Note the backticks in the above examples. + + +File: libconfig.info, Node: Configuration Files, Next: The C API, Prev: Introduction, Up: Top + +* Menu: + +* Settings:: +* Groups:: +* Arrays:: +* Lists:: +* Integer Values:: +* 64-bit Integer Values:: +* Floating Point Values:: +* Boolean Values:: +* String Values:: +* Comments:: + +2 Configuration Files +********************* + +Libconfig supports structured, hierarchical configurations. These +configurations can be read from and written to files and manipulated in +memory. + + A "configuration" consists of a group of "settings", which associate +names with values. A "value" can be one of the following: + + * A "scalar value": integer, 64-bit integer, floating-point number, + boolean, or string + + * An "array", which is a sequence of scalar values, all of which + must have the same type + + * A "group", which is a collection of settings + + * A "list", which is a sequence of values of any type, including + other lists + + Consider the following configuration file for a hypothetical GUI +application, which illustrates all of the elements of the configuration +file grammar. + + + # Example application configuration file + + version = "1.0"; + + application: + { + window: + { + title = "My Application"; + size = { w = 640; h = 480; }; + pos = { x = 350; y = 250; }; + }; + + list = ( ( "abc", 123, true ), 1.234, ( /* an empty list */) ); + + books = ( { title = "Treasure Island"; + author = "Robert Louis Stevenson"; + price = 29.95; + qty = 5; }, + { title = "Snow Crash"; + author = "Neal Stephenson"; + price = 9.99; + qty = 8; } ); + + misc: + { + pi = 3.141592654; + bigint = 9223372036854775807L; + columns = [ "Last Name", "First Name", "MI" ]; + bitmask = 0x1FC3; + }; + }; + + + Settings can be uniquely identified within the configuration by a +"path". The path is a dot-separated sequence of names, beginning at a +top-level group and ending at the setting itself. Each name in the path +is the name of a setting; if the setting has no name because it is an +element in a list or array, an integer index in square brackets can be +used as the name. + + For example, in our hypothetical configuration file, the path to the +`x' setting is `application.window.pos.x'; the path to the `version' +setting is simply `version'; and the path to the `title' setting of the +second book in the `books' list is `application.books.[1].title'. + + The datatype of a value is determined from the format of the value +itself. If the value is enclosed in double quotes, it is treated as a +string. If it looks like an integer or floating point number, it is +treated as such. If it is one of the values `TRUE', `true', `FALSE', or +`false' (or any other mixed-case version of those tokens, e.g., `True' +or `FaLsE'), it is treated as a boolean. If it consists of a +comma-separated list of values enclosed in square brackets, it is +treated as an array. And if it consists of a comma-separated list of +values enclosed in parentheses, it is treated as a list. Any value +which does not meet any of these criteria is considered invalid and +results in a parse error. + + All names are case-sensitive. They may consist only of alphanumeric +characters, dashes (`-'), underscores (`_'), and asterisks (`*'), and +must begin with a letter or asterisk. No other characters are allowed. + + In C and C++, integer, 64-bit integer, floating point, and string +values are mapped to the types `long', `long long', `double', and +`const char *', respectively. The boolean type is mapped to `int' in C +and `bool' in C++. + + The following sections describe the elements of the configuration +file grammar in additional detail. + + +File: libconfig.info, Node: Settings, Next: Groups, Up: Configuration Files + +2.1 Settings +============ + +A setting has the form: + + name = value ; + + or: + + name : value ; + + The trailing semicolon is required. Whitespace is not significant. + + The value may be a scalar value, an array, a group, or a list. + + +File: libconfig.info, Node: Groups, Next: Arrays, Prev: Settings, Up: Configuration Files + +2.2 Groups +========== + +A group has the form: + + { settings ... } + + Groups can contain any number of settings, but each setting must have +a unique name within the group. + + +File: libconfig.info, Node: Arrays, Next: Lists, Prev: Groups, Up: Configuration Files + +2.3 Arrays +========== + +An array has the form: + + [ value, value ... ] + + An array may have zero or more elements, but the elements must all be +scalar values of the same type. + + +File: libconfig.info, Node: Lists, Next: Integer Values, Prev: Arrays, Up: Configuration Files + +2.4 Lists +========= + +A list has the form: + + ( value, value ... ) + + A list may have zero or more elements, each of which can be a scalar +value, an array, a group, or another list. + + +File: libconfig.info, Node: Integer Values, Next: 64-bit Integer Values, Prev: Lists, Up: Configuration Files + +2.5 Integer Values +================== + +Integers can be represented in one of two ways: as a series of one or +more decimal digits (`0' - `9'), with an optional leading sign +character (`+' or `-'); or as a hexadecimal value consisting of the +characters `0x' followed by a series of one or more hexadecimal digits +(`0' - `9', `A' - `F', `a' - `f'). + + +File: libconfig.info, Node: 64-bit Integer Values, Next: Floating Point Values, Prev: Integer Values, Up: Configuration Files + +2.6 64-bit Integer Values +========================= + +Long long (64-bit) integers are represented identically to integers, +except that an 'L' character is appended to indicate a 64-bit value. +For example, `0L' indicates a 64-bit integer value 0. + + +File: libconfig.info, Node: Floating Point Values, Next: Boolean Values, Prev: 64-bit Integer Values, Up: Configuration Files + +2.7 Floating Point Values +========================= + +Floating point values consist of a series of one or more digits, one +decimal point, an optional leading sign character (`+' or `-'), and an +optional exponent. An exponent consists of the letter `E' or `e', an +optional sign character, and a series of one or more digits. + + +File: libconfig.info, Node: Boolean Values, Next: String Values, Prev: Floating Point Values, Up: Configuration Files + +2.8 Boolean Values +================== + +Boolean values may have one of the following values: `true', `false', +or any mixed-case variation thereof. + + +File: libconfig.info, Node: String Values, Next: Comments, Prev: Boolean Values, Up: Configuration Files + +2.9 String Values +================= + +String values consist of arbitrary text delimited by double quotes. +Literal double quotes can be escaped by preceding them with a +backslash: `\"'. The escape sequences `\\', `\f', `\n', `\r', and `\t' +are also recognized, and have the usual meaning. No other escape +sequences are currently supported. + + Adjacent strings are automatically concatenated, as in C/C++ source +code. This is useful for formatting very long strings as sequences of +shorter strings. For example, the following constructs are equivalent: + + * `"The quick brown fox jumped over the lazy dog."' + + * `"The quick brown fox"' + `" jumped over the lazy dog."' + + * `"The quick" /* comment */ " brown fox " // another comment' + `"jumped over the lazy dog."' + + + +File: libconfig.info, Node: Comments, Prev: String Values, Up: Configuration Files + +2.10 Comments +============= + +Three types of comments are allowed within a configuration: + + * Script-style comments. All text beginning with a `#' character to + the end of the line is ignored. + + * C-style comments. All text, including line breaks, between a + starting `/*' sequence and an ending `*/' sequence is ignored. + + * C++-style comments. All text beginning with a `//' sequence to the + end of the line is ignored. + + + As expected, comment delimiters appearing within quoted strings are +treated as literal text. + + Comments are ignored when the configuration is read in, so they are +not treated as part of the configuration. Therefore if the +configuration is written back out to a stream, any comments that were +present in the original configuration will be lost. + + +File: libconfig.info, Node: The C API, Next: The C++ API, Prev: Configuration Files, Up: Top + +3 The C API +*********** + +This chapter describes the C library API. The type config_t represents +a configuration, and the type config_setting_t represents a +configuration setting. + + The boolean values `CONFIG_TRUE' and `CONFIG_FALSE' are macros +defined as `(1)' and `(0)', respectively. + + -- Function: void config_init (config_t * CONFIG) + -- Function: void config_destroy (config_t * CONFIG) + These functions initialize and destroy the configuration object + CONFIG. + + `config_init()' initializes CONFIG as a new, empty configuration. + + `config_destroy()' destroys the configuration CONFIG, deallocating + all memory associated with the configuration, but not including + the config_t structure itself. + + + -- Function: int config_read (config_t * CONFIG, FILE * STREAM) + This function reads and parses a configuration from the given + STREAM into the configuration object CONFIG. It returns + `CONFIG_TRUE' on success, or `CONFIG_FALSE' on failure; the + `config_error_text()' and `config_error_line()' functions, + described below, can be used to obtain information about the error. + + + -- Function: int config_read_file (config_t * CONFIG, + const char * FILENAME) + This function reads and parses a configuration from the file named + FILENAME into the configuration object CONFIG. It returns + `CONFIG_TRUE' on success, or `CONFIG_FALSE' on failure; the + `config_error_text()' and `config_error_line()' functions, + described below, can be used to obtain information about the error. + + + -- Function: void config_write (const config_t * CONFIG, FILE * STREAM) + This function writes the configuration CONFIG to the given STREAM. + + + -- Function: int config_write_file (config_t * CONFIG, + const char * FILENAME) + This function writes the configuration CONFIG to the file named + FILENAME. It returns `CONFIG_TRUE' on success, or `CONFIG_FALSE' + on failure. + + + -- Function: const char * config_error_text (const config_t * CONFIG) + -- Function: int config_error_line (const config_t * CONFIG) + These functions, which are implemented as macros, return the text + and line number of the parse error, if one occurred during a call + to `config_read()' or `config_read_file()'. Storage for the string + returned by `config_error_text()' is managed by the library and + released automatically when the configuration is destroyed; the + string must not be freed by the caller. + + + -- Function: void config_set_auto_convert (config_t *CONFIG, int FLAG) + -- Function: int config_get_auto_convert (const config_t *CONFIG) + `config_set_auto_convert()' enables number auto-conversion for the + configuration CONFIG if FLAG is non-zero, and disables it + otherwise. When this feature is enabled, an attempt to retrieve a + floating point setting's value into an integer (or vice versa), or + store an integer to a floating point setting's value (or vice + versa) will cause the library to silently perform the necessary + conversion (possibly leading to loss of data), rather than + reporting failure. By default this feature is disabled. + + `config_get_auto_convert()' returns `CONFIG_TRUE' if number + auto-conversion is currently enabled for CONFIG; otherwise it + returns `CONFIG_FALSE'. + + + -- Function: int config_lookup_int (const config_t * CONFIG, + const char * PATH, long * VALUE) + -- Function: int config_lookup_int64 (const config_t * CONFIG, + const char * PATH, long long * VALUE) + -- Function: int config_lookup_float (const config_t * CONFIG, + const char * PATH, double * VALUE) + -- Function: int config_lookup_bool (const config_t * CONFIG, + const char * PATH, int * VALUE) + -- Function: int config_lookup_string (const config_t * CONFIG, + const char * PATH, const char ** VALUE) + These functions look up the value of the setting in the + configuration CONFIG specified by the path PATH. They store the + value of the setting at VALUE and return `CONFIG_TRUE' on success. + If the setting was not found or if the type of the value did not + match the type requested, they leave the data pointed to by VALUE + unmodified and return `CONFIG_FALSE'. + + Storage for the string returned by `config_lookup_string()' is + managed by the library and released automatically when the setting + is destroyed or when the setting's value is changed; the string + must not be freed by the caller. + + + -- Function: config_setting_t * config_lookup + (const config_t * CONFIG, const char * PATH) + This function locates the setting in the configuration CONFIG + specified by the path PATH. It returns a pointer to the + `config_setting_t' structure on success, or `NULL' if the setting + was not found. + + + -- Function: long config_setting_get_int + (const config_setting_t * SETTING) + -- Function: long long config_setting_get_int64 + (const config_setting_t * SETTING) + -- Function: double config_setting_get_float + (const config_setting_t * SETTING) + -- Function: int config_setting_get_bool + (const config_setting_t * SETTING) + -- Function: const char * config_setting_get_string + (const config_setting_t * SETTING) + These functions return the value of the given SETTING. If the type + of the setting does not match the type requested, a 0 or `NULL' + value is returned. Storage for the string returned by + `config_setting_get_string()' is managed by the library and + released automatically when the setting is destroyed or when the + setting's value is changed; the string must not be freed by the + caller. + + + -- Function: int config_setting_set_int (config_setting_t * SETTING, + long VALUE) + -- Function: int config_setting_set_int64 (config_setting_t * SETTING, + long long VALUE) + -- Function: int config_setting_set_float (config_setting_t * SETTING, + double VALUE) + -- Function: int config_setting_set_bool (config_setting_t * SETTING, + int VALUE) + -- Function: int config_setting_set_string + (config_setting_t * SETTING, const char * VALUE) + These functions set the value of the given SETTING to VALUE. On + success, they return `CONFIG_TRUE'. If the setting does not match + the type of the value, they return `CONFIG_FALSE'. + `config_setting_set_string()' makes a copy of the passed string + VALUE, so it may be subsequently freed or modified by the caller + without affecting the value of the setting. + + + -- Function: int config_setting_lookup_int + (const config_setting_t * SETTING, const char * NAME, + long * VALUE) + -- Function: int config_setting_lookup_int64 + (const config_setting_t * SETTING, const char * NAME, + long long * VALUE) + -- Function: int config_setting_lookup_float + (const config_setting_t * SETTING, const char * NAME, + double * VALUE) + -- Function: int config_setting_lookup_bool + (const config_setting_t * SETTING, const char * NAME, + int * VALUE) + -- Function: int config_setting_lookup_string + (const config_setting_t * SETTING, const char * NAME, + const char ** VALUE) + These functions look up the value of the child setting named NAME + of the setting SETTING. They store the value at VALUE and return + `CONFIG_TRUE' on success. If the setting was not found or if the + type of the value did not match the type requested, they leave the + data pointed to by VALUE unmodified and return `CONFIG_FALSE'. + + Storage for the string returned by + `config_setting_lookup_string()' is managed by the library and + released automatically when the setting is destroyed or when the + setting's value is changed; the string must not be freed by the + caller. + + + -- Function: short config_setting_get_format + (config_setting_t * SETTING) + -- Function: int config_setting_set_format + (config_setting_t * SETTING, short FORMAT) + These functions get and set the external format for the setting + SETTING. + + The FORMAT must be one of the constants `CONFIG_FORMAT_DEFAULT' or + `CONFIG_FORMAT_HEX'. All settings support the + `CONFIG_FORMAT_DEFAULT' format. The `CONFIG_FORMAT_HEX' format + specifies hexadecimal formatting for integer values, and hence + only applies to settings of type `CONFIG_TYPE_INT' and + `CONFIG_TYPE_INT64'. If FORMAT is invalid for the given setting, + it is ignored. + + `config_setting_set_format()' returns `CONFIG_TRUE' on success and + `CONFIG_FALSE' on failure. + + + -- Function: config_setting_t * config_setting_get_member + (config_setting_t * SETTING, const char * NAME) + This function fetches the child setting named NAME from the group + SETTING. It returns the requested setting on success, or `NULL' if + the setting was not found or if SETTING is not a group. + + + -- Function: config_setting_t * config_setting_get_elem + (const config_setting_t * SETTING, unsigned int IDX) + This function fetches the element at the given index IDX in the + setting SETTING, which must be an array, list, or group. It + returns the requested setting on success, or `NULL' if IDX is out + of range or if SETTING is not an array, list, or group. + + + -- Function: long config_setting_get_int_elem + (const config_setting_t * SETTING, int IDX) + -- Function: long long config_setting_get_int64_elem + (const config_setting_t * SETTING, int IDX) + -- Function: double config_setting_get_float_elem + (const config_setting_t * SETTING, int IDX) + -- Function: int config_setting_get_bool_elem + (const config_setting_t * SETTING, int IDX) + -- Function: const char * config_setting_get_string_elem + (const config_setting_t * SETTING, int IDX) + These functions return the value at the specified index IDX in the + setting SETTING. If the setting is not an array or list, or if the + type of the element does not match the type requested, or if IDX + is out of range, they return 0 or `NULL'. Storage for the string + returned by `config_setting_get_string_elem()' is managed by the + library and released automatically when the setting is destroyed + or when its value is changed; the string must not be freed by the + caller. + + -- Function: config_setting_t * config_setting_set_int_elem + (config_setting_t * SETTING, int IDX, long VALUE) + -- Function: config_setting_t * config_setting_set_int64_elem + (config_setting_t * SETTING, int IDX, long long VALUE) + -- Function: config_setting_t * config_setting_set_float_elem + (config_setting_t * SETTING, int IDX, double VALUE) + -- Function: config_setting_t * config_setting_set_bool_elem + (config_setting_t * SETTING, int IDX, int VALUE) + -- Function: config_setting_t * config_setting_set_string_elem + (config_setting_t * SETTING, int IDX, const char * VALUE) + These functions set the value at the specified index IDX in the + setting SETTING to VALUE. If IDX is negative, a new element is + added to the end of the array or list. On success, these functions + return a pointer to the setting representing the element. If the + setting is not an array or list, or if the setting is an array and + the type of the array does not match the type of the value, or if + IDX is out of range, they return `NULL'. + `config_setting_set_string_elem()' makes a copy of the passed + string VALUE, so it may be subsequently freed or modified by the + caller without affecting the value of the setting. + + -- Function: config_setting_t * config_setting_add + (config_setting_t * PARENT, const char * NAME, int TYPE) + This function adds a new child setting or element to the setting + PARENT, which must be a group, array, or list. If PARENT is an + array or list, the NAME parameter is ignored and may be `NULL'. + + The function returns the new setting on success, or `NULL' if + PARENT is not a group, array, or list; or if there is already a + child setting of PARENT named NAME; or if TYPE is invalid. + + -- Function: int config_setting_remove (config_setting_t * PARENT, + const char * NAME) + This function removes and destroys the setting named NAME from the + parent setting PARENT, which must be a group. Any child settings + of the setting are recursively destroyed as well. + + The function returns `CONFIG_TRUE' on success. If PARENT is not a + group, or if it has no setting with the given name, it returns + `CONFIG_FALSE'. + + + -- Function: int config_setting_remove_elem + (config_setting_t * PARENT, unsigned int IDX) + This function removes the child setting at the given index IDX from + the setting PARENT, which must be a group, list, or array. Any + child settings of the removed setting are recursively destroyed as + well. + + The function returns `CONFIG_TRUE' on success. If PARENT is not a + group, list, or array, or if IDX is out of range, it returns + `CONFIG_FALSE'. + + + -- Function: config_setting_t * config_root_setting + (const config_t * CONFIG) + This function returns the root setting for the configuration + CONFIG. The root setting is a group. + + + -- Function: const char * config_setting_name + (const config_setting_t * SETTING) + This function returns the name of the given SETTING, or `NULL' if + the setting has no name. Storage for the returned string is + managed by the library and released automatically when the setting + is destroyed; the string must not be freed by the caller. + + + -- Function: config_setting_t * config_setting_parent + (const config_setting_t * SETTING) + This function returns the parent setting of the given SETTING, or + `NULL' if SETTING is the root setting. + + + -- Function: int config_setting_is_root + (const config_setting_t * SETTING) + This function returns `CONFIG_TRUE' if the given SETTING is the + root setting, and `CONFIG_FALSE' otherwise. + + + -- Function: int config_setting_index + (const config_setting_t * SETTING) + This function returns the index of the given SETTING within its + parent setting. If SETTING is the root setting, this function + returns -1. + + + -- Function: int config_setting_length + (const config_setting_t * SETTING) + This function returns the number of settings in a group, or the + number of elements in a list or array. For other types of + settings, it returns 0. + + + -- Function: int config_setting_type (const config_setting_t * SETTING) + This function returns the type of the given SETTING. The return + value is one of the constants `CONFIG_TYPE_INT', + `CONFIG_TYPE_INT64', `CONFIG_TYPE_FLOAT', `CONFIG_TYPE_STRING', + `CONFIG_TYPE_BOOL', `CONFIG_TYPE_ARRAY', `CONFIG_TYPE_LIST', or + `CONFIG_TYPE_GROUP'. + + + -- Function: int config_setting_is_group + (const config_setting_t * SETTING) + -- Function: int config_setting_is_array + (const config_setting_t * SETTING) + -- Function: int config_setting_is_list + (const config_setting_t * SETTING) + These convenience functions, which are implemented as macros, test + if the setting SETTING is of a given type. They return + `CONFIG_TRUE' or `CONFIG_FALSE'. + + + -- Function: int config_setting_is_aggregate + (const config_setting_t * SETTING) + -- Function: int config_setting_is_scalar + (const config_setting_t * SETTING) + -- Function: int config_setting_is_number + (const config_setting_t * SETTING) + These convenience functions, which are implemented as macros, test + if the setting SETTING is of an aggregate type (a group, array, or + list), of a scalar type (integer, 64-bit integer, floating point, + boolean, or string), and of a number (integer, 64-bit integer, or + floating point), respectively. They return `CONFIG_TRUE' or + `CONFIG_FALSE'. + + + -- Function: unsigned int config_setting_source_line + (const config_setting_t * SETTING) + This function returns the line number of the configuration file or + stream at which the setting SETTING was parsed. This information + is useful for reporting application-level errors. If the setting + was not read from a file or stream, or if the line number is + otherwise unavailable, the function returns 0. + + + -- Function: void config_setting_set_hook (config_setting_t * SETTING, + void * HOOK) + -- Function: void * config_setting_get_hook + (const config_setting_t * SETTING) + These functions make it possible to attach arbitrary data to each + setting structure, for instance a "wrapper" or "peer" object + written in another programming language. The destructor function, + if one has been supplied via a call to `config_set_destructor()', + will be called by the library to dispose of this data when the + setting itself is destroyed. There is no default destructor. + + + -- Function: void config_set_destructor (config_t * CONFIG, + void (* DESTRUCTOR)(void *)) + This function assigns the destructor function DESTRUCTOR for the + configuration CONFIG. This function accepts a single `void *' + argument and has no return value. See `config_setting_set_hook()' + above for more information. + + + +File: libconfig.info, Node: The C++ API, Next: Configuration File Grammar, Prev: The C API, Up: Top + +4 The C++ API +************* + +This chapter describes the C++ library API. The class `Config' +represents a configuration, and the class `Setting' represents a +configuration setting. Note that by design, neither of these classes +provides a public copy constructor or assignment operator. Therefore, +instances of these classes may only be passed between functions via +references or pointers. + + The library defines a group of exceptions, all of which extend the +common base exception `ConfigException'. + + A `SettingTypeException' is thrown when the type of a setting's +value does not match the type requested. + + A `SettingNotFoundException' is thrown when a setting is not found. + + A `SettingNameException' is thrown when an attempt is made to add a +new setting with a non-unique or invalid name. + + A `ParseException' is thrown when a parse error occurs while reading +a configuration from a stream. + + A `FileIOException' is thrown when an I/O error occurs while +reading/writing a configuration from/to a file. + + `SettingTypeException', `SettingNotFoundException', and +`SettingNameException' all extend the common base exception +`SettingException', which provides the following method: + + -- Method on SettingException: const char * getPath () + Returns the path to the setting associated with the exception, or + `NULL' if there is no applicable path. + + + The remainder of this chapter describes the methods for manipulating +configurations and configuration settings. + + -- Method on Config: Config () + -- Method on Config: ~Config () + These methods create and destroy `Config' objects. + + + -- Method on Config: void read (FILE * STREAM) + -- Method on Config: void write (FILE * STREAM) + The `read()' method reads and parses a configuration from the given + STREAM. A `ParseException' is thrown if a parse error occurs. + + The `write()' method writes the configuration to the given STREAM. + + + -- Method on Config: void readFile (const char * FILENAME) + -- Method on Config: void writeFile (const char * FILENAME) + The `readFile()' method reads and parses a configuration from the + file named FILENAME. A `ParseException' is thrown if a parse error + occurs. A `FileIOException' is thrown if the file cannot be read. + + The `writeFile()' method writes the configuration to the file + named FILENAME. A `FileIOException' is thrown if the file cannot + be written. + + + -- Method on ParseException: const char * getError () + -- Method on ParseException: int getLine () + If a call to `readFile()' or `read()' resulted in a + `ParseException', these methods can be called on the exception + object to obtain the text and line number of the parse error. + Storage for the string returned by `getError()' is managed by the + library; the string must not be freed by the caller. + + + -- Method on Config: void setAutoConvert (bool FLAG) + -- Method on Config: bool getAutoConvert () + `setAutoConvert()' enables number auto-conversion for the + configuration if FLAG is `true', and disables it otherwise. When + this feature is enabled, an attempt to assign a floating point + setting to an integer (or vice versa), or assign an integer to a + floating point setting (or vice versa) will cause the library to + silently perform the necessary conversion (possibly leading to + loss of data), rather than throwing a `SettingTypeException'. By + default this feature is disabled. + + `getAutoConvert()' returns `true' if number auto-conversion is + currently enabled for the configuration; otherwise it returns + `false'. + + + -- Method on Config: Setting & getRoot () + This method returns the root setting for the configuration, which + is a group. + + + -- Method on Config: Setting & lookup (const std::string &PATH) + -- Method on Config: Setting & lookup (const char * PATH) + These methods locate the setting specified by the path PATH. If + the requested setting is not found, a `SettingNotFoundException' is + thrown. + + + -- Method on Config: bool exists (const std::string &PATH) + -- Method on Config: bool exists (const char *PATH) + These methods test if a setting with the given PATH exists in the + configuration. They return `true' if the setting exists, and + `false' otherwise. These methods do not throw exceptions. + + + -- Method on Config: bool lookupValue (const char *PATH, bool &VALUE) + -- Method on Config: bool lookupValue (const std::string &PATH, + bool &VALUE) + -- Method on Config: bool lookupValue (const char *PATH, int &VALUE) + -- Method on Config: bool lookupValue (const std::string &PATH, + int &VALUE) + -- Method on Config: bool lookupValue (const char *PATH, + unsigned int &VALUE) + -- Method on Config: bool lookupValue (const std::string &PATH, + unsigned int &VALUE) + -- Method on Config: bool lookupValue (const char *PATH, long &VALUE) + -- Method on Config: bool lookupValue (const std::string &PATH, + long &VALUE) + -- Method on Config: bool lookupValue (const char *PATH, + long long &VALUE) + -- Method on Config: bool lookupValue (const std::string &PATH, + long long &VALUE) + -- Method on Config: bool lookupValue (const char *PATH, + unsigned long &VALUE) + -- Method on Config: bool lookupValue (const std::string &PATH, + unsigned long &VALUE) + -- Method on Config: bool lookupValue (const char *PATH, float &VALUE) + -- Method on Config: bool lookupValue (const std::string &PATH, + float &VALUE) + -- Method on Config: bool lookupValue (const char *PATH, double &VALUE) + -- Method on Config: bool lookupValue (const std::string &PATH, + double &VALUE) + -- Method on Config: bool lookupValue (const char *PATH, + const char *&VALUE) + -- Method on Config: bool lookupValue (const std::string &PATH, + const char *&VALUE) + -- Method on Config: bool lookupValue (const char *PATH, + std::string &VALUE) + -- Method on Config: bool lookupValue (const std::string &PATH, + std::string &VALUE) + These are convenience methods for looking up the value of a setting + with the given PATH. If the setting is found and is of an + appropriate type, the value is stored in VALUE and the method + returns `true'. Otherwise, VALUE is left unmodified and the method + returns `false'. These methods do not throw exceptions. + + Storage for const char * values is managed by the library and + released automatically when the setting is destroyed or when its + value is changed; the string must not be freed by the caller. For + safety and convenience, always assigning string values to a + `std::string' is suggested. + + Since these methods have boolean return values and do not throw + exceptions, they can be used within boolean logic expressions. The + following example presents a concise way to look up three values + at once and perform error handling if any of them are not found or + are of the wrong type: + + + int var1; + double var2; + const char *var3; + + if(config.lookupValue("values.var1", var1) + && config.lookupValue("values.var2", var2) + && config.lookupValue("values.var3", var3)) + { + // use var1, var2, var3 + } + else + { + // error handling here + } + + This approach also takes advantage of the short-circuit evaluation + rules of C++, e.g., if the first lookup fails (returning `false'), + the remaining lookups are skipped entirely. + + + -- Method on Setting: operator bool() + -- Method on Setting: operator int() + -- Method on Setting: operator unsigned int() + -- Method on Setting: operator long() + -- Method on Setting: operator unsigned long() + -- Method on Setting: operator long long() + -- Method on Setting: operator unsigned long long() + -- Method on Setting: operator float() + -- Method on Setting: operator double() + -- Method on Setting: operator const char *() + -- Method on Setting: operator std::string() + These cast operators allow a `Setting' object to be assigned to a + variable of type bool if it is of type `TypeBoolean'; int, + unsigned int, long, or unsigned long if it is of type `TypeInt'; + `long long' or `unsigned long long' if it is of type `TypeInt64', + float or double if it is of type `TypeFloat'; or const char * or + std::string if it is of type `TypeString'. + + Storage for const char * return values is managed by the library + and released automatically when the setting is destroyed or when + its value is changed; the string must not be freed by the caller. + For safety and convenience, always assigning string return values + to a `std::string' is suggested. + + The following examples demonstrate this usage: + + long width = config.lookup("application.window.size.w"); + + bool splashScreen = config.lookup("application.splash_screen"); + + std::string title = config.lookup("application.window.title"); + + Note that certain conversions can lead to loss of precision or + clipping of values, e.g., assigning a negative value to an unsigned + int (in which case the value will be treated as 0), or a + double-precision value to a float. The library does not treat + these lossy conversions as errors. + + Perhaps surprisingly, the following code in particular will cause a + compiler error: + + std::string title; + . + . + . + title = config.lookup("application.window.title"); + + This is because the assignment operator of `std::string' is being + invoked with a `Setting &' as an argument. The compiler is unable + to make an implicit conversion because both the `const char *' and + the `std::string' cast operators of `Setting' are equally + appropriate. This is not a bug in libconfig; providing only the + `const char *' cast operator would resolve this particular + ambiguity, but would cause assignments to `std::string' like the + one in the previous example to produce a compiler error. (To + understand why, see section 11.4.1 of The C++ Programming + Language.) + + The solution to this problem is to use an explicit conversion that + avoids the construction of an intermediate `std::string' object, + as follows: + + std::string title; + . + . + . + title = (const char *)config.lookup("application.window.title"); + + If the assignment is invalid due to a type mismatch, a + `SettingTypeException' is thrown. + + + -- Method on Setting: Setting & operator= (bool VALUE) + -- Method on Setting: Setting & operator= (int VALUE) + -- Method on Setting: Setting & operator= (long VALUE) + -- Method on Setting: Setting & operator= (const long long &VALUE) + -- Method on Setting: Setting & operator= (float VALUE) + -- Method on Setting: Setting & operator= (const double &VALUE) + -- Method on Setting: Setting & operator= (const char *VALUE) + -- Method on Setting: Setting & operator= (const std::string &VALUE) + These assignment operators allow values of type bool, int, long, + long long, float, double, const char *, and std::string to be + assigned to a setting. In the case of strings, the library makes a + copy of the passed string VALUE, so it may be subsequently freed + or modified by the caller without affecting the value of the + setting. + + If the assignment is invalid due to a type mismatch, a + `SettingTypeException' is thrown. + + + -- Method on Setting: Setting & operator[] (int IDX) + -- Method on Setting: Setting & operator[] (const std::string &NAME) + -- Method on Setting: Setting & operator[] (const char *NAME) + A `Setting' object may be subscripted with an integer index IDX if + it is an array or list, or with either a string NAME or an integer + index IDX if it is a group. For example, the following code would + produce the string `Last Name' when applied to the example + configuration in *note Configuration Files::. + + Setting& setting = config.lookup("application.misc"); + const char *s = setting["columns"][0]; + + If the setting is not an array, list, or group, a + `SettingTypeException' is thrown. If the subscript (IDX or NAME) + does not refer to a valid element, a `SettingNotFoundException' is + thrown. + + Iterating over a group's child settings with an integer index will + return the settings in the same order that they appear in the + configuration. + + + -- Method on Setting: bool lookupValue (const char *NAME, bool &VALUE) + -- Method on Setting: bool lookupValue (const std::string &NAME, + bool &VALUE) + -- Method on Setting: bool lookupValue (const char *NAME, int &VALUE) + -- Method on Setting: bool lookupValue (const std::string &NAME, + int &VALUE) + -- Method on Setting: bool lookupValue (const char *NAME, + unsigned int &VALUE) + -- Method on Setting: bool lookupValue (const std::string &NAME, + unsigned int &VALUE) + -- Method on Setting: bool lookupValue (const char *NAME, + long long &VALUE) + -- Method on Setting: bool lookupValue (const std::string &NAME, + long long &VALUE) + -- Method on Setting: bool lookupValue (const char *NAME, + unsigned long long &VALUE) + -- Method on Setting: bool lookupValue (const std::string &NAME, + unsigned long long &VALUE) + -- Method on Setting: bool lookupValue (const char *NAME, long &VALUE) + -- Method on Setting: bool lookupValue (const std::string &NAME, + long &VALUE) + -- Method on Setting: bool lookupValue (const char *NAME, + unsigned long &VALUE) + -- Method on Setting: bool lookupValue (const std::string &NAME, + unsigned long &VALUE) + -- Method on Setting: bool lookupValue (const char *NAME, float &VALUE) + -- Method on Setting: bool lookupValue (const std::string &NAME, + float &VALUE) + -- Method on Setting: bool lookupValue (const char *NAME, + double &VALUE) + -- Method on Setting: bool lookupValue (const std::string &NAME, + double &VALUE) + -- Method on Setting: bool lookupValue (const char *NAME, + const char *&VALUE) + -- Method on Setting: bool lookupValue (const std::string &NAME, + const char *&VALUE) + -- Method on Setting: bool lookupValue (const char *NAME, + std::string &VALUE) + -- Method on Setting: bool lookupValue (const std::string &NAME, + std::string &VALUE) + These are convenience methods for looking up the value of a child + setting with the given NAME. If the setting is found and is of an + appropriate type, the value is stored in VALUE and the method + returns `true'. Otherwise, VALUE is left unmodified and the method + returns `false'. These methods do not throw exceptions. + + Storage for const char * values is managed by the library and + released automatically when the setting is destroyed or when its + value is changed; the string must not be freed by the caller. For + safety and convenience, always assigning string values to a + `std::string' is suggested. + + Since these methods have boolean return values and do not throw + exceptions, they can be used within boolean logic expressions. The + following example presents a concise way to look up three values + at once and perform error handling if any of them are not found or + are of the wrong type: + + + int var1; + double var2; + const char *var3; + + if(setting.lookupValue("var1", var1) + && setting.lookupValue("var2", var2) + && setting.lookupValue("var3", var3)) + { + // use var1, var2, var3 + } + else + { + // error handling here + } + + This approach also takes advantage of the short-circuit evaluation + rules of C++, e.g., if the first lookup fails (returning `false'), + the remaining lookups are skipped entirely. + + + -- Method on Setting: Setting & add (const std::string &NAME, + Setting::Type TYPE) + -- Method on Setting: Setting & add (const char *NAME, + Setting::Type TYPE) + These methods add a new child setting with the given NAME and TYPE + to the setting, which must be a group. They return a reference to + the new setting. If the setting already has a child setting with + the given name, or if the name is invalid, a + `SettingNameException' is thrown. If the setting is not a group, a + `SettingTypeException' is thrown. + + Once a setting has been created, neither its name nor type can be + changed. + + + -- Method on Setting: Setting & add (Setting::Type TYPE) + This method adds a new element to the setting, which must be of + type `TypeArray' or `TypeList'. If the setting is an array which + currently has zero elements, the TYPE parameter (which must be + `TypeInt', `TypeInt64', `TypeFloat', `TypeBool', or `TypeString') + determines the type for the array; otherwise it must match the + type of the existing elements in the array. + + The method returns the new setting on success. If TYPE is a scalar + type, the new setting will have a default value of 0, 0.0, + `false', or `NULL', depending on the type. + + The method throws a `SettingTypeException' if the setting is not + an array or list, or if TYPE is invalid. + + + -- Method on Setting: void remove (const std::string &NAME) + -- Method on Setting: void remove (const char *NAME) + These methods remove the child setting with the given NAME from + the setting, which must be a group. Any child settings of the + removed setting are recursively destroyed as well. + + If the setting is not a group, a `SettingTypeException' is thrown. + If the setting does not have a child setting with the given name, + a `SettingNotFoundException' is thrown. + + + -- Method on Setting: void remove (unsigned int IDX) + This method removes the child setting at the given index IDX from + the setting, which must be a group, list, or array. Any child + settings of the removed setting are recursively destroyed as well. + + If the setting is not a group, list, or array, a + `SettingTypeException' is thrown. If IDX is out of range, a + `SettingNotFoundException' is thrown. + + + -- Method on Setting: const char * getName () + This method returns the name of the setting, or `NULL' if the + setting has no name. Storage for the returned string is managed by + the library and released automatically when the setting is + destroyed; the string must not be freed by the caller. For safety + and convenience, consider assigning the return value to a + `std::string'. + + + -- Method on Setting: std::string getPath () + This method returns the complete dot-separated path to the + setting. Settings which do not have a name (list and array + elements) are represented by their index in square brackets. + + + -- Method on Setting: Setting & getParent () + This method returns the parent setting of the setting. If the + setting is the root setting, a `SettingNotFoundException' is + thrown. + + + -- Method on Setting: bool isRoot () + This method returns `true' if the setting is the root setting, and + `false' otherwise. + + + -- Method on Setting: int getIndex () + This method returns the index of the setting within its parent + setting. When applied to the root setting, this method returns -1. + + + -- Method on Setting: Setting::Type getType () + This method returns the type of the setting. The `Setting::Type' + enumeration consists of the following constants: `TypeInt', + `TypeInt64', `TypeFloat', `TypeString', `TypeBoolean', + `TypeArray', `TypeList', and `TypeGroup'. + + + -- Method on Setting: Setting::Format getFormat () + -- Method on Setting: void setFormat (Setting::Format FORMAT) + These methods get and set the external format for the setting. + + The SETTING::FORMAT enumeration consists of the following + constants: `FormatDefault' and `FormatHex'. All settings support + the `FormatDefault' format. The `FormatHex' format specifies + hexadecimal formatting for integer values, and hence only applies + to settings of type `TypeInt' and `TypeInt64'. If FORMAT is + invalid for the given setting, it is ignored. + + + -- Method on Setting: bool exists (const std::string &NAME) + -- Method on Setting: bool exists (const char *NAME) + These methods test if the setting has a child setting with the + given NAME. They return `true' if the setting exists, and `false' + otherwise. These methods do not throw exceptions. + + + -- Method on Setting: int getLength () + This method returns the number of settings in a group, or the + number of elements in a list or array. For other types of + settings, it returns 0. + + + -- Method on Setting: bool isGroup () + -- Method on Setting: bool isArray () + -- Method on Setting: bool isList () + These convenience methods test if a setting is of a given type. + + + -- Method on Setting: bool isAggregate () + -- Method on Setting: bool isScalar () + -- Method on Setting: bool isNumber () + These convenience methods test if a setting is of an aggregate + type (a group, array, or list), of a scalar type (integer, 64-bit + integer, floating point, boolean, or string), and of a number + (integer, 64-bit integer, or floating point), respectively. + + + -- Method on Setting: unsigned int getSourceLine () + This method returns the line number of the configuration file or + stream at which the setting was parsed. This information is useful + for reporting application-level errors. If the setting was not + read from a file or stream, or if the line number is otherwise + unavailable, the method returns 0. + + + +File: libconfig.info, Node: Configuration File Grammar, Next: License, Prev: The C++ API, Up: Top + +5 Configuration File Grammar +**************************** + +Below is the BNF grammar for configuration files. Comments are not part +of the grammar, and hence are not included here. + + + configuration = setting-list | empty + + empty = + + setting-list = setting | setting-list setting + + setting = name (":" | "=") value ";" + + value = scalar-value | array | list | group + + value-list = value | value-list "," value + + scalar-value = boolean | integer | integer64 | hex | hex64 | float + | string + + scalar-value-list = scalar-value | scalar-value-list "," scalar-value + + array = "[" (scalar-value-list | empty) "]" + + list = "(" (value-list | empty) ")" + + group = "{" (setting-list | empty) "}" + + + + Terminals are defined below as regular expressions: + +`boolean' `([Tt][Rr][Uu][Ee])|([Ff][Aa][Ll][Ss][Ee])' +`string' `\"([^\"\\]|\\.)*\"' +`name' `[A-Za-z\*][-A-Za-z0-9_\*]*' +`integer' `[-+]?[0-9]+' +`integer64' `[-+]?[0-9]+L(L)?' +`hex' `0[Xx][0-9A-Fa-f]+' +`hex64' `0[Xx][0-9A-Fa-f]+L(L)?' +`float' `([-+]?([0-9]*)?\.[0-9]*([eE][-+]?[0-9]+)?)|([-+]([0-9]+)(\.[0-9]*)?[eE][-+]?[0-9]+)' + + +File: libconfig.info, Node: License, Next: Function Index, Prev: Configuration File Grammar, Up: Top + +Appendix A License +****************** + + GNU LESSER GENERAL PUBLIC LICENSE + Version 2.1, February 1999 + + + Copyright (C) 1991, 1999 Free Software Foundation, Inc., 59 Temple +Place, Suite 330, Boston, MA 02111-1307 USA + + Everyone is permitted to copy and distribute verbatim copies of this +license document, but changing it is not allowed. + + [This is the first released version of the Lesser GPL. It also +counts as the successor of the GNU Library Public License, version 2, +hence the version number 2.1.] + + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +Licenses are intended to guarantee your freedom to share and change +free software-to make sure the software is free for all its users. + + This license, the Lesser General Public License, applies to some +specially designated software packages-typically libraries-of the Free +Software Foundation and other authors who decide to use it. You can use +it too, but we suggest you first think carefully about whether this +license or the ordinary General Public License is the better strategy to +use in any particular case, based on the explanations below. + + When we speak of free software, we are referring to freedom of use, +not price. Our General Public Licenses are designed to make sure that +you have the freedom to distribute copies of free software (and charge +for this service if you wish); that you receive source code or can get +it if you want it; that you can change the software and use pieces of +it in new free programs; and that you are informed that you can do these +things. + + To protect your rights, we need to make restrictions that forbid +distributors to deny you these rights or to ask you to surrender these +rights. These restrictions translate to certain responsibilities for +you if you distribute copies of the library or if you modify it. + + For example, if you distribute copies of the library, whether gratis +or for a fee, you must give the recipients all the rights that we gave +you. You must make sure that they, too, receive or can get the source +code. If you link other code with the library, you must provide +complete object files to the recipients, so that they can relink them +with the library after making changes to the library and recompiling +it. And you must show them these terms so they know their rights. + + We protect your rights with a two-step method: (1) we copyright the +library, and (2) we offer you this license, which gives you legal +permission to copy, distribute and/or modify the library. + + To protect each distributor, we want to make it very clear that +there is no warranty for the free library. Also, if the library is +modified by someone else and passed on, the recipients should know that +what they have is not the original version, so that the original +author's reputation will not be affected by problems that might be +introduced by others. + + Finally, software patents pose a constant threat to the existence of +any free program. We wish to make sure that a company cannot +effectively restrict the users of a free program by obtaining a +restrictive license from a patent holder. Therefore, we insist that +any patent license obtained for a version of the library must be +consistent with the full freedom of use specified in this license. + + Most GNU software, including some libraries, is covered by the +ordinary GNU General Public License. This license, the GNU Lesser +General Public License, applies to certain designated libraries, and is +quite different from the ordinary General Public License. We use this +license for certain libraries in order to permit linking those +libraries into non-free programs. + + When a program is linked with a library, whether statically or using +a shared library, the combination of the two is legally speaking a +combined work, a derivative of the original library. The ordinary +General Public License therefore permits such linking only if the entire +combination fits its criteria of freedom. The Lesser General Public +License permits more lax criteria for linking other code with the +library. + + We call this license the "Lesser" General Public License because it +does Less to protect the user's freedom than the ordinary General Public +License. It also provides other free software developers Less of an +advantage over competing non-free programs. These disadvantages are the +reason we use the ordinary General Public License for many libraries. +However, the Lesser license provides advantages in certain special +circumstances. + + For example, on rare occasions, there may be a special need to +encourage the widest possible use of a certain library, so that it +becomes a de-facto standard. To achieve this, non-free programs must +be allowed to use the library. A more frequent case is that a free +library does the same job as widely used non-free libraries. In this +case, there is little to gain by limiting the free library to free +software only, so we use the Lesser General Public License. + + In other cases, permission to use a particular library in non-free +programs enables a greater number of people to use a large body of free +software. For example, permission to use the GNU C Library in non-free +programs enables many more people to use the whole GNU operating system, +as well as its variant, the GNU/Linux operating system. + + Although the Lesser General Public License is Less protective of the +users' freedom, it does ensure that the user of a program that is linked +with the Library has the freedom and the wherewithal to run that program +using a modified version of the Library. + + The precise terms and conditions for copying, distribution and +modification follow. Pay close attention to the difference between a +"work based on the library" and a "work that uses the library". The +former contains code derived from the library, whereas the latter must +be combined with the library in order to run. + + GNU LESSER GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + + 0. This License Agreement applies to any software library or other + program which contains a notice placed by the copyright holder or + other authorized party saying it may be distributed under the + terms of this Lesser General Public License (also called "this + License"). Each licensee is addressed as "you". + + A "library" means a collection of software functions and/or data + prepared so as to be conveniently linked with application programs + (which use some of those functions and data) to form executables. + + The "Library", below, refers to any such software library or work + which has been distributed under these terms. A "work based on + the Library" means either the Library or any derivative work under + copyright law: that is to say, a work containing the Library or a + portion of it, either verbatim or with modifications and/or + translated straightforwardly into another language. (Hereinafter, + translation is included without limitation in the term + "modification".) + + "Source code" for a work means the preferred form of the work for + making modifications to it. For a library, complete source code + means all the source code for all modules it contains, plus any + associated interface definition files, plus the scripts used to + control compilation and installation of the library. + + Activities other than copying, distribution and modification are + not covered by this License; they are outside its scope. The act + of running a program using the Library is not restricted, and + output from such a program is covered only if its contents + constitute a work based on the Library (independent of the use of + the Library in a tool for writing it). Whether that is true + depends on what the Library does and what the program that uses + the Library does. + + + 1. You may copy and distribute verbatim copies of the Library's + complete source code as you receive it, in any medium, provided + that you conspicuously and appropriately publish on each copy an + appropriate copyright notice and disclaimer of warranty; keep + intact all the notices that refer to this License and to the + absence of any warranty; and distribute a copy of this License + along with the Library. + + You may charge a fee for the physical act of transferring a copy, + and you may at your option offer warranty protection in exchange + for a fee. + + + 2. You may modify your copy or copies of the Library or any portion + of it, thus forming a work based on the Library, and copy and + distribute such modifications or work under the terms of Section 1 + above, provided that you also meet all of these conditions: + + a. The modified work must itself be a software library. + + + b. You must cause the files modified to carry prominent notices + stating that you changed the files and the date of any change. + + + c. You must cause the whole of the work to be licensed at no + charge to all third parties under the terms of this License. + + + d. If a facility in the modified Library refers to a function or + a table of data to be supplied by an application program that + uses the facility, other than as an argument passed when the + facility is invoked, then you must make a good faith effort + to ensure that, in the event an application does not supply + such function or table, the facility still operates, and + performs whatever part of its purpose remains meaningful. + + (For example, a function in a library to compute square roots + has a purpose that is entirely well-defined independent of + the application. Therefore, Subsection 2d requires that any + application-supplied function or table used by this function + must be optional: if the application does not supply it, the + square root function must still compute square roots.) + + + These requirements apply to the modified work as a whole. If + identifiable sections of that work are not derived from the + Library, and can be reasonably considered independent and separate + works in themselves, then this License, and its terms, do not + apply to those sections when you distribute them as separate + works. But when you distribute the same sections as part of a + whole which is a work based on the Library, the distribution of + the whole must be on the terms of this License, whose permissions + for other licensees extend to the entire whole, and thus to each + and every part regardless of who wrote it. + + Thus, it is not the intent of this section to claim rights or + contest your rights to work written entirely by you; rather, the + intent is to exercise the right to control the distribution of + derivative or collective works based on the Library. + + In addition, mere aggregation of another work not based on the + Library with the Library (or with a work based on the Library) on + a volume of a storage or distribution medium does not bring the + other work under the scope of this License. + + + 3. You may opt to apply the terms of the ordinary GNU General Public + License instead of this License to a given copy of the Library. + To do this, you must alter all the notices that refer to this + License, so that they refer to the ordinary GNU General Public + License, version 2, instead of to this License. (If a newer + version than version 2 of the ordinary GNU General Public License + has appeared, then you can specify that version instead if you + wish.) Do not make any other change in these notices. + + Once this change is made in a given copy, it is irreversible for + that copy, so the ordinary GNU General Public License applies to + all subsequent copies and derivative works made from that copy. + + This option is useful when you wish to copy part of the code of the + Library into a program that is not a library. + + + 4. You may copy and distribute the Library (or a portion or + derivative of it, under Section 2) in object code or executable + form under the terms of Sections 1 and 2 above provided that you + accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software + interchange. + + If distribution of object code is made by offering access to copy + from a designated place, then offering equivalent access to copy + the source code from the same place satisfies the requirement to + distribute the source code, even though third parties are not + compelled to copy the source along with the object code. + + + 5. A program that contains no derivative of any portion of the + Library, but is designed to work with the Library by being + compiled or linked with it, is called a "work that uses the + Library". Such a work, in isolation, is not a derivative work of + the Library, and therefore falls outside the scope of this License. + + However, linking a "work that uses the Library" with the Library + creates an executable that is a derivative of the Library (because + it contains portions of the Library), rather than a "work that + uses the library". The executable is therefore covered by this + License. Section 6 states terms for distribution of such + executables. + + When a "work that uses the Library" uses material from a header + file that is part of the Library, the object code for the work may + be a derivative work of the Library even though the source code is + not. Whether this is true is especially significant if the work + can be linked without the Library, or if the work is itself a + library. The threshold for this to be true is not precisely + defined by law. + + If such an object file uses only numerical parameters, data + structure layouts and accessors, and small macros and small inline + functions (ten lines or less in length), then the use of the + object file is unrestricted, regardless of whether it is legally a + derivative work. (Executables containing this object code plus + portions of the Library will still fall under Section 6.) + + Otherwise, if the work is a derivative of the Library, you may + distribute the object code for the work under the terms of Section + 6. Any executables containing that work also fall under Section + 6, whether or not they are linked directly with the Library itself. + + + 6. As an exception to the Sections above, you may also combine or + link a "work that uses the Library" with the Library to produce a + work containing portions of the Library, and distribute that work + under terms of your choice, provided that the terms permit + modification of the work for the customer's own use and reverse + engineering for debugging such modifications. + + You must give prominent notice with each copy of the work that the + Library is used in it and that the Library and its use are covered + by this License. You must supply a copy of this License. If the + work during execution displays copyright notices, you must include + the copyright notice for the Library among them, as well as a + reference directing the user to the copy of this License. Also, + you must do one of these things: + + + a. Accompany the work with the complete corresponding + machine-readable source code for the Library including + whatever changes were used in the work (which must be + distributed under Sections 1 and 2 above); and, if the work + is an executable linked with the Library, with the complete + machine-readable "work that uses the Library", as object code + and/or source code, so that the user can modify the Library + and then relink to produce a modified executable containing + the modified Library. (It is understood that the user who + changes the contents of definitions files in the Library will + not necessarily be able to recompile the application to use + the modified definitions.) + + + b. Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (1) uses at run + time a copy of the library already present on the user's + computer system, rather than copying library functions into + the executable, and (2) will operate properly with a modified + version of the library, if the user installs one, as long as + the modified version is interface-compatible with the version + that the work was made with. + + + c. Accompany the work with a written offer, valid for at least + three years, to give the same user the materials specified in + Subsection 6a, above, for a charge no more than the cost of + performing this distribution. + + + d. If distribution of the work is made by offering access to + copy from a designated place, offer equivalent access to copy + the above specified materials from the same place. + + + e. Verify that the user has already received a copy of these + materials or that you have already sent this user a copy. + + + For an executable, the required form of the "work that uses the + Library" must include any data and utility programs needed for + reproducing the executable from it. However, as a special + exception, the materials to be distributed need not include + anything that is normally distributed (in either source or binary + form) with the major components (compiler, kernel, and so on) of + the operating system on which the executable runs, unless that + component itself accompanies the executable. + + It may happen that this requirement contradicts the license + restrictions of other proprietary libraries that do not normally + accompany the operating system. Such a contradiction means you + cannot use both them and the Library together in an executable + that you distribute. + + + 7. You may place library facilities that are a work based on the + Library side-by-side in a single library together with other + library facilities not covered by this License, and distribute + such a combined library, provided that the separate distribution + of the work based on the Library and of the other library + facilities is otherwise permitted, and provided that you do these + two things: + + + a. Accompany the combined library with a copy of the same work + based on the Library, uncombined with any other library + facilities. This must be distributed under the terms of the + Sections above. + + + b. Give prominent notice with the combined library of the fact + that part of it is a work based on the Library, and + explaining where to find the accompanying uncombined form of + the same work. + + + + 8. You may not copy, modify, sublicense, link with, or distribute the + Library except as expressly provided under this License. Any + attempt otherwise to copy, modify, sublicense, link with, or + distribute the Library is void, and will automatically terminate + your rights under this License. However, parties who have + received copies, or rights, from you under this License will not + have their licenses terminated so long as such parties remain in + full compliance. + + + 9. You are not required to accept this License, since you have not + signed it. However, nothing else grants you permission to modify + or distribute the Library or its derivative works. These actions + are prohibited by law if you do not accept this License. + Therefore, by modifying or distributing the Library (or any work + based on the Library), you indicate your acceptance of this + License to do so, and all its terms and conditions for copying, + distributing or modifying the Library or works based on it. + + + 10. Each time you redistribute the Library (or any work based on the + Library), the recipient automatically receives a license from the + original licensor to copy, distribute, link with or modify the + Library subject to these terms and conditions. You may not impose + any further restrictions on the recipients' exercise of the rights + granted herein. You are not responsible for enforcing compliance + by third parties with this License. + + + 11. If, as a consequence of a court judgment or allegation of patent + infringement or for any other reason (not limited to patent + issues), conditions are imposed on you (whether by court order, + agreement or otherwise) that contradict the conditions of this + License, they do not excuse you from the conditions of this + License. If you cannot distribute so as to satisfy simultaneously + your obligations under this License and any other pertinent + obligations, then as a consequence you may not distribute the + Library at all. For example, if a patent license would not permit + royalty-free redistribution of the Library by all those who + receive copies directly or indirectly through you, then the only + way you could satisfy both it and this License would be to refrain + entirely from distribution of the Library. + + If any portion of this section is held invalid or unenforceable + under any particular circumstance, the balance of the section is + intended to apply, and the section as a whole is intended to apply + in other circumstances. + + It is not the purpose of this section to induce you to infringe any + patents or other property right claims or to contest validity of + any such claims; this section has the sole purpose of protecting + the integrity of the free software distribution system which is + implemented by public license practices. Many people have made + generous contributions to the wide range of software distributed + through that system in reliance on consistent application of that + system; it is up to the author/donor to decide if he or she is + willing to distribute software through any other system and a + licensee cannot impose that choice. + + This section is intended to make thoroughly clear what is believed + to be a consequence of the rest of this License. + + + 12. If the distribution and/or use of the Library is restricted in + certain countries either by patents or by copyrighted interfaces, + the original copyright holder who places the Library under this + License may add an explicit geographical distribution limitation + excluding those countries, so that distribution is permitted only + in or among countries not thus excluded. In such case, this + License incorporates the limitation as if written in the body of + this License. + + + 13. The Free Software Foundation may publish revised and/or new + versions of the Lesser General Public License from time to time. + Such new versions will be similar in spirit to the present + version, but may differ in detail to address new problems or + concerns. + + Each version is given a distinguishing version number. If the + Library specifies a version number of this License which applies + to it and "any later version", you have the option of following + the terms and conditions either of that version or of any later + version published by the Free Software Foundation. If the Library + does not specify a license version number, you may choose any + version ever published by the Free Software Foundation. + + + 14. If you wish to incorporate parts of the Library into other free + programs whose distribution conditions are incompatible with + these, write to the author to ask for permission. For software + which is copyrighted by the Free Software Foundation, write to the + Free Software Foundation; we sometimes make exceptions for this. + Our decision will be guided by the two goals of preserving the + free status of all derivatives of our free software and of + promoting the sharing and reuse of software generally. + + + NO WARRANTY + + 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO + WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE + LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT + HOLDERS AND/OR OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT + WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT + NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE + QUALITY AND PERFORMANCE OF THE LIBRARY IS WITH YOU. SHOULD THE + LIBRARY PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY + SERVICING, REPAIR OR CORRECTION. + + + 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN + WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY + MODIFY AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE + LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, + INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR + INABILITY TO USE THE LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF + DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU + OR THIRD PARTIES OR A FAILURE OF THE LIBRARY TO OPERATE WITH ANY + OTHER SOFTWARE), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN + ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. + + + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Libraries + + If you develop a new library, and you want it to be of the greatest +possible use to the public, we recommend making it free software that +everyone can redistribute and change. You can do so by permitting +redistribution under these terms (or, alternatively, under the terms of +the ordinary General Public License). + + To apply these terms, attach the following notices to the library. +It is safest to attach them to the start of each source file to most +effectively convey the exclusion of warranty; and each file should have +at least the "copyright" line and a pointer to where the full notice is +found. + + +<one line to give the library's name and a brief idea of what it does.> +Copyright (C) <year> <name of author> + +This library is free software; you can redistribute it and/or +modify it under the terms of the GNU Lesser General Public +License as published by the Free Software Foundation; either +version 2 of the License, or (at your option) any later version. + +This library is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with this library; if not, write to the Free Software +Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + + Also add information on how to contact you by electronic and paper +mail. + + You should also get your employer (if you work as a programmer) or +your school, if any, to sign a "copyright disclaimer" for the library, +if necessary. Here is a sample; alter the names: + + +Yoyodyne, Inc., hereby disclaims all copyright interest in the +library `Frob' (a library for tweaking knobs) written by James Random Hacker. + +<signature of Ty Coon>, 1 April 1990 +Ty Coon, President of Vice + + That's all there is to it! + + +File: libconfig.info, Node: Function Index, Next: Type Index, Prev: License, Up: Top + +Function Index +************** + + +* Menu: + +* add on Setting: The C++ API. (line 378) +* Config on Config: The C++ API. (line 43) +* config_destroy: The C API. (line 15) +* config_error_line: The C API. (line 55) +* config_error_text: The C API. (line 54) +* config_get_auto_convert: The C API. (line 65) +* config_init: The C API. (line 14) +* config_lookup: The C API. (line 104) +* config_lookup_bool: The C API. (line 87) +* config_lookup_float: The C API. (line 85) +* config_lookup_int: The C API. (line 81) +* config_lookup_int64: The C API. (line 83) +* config_lookup_string: The C API. (line 89) +* config_read: The C API. (line 26) +* config_read_file: The C API. (line 35) +* config_root_setting: The C API. (line 284) +* config_set_auto_convert: The C API. (line 64) +* config_set_destructor: The C API. (line 378) +* config_setting_add: The C API. (line 251) +* config_setting_get_bool: The C API. (line 118) +* config_setting_get_bool_elem: The C API. (line 217) +* config_setting_get_elem: The C API. (line 203) +* config_setting_get_float: The C API. (line 116) +* config_setting_get_float_elem: The C API. (line 215) +* config_setting_get_format: The C API. (line 177) +* config_setting_get_hook: The C API. (line 368) +* config_setting_get_int: The C API. (line 112) +* config_setting_get_int64: The C API. (line 114) +* config_setting_get_int64_elem: The C API. (line 213) +* config_setting_get_int_elem: The C API. (line 211) +* config_setting_get_member: The C API. (line 196) +* config_setting_get_string: The C API. (line 120) +* config_setting_get_string_elem: The C API. (line 219) +* config_setting_index: The C API. (line 310) +* config_setting_is_aggregate: The C API. (line 343) +* config_setting_is_array: The C API. (line 334) +* config_setting_is_group: The C API. (line 332) +* config_setting_is_list: The C API. (line 336) +* config_setting_is_number: The C API. (line 347) +* config_setting_is_root: The C API. (line 304) +* config_setting_is_scalar: The C API. (line 345) +* config_setting_length: The C API. (line 317) +* config_setting_lookup_bool: The C API. (line 159) +* config_setting_lookup_float: The C API. (line 156) +* config_setting_lookup_int: The C API. (line 150) +* config_setting_lookup_int64: The C API. (line 153) +* config_setting_lookup_string: The C API. (line 162) +* config_setting_name: The C API. (line 290) +* config_setting_parent: The C API. (line 298) +* config_setting_remove: The C API. (line 261) +* config_setting_remove_elem: The C API. (line 272) +* config_setting_set_bool: The C API. (line 137) +* config_setting_set_bool_elem: The C API. (line 236) +* config_setting_set_float: The C API. (line 135) +* config_setting_set_float_elem: The C API. (line 234) +* config_setting_set_format: The C API. (line 179) +* config_setting_set_hook: The C API. (line 366) +* config_setting_set_int: The C API. (line 131) +* config_setting_set_int64: The C API. (line 133) +* config_setting_set_int64_elem: The C API. (line 232) +* config_setting_set_int_elem: The C API. (line 230) +* config_setting_set_string: The C API. (line 139) +* config_setting_set_string_elem: The C API. (line 238) +* config_setting_source_line: The C API. (line 357) +* config_setting_type: The C API. (line 323) +* config_write: The C API. (line 43) +* config_write_file: The C API. (line 48) +* exists on Config: The C++ API. (line 104) +* exists on Setting: The C++ API. (line 479) +* getAutoConvert on Config: The C++ API. (line 77) +* getError on ParseException: The C++ API. (line 67) +* getFormat on Setting: The C++ API. (line 467) +* getIndex on Setting: The C++ API. (line 455) +* getLength on Setting: The C++ API. (line 486) +* getLine on ParseException: The C++ API. (line 68) +* getName on Setting: The C++ API. (line 429) +* getParent on Setting: The C++ API. (line 444) +* getPath on Setting: The C++ API. (line 438) +* getPath on SettingException: The C++ API. (line 35) +* getRoot on Config: The C++ API. (line 92) +* getSourceLine on Setting: The C++ API. (line 507) +* getType on Setting: The C++ API. (line 460) +* isAggregate on Setting: The C++ API. (line 498) +* isArray on Setting: The C++ API. (line 493) +* isGroup on Setting: The C++ API. (line 492) +* isList on Setting: The C++ API. (line 494) +* isNumber on Setting: The C++ API. (line 500) +* isRoot on Setting: The C++ API. (line 450) +* isScalar on Setting: The C++ API. (line 499) +* lookup on Config: The C++ API. (line 97) +* lookupValue on Config: The C++ API. (line 111) +* lookupValue on Setting: The C++ API. (line 298) +* operator bool() on Setting: The C++ API. (line 185) +* operator const char *() on Setting: The C++ API. (line 194) +* operator double() on Setting: The C++ API. (line 193) +* operator float() on Setting: The C++ API. (line 192) +* operator int() on Setting: The C++ API. (line 186) +* operator long long() on Setting: The C++ API. (line 190) +* operator long() on Setting: The C++ API. (line 188) +* operator std::string() on Setting: The C++ API. (line 195) +* operator unsigned int() on Setting: The C++ API. (line 187) +* operator unsigned long long() on Setting: The C++ API. (line 191) +* operator unsigned long() on Setting: The C++ API. (line 189) +* operator= on Setting: The C++ API. (line 257) +* operator[] on Setting: The C++ API. (line 276) +* read on Config: The C++ API. (line 48) +* readFile on Config: The C++ API. (line 56) +* remove on Setting: The C++ API. (line 408) +* setAutoConvert on Config: The C++ API. (line 76) +* setFormat on Setting: The C++ API. (line 468) +* write on Config: The C++ API. (line 49) +* writeFile on Config: The C++ API. (line 57) +* ~Config on Config: The C++ API. (line 44) + + +File: libconfig.info, Node: Type Index, Next: Concept Index, Prev: Function Index, Up: Top + +Type Index +********** + + +* Menu: + +* Config: The C++ API. (line 6) +* config_setting_t: The C API. (line 6) +* config_t: The C API. (line 6) +* ConfigException: The C++ API. (line 13) +* FileIOException: The C++ API. (line 27) +* ParseException: The C++ API. (line 24) +* Setting: The C++ API. (line 6) +* Setting::Format: The C++ API. (line 470) +* Setting::Type: The C++ API. (line 460) +* SettingException: The C++ API. (line 30) +* SettingFormat: The C API. (line 182) +* SettingNameException: The C++ API. (line 21) +* SettingNotFoundException: The C++ API. (line 19) +* SettingTypeException: The C++ API. (line 16) + + +File: libconfig.info, Node: Concept Index, Prev: Type Index, Up: Top + +Concept Index +************* + + +* Menu: + +* aggregate value: The C API. (line 347) +* array: Configuration Files. (line 23) +* comment: Comments. (line 6) +* configuration: Configuration Files. (line 23) +* format: The C API. (line 182) +* group: Configuration Files. (line 23) +* list: Configuration Files. (line 23) +* locale: Internationalization Issues. + (line 14) +* path: Configuration Files. (line 76) +* scalar value: Configuration Files. (line 23) +* setting: Configuration Files. (line 23) +* Unicode: Internationalization Issues. + (line 6) +* UTF-8: Internationalization Issues. + (line 6) +* value: Configuration Files. (line 23) + + + +Tag Table: +Node: Top245 +Node: Introduction511 +Node: Why Another Configuration File Library?1323 +Node: Using the Library from a C Program2399 +Node: Using the Library from a C++ Program2867 +Node: Multithreading Issues3532 +Node: Internationalization Issues5099 +Node: Compiling Using pkg-config6622 +Node: Configuration Files7484 +Node: Settings11311 +Node: Groups11629 +Node: Arrays11903 +Node: Lists12175 +Node: Integer Values12461 +Node: 64-bit Integer Values12925 +Node: Floating Point Values13304 +Node: Boolean Values13761 +Node: String Values14033 +Node: Comments14922 +Node: The C API15802 +Node: The C++ API33339 +Node: Configuration File Grammar55291 +Node: License56588 +Node: Function Index84682 +Node: Type Index93076 +Node: Concept Index94241 + +End Tag Table |