NAME

docs/configuration.pod - Parrot Configuration System

DESCRIPTION

Parrot configuration is broken up into steps. Each step contains several related prompts, probes, or generations. Steps should be mostly of a single type, though some overlap is allowed (for example, allowing a probe to ask the user what to do in an exceptional situation).

The directory config contains subdirectories for each type of step. Each step should consist of exactly one .pl file and any number of supporting .c, .in, etc. files. Any supporting files should be in a folder whose name is the same as the basename of the step's .pl file; for example, if foo.pl uses bar_c.in, bar_c.in should be in a directory called foo; the full path might be config/auto/foo/bar_c.in.

Generally, when adding a new test you should add a new step unless a test clearly belongs in a current step. For example, if we added a new user-configurable type called FOOVAL, you should add the test for its size in config/auto/sizes.pl; however, if you were testing what dynaloading capabilities are available, you should create a new step.

Initialization Steps

Initialization steps are run before any other steps. They do tasks such as preparing the configuration system's data structures and checking the MANIFEST. These will rarely be added; when they are, it usually means that the configuration system is getting significant new capabilities. They're kept in the directory config/init.

Initialization steps usually do not output anything under normal circumstances.

Prompts

Prompts ask the user for some information. These should be used sparingly. A step containing prompts is an interactive step. Interactive steps should be in the config/inter folder.

Interactive steps often include simple probes to determine good guesses of what the user will answer. See "Prompt or Probe?" for more information.

Interactive steps virtually always output something.

Note that, by default, these prompts are turned off. To enable them run Configure.pl with the --ask option.

Probes

Probes are automated tests of some feature of the computer. These should be used wherever a value will not often need to be modified by the user. A step containing probes is an automatic step. Automatic steps should be in the config/auto folder.

Automatic steps usually do not output anything under normal circumstances.

Generations

Generations create files needed after configuration has completed, such as Makefiles and configuration headers. A step containing generations is a generation step. Generation steps should be in the config/gen folder.

Generation steps usually do not output anything under normal circumstances.

Prompt or Probe?

It can sometimes be hard to decide whether a given step should be an automatic or an interactive step. The guiding question is Would a user ever want to change this?, or conversely, Is this something that can be completely determined without user intervention? A step figuring out what the compiler's command is would probably be an interactive step; conversely, a step figuring out if that command is connected to a specific compiler (like gcc) would be an automatic step.

Adding Steps

New steps should be added in one of the three folders mentioned above.

All steps are really modules; they should start with a declaration setting the current package to Configure::Step. Note that there is no file for the Configure::Step package.

They should define the following:

$description: A short descriptive message that should be printed before the step executes. Usually, interactive steps have long, friendly descriptions and other steps have terse descriptions ending in "...".; Some example descriptions:; Note that on non-interactive steps, the text done. will be printed after the description when the step finishes executing; for example, the user will see:
@args: This contains the names of any command-line arguments the step cares about. Command-line arguments are standardized in Configure.pl; this will be described later in more detail.
Configure::Step::runstep(): This is called to actually execute the step. The command-line arguments that your module said it cared about are passed in; they come in the same order as in @args, and any that weren't specified are passed as undef.

The configuration system won't execute your step by default unless it's specifically told to. To do this, edit the Parrot::Configure::RunSteps module's @steps array. Steps are run in the sequence in which they appear in @steps.

Various utility functions for configuration steps are provided by the Parrot::Configure::Step module.

A template for a new step might look like this:

    package Configure::Step;

    use strict;
    use vars qw($description @args);
    use Parrot::Configure::Step;

    $description="<description>";
    @args=qw(<args>);

    sub runstep {
        <code>
    }

Command-line Arguments

Command-line arguments look like /--[-\w]+(=.*)?/; the equals sign separates the name and the value. If the value is omitted, it's assumed to be 1. The options --help and --version are built in to Configure; any others are defined by steps.

If you add a new option, don't forget to add it to this documentation and the --help listing in Configure.pl.

Steps use the @args array to list any options they're interested in. They should be listed without the dashes.

Building Up Configuration Data

The second step is config/init/data.pl, which sets up a Configure::Data package. You get and set configuration system's data by calling methods on this package. The methods are listed below.

Configure::Data->get(keys): Returns the values for the given keys.
Configure::Data->set(key, value, [key, value, ...]): Sets the given keys to the given values.
Configure::Data->add(delim, key, value, [key, value, ...]): Sets the given keys to the given values or appends values delimited by delim to existing keys.
Configure::Data->keys(): Returns a list of all keys.
Configure::Data->dump(): Returns a string that can be evaled by Perl to create a hash representing the configuration system's data.

Special Configuration Items

Some configuration items (mainly prefixes) have a special meaning and handled internally.

i_(\w+) include files: defines or undefs PARROT_HAS_HEADER_XXX in include/parrot/has_header.h
HAS_(\w+) features: defines PARROT_HAS_XXX in include/parrot/has_header.h
TEMP_(\w+) temporary settings: These settings are deleted before lib/Parrot/Config.pm is written. These entries are only used e.g. for Makefile creation.

HISTORY

The Parrot configuration system was created by Brent Dax.

parrotcode: Parrot Configuration System
Contents \| Configuration