Free parse configuration files software for linux

Kernel Configuration Comparison (kccmp) provides a GUI for comparing two Linux kernel ".config" files.
It shows configuration variables with different values in a tabular format. It also shows configuration variables found in only one of the input configuration files.
Building:
kccmp by default requires Qt 3.x. However, by changing one line in kccmp.pro you can build against Qt 4.x. Note that the Qt 4.x build requilres libboost_regex as well.
The standard build is as easy as:
example:
% qmake
% make
Usage
% kccmp /path/to/first/.config path/to/second/.config
example:
% kccmp /usr/src/linux/.config /usr/src/linux/.config.old
Enhancements:
- This release was ported to Qt 3.x.
- The requirement for libboost_regex was removed.
- Building with either Qt 4.x or Qt 3.x is now supported.

Fontconfig is a library for configuring and customizing font access.

Font Configuration Library contains two essential modules, the configuration module which builds an internal configuration from XML files and the matching module which accepts font patterns and returns the nearest matching font.

The configuration module consists of the FcConfig datatype, libexpat and FcConfigParse which walks over an XML tree and ammends a configuration with data found within. From an external perspective, configuration of the library consists of generating a valid XML tree and feeding that to FcConfigParse.

The only other mechanism provided to applications for changing the running configuration is to add fonts and directories to the list of application-provided font files.

The intent is to make font configurations relatively static, and shared by as many applications as possible.

It is hoped that this will lead to more stable font selection when passing names from one application to another. XML was chosen as a configuration file format because it provides a format which is easy for external agents to edit while retaining the correct structure and syntax.

Font configuration is separate from font matching; applications needing to do their own matching can access the available fonts from the library and perform private matching.

The intent is to permit applications to pick and choose appropriate functionality from the library instead of forcing them to choose between this library and a private configuration mechanism.

The hope is that this will ensure that configuration of fonts for all applications can be centralized in one place. Centralizing font configuration will simplify and regularize font installation and customization.

parse_conf library is a simple library for reading scientific initial data from configuration files. Documentation is available below. It is convenient tool that makes reading initial values for your scientific project as easy as even possiable.
It has the same simple interface for C, C++ and FORTRAN users. Please read very short usage instruction placed below.
Installation:
It should not be installed but used with as a part of your own code. Copy files parse_conf.c and parse_conf.h to the directory with your own files and put the line
#include "parse_conf.h"
for C users
and
include "parse_conf_f.inc"
for FORTRAN users
in any file where you use parse_conf. It will work good for any C, C++ and FORTRAN code. Please, read special notice for FORTRAN and C users
TODO:
- write deleter of some special symbols (like =) or add it as a succeder of all fields
- Line of present tags in configuration file (or maybe reserved group)
- Consider the flexibility in group descriptions
- Add a flag for interruption of work if an error occured.
- Write a documentation in texinfo system and add texinfo generation in Makefile
- write emacs mode for pcnf ini files
Enhancements:
- New flag PCNF_DEBUG_OUTPUT_VARNAMES was added.
- Documentation was changed as well.

Mars Simulation Project is a free software Java project to create a simulation of future human settlement of Mars.
The simulation is a multi-agent artificial society set in a detailed virtual world.
XML configuration files allow the user to modify the simulation properties.
The Mars Simulation Projects main window contains the following components:
- Menu Bar
- Search Tool
- Time Tool
- Mars Navigator
- Monitor Tool
- Rover Info Window
- Settlement Info Window
- Person Info Window
- Unit Bar
The Mars Simulation Project can be configured with a number of XML configuration files located in the "conf/" directory. It is recommended that you save a backup copy of a configuration file before modifying it in case there is an error and the simulation cannot read the modified configuration file.
Here are the configuration files you can modify for the simulation. You will need to start a new simulation for any changes to be loaded in.
- buildings.xml
- crops.xml
- landmarks.xml
- malfunctions.xml
- medical.xml
- people.xml
- settlements.xml
- simulation.xml
- vehicles.xml
Enhancements:
- This release includes the new mission tool for viewing, creating, and editing missions as well as plenty of bugfixes.

Simple Config library supports configuration files consisting of simple name-value pairs, similar to the old Windows INI files. A config file can be loaded into memory, queried by item name, modified, and written back out to a file. Configuration items may also be "watched", which causes a user-supplied callback function to be called with the named item is modified
Client code can query the configuration system for named values, set named values, test the type of values (STR, INT, FIX, BOOL, DATE or TIME) and watch values for changes. The system can update the configuration file when the application has changed or added values, even preserving the original format and commens from the input configuration file.
Theres not much to it, at the moment, not even a manpage, so youre on your own as far as using the library. There is a ReadMe file and a makefile, so you can easily build and install the library.
The whole thing took about a week to design, code and test, so its no heroic effort or anything. With a bit more time and energy it could probably be something really spectacular. My main point was that, given the simple problem statement, it was (relatively) trivial to code up a conforming solution.
Enhancements:
- The hashtable code was updated.
- No changes were made to functionality, but it is now more heap-friendly with less heap fragmentation and faster bucket allocation.
- The ground work for automatic table resizing has been laid.

ConfigReader::Simple is a simple configuration file parser.

SYNOPSIS

use ConfigReader::Simple;

# parse one file
$config = ConfigReader::Simple->new("configrc", [qw(Foo Bar Baz Quux)]);

# parse multiple files, in order
$config = ConfigReader::Simple->new_multiple(
Files => [ "global", "configrc" ],
Keys => [qw(Foo Bar Baz Quux)]
);

my @directives = $config->directives;

$config->get( "Foo" );

if( $config->exists( "Bar" ) )
{
print "Bar was in the config filen";
}

# copy an object to play with it separately
my $clone = $config->clone;

# only affects clone
$clone->set( "Foo", "Buster" );

# save the config to a single file
$clone->save( "configrc" )

# save the config to a single file, but only with
# certain directives
$clone->save( "configrc" => [qw(Foo Bar)] )

# save to multiple configuration files
$clone->save(
"configrc" => [qw(Foo Bar)],
"global" => [qw(Baz Quux)],
);

ConfigReader::Simple reads and parses simple configuration files. It is designed to be smaller and simpler than the ConfigReader module and is more suited to simple configuration files.