7. Automated Option Processing

AutoOpts 27.1 is bundled with AutoGen. It is a tool that virtually eliminates the hassle of processing options and keeping man pages, info docs and usage text up to date. This package allows you to specify several program attributes, up to a hundred option types and many option attributes. From this, it then produces all the code necessary to parse and handle the command line and configuration file options, and the documentation that should go with your program as well. All the features notwithstanding, some applications simply have well-established command line interfaces. Even still, those programs may use the configuration file parsing portion of the library. See the "AutoOpts Features" and "Configuration File Format" sections.

7.1 AutoOpts Features

AutoOpts supports option processing; option state saving; and program documentation with innumerable features. Here, we list a few obvious ones and some important ones, but the full list is really defined by all the attributes defined in the Option Definitions section.

POSIX-compliant short (flag) option processing.
GNU-style long options processing. Long options are recognized without case sensitivity, and they may be abbreviated.
Environment variable initializations, See section environment variable presets.
Initialization from configuration files (aka RC or INI files), and saving the option state back into one, See section configuration file presets.
Config files may be partitioned. One config file may be used by several programs by partitioning it with lines containing, "[PROGRAM_NAME]", See section configuration file presets.
Options may be marked as dis-abled with a disablement prefix. Such options may default to either an enabled or a disabled state. You may also provide an enablement prefix, too, e.g., --allow-mumble and --prevent-mumble.
Verify that required options are present between the minimum and maximum number of times on the command line.
Verify that conflicting options do not appear together, and that options that require the presence of other options are, in fact, used in the presence of other options.
Provides a callable routine to parse a text string as if it were from one of the rc/ini/config files, hereafter referred to as a configuration file.
--help and --version are automatically supported. --more-help will page the generated help.
By adding a `doc' and `arg-name' attributes to each option, AutoGen will also be able to produce a man page and the `invoking' section of a texinfo document.
Insert the option processing state into Scheme-defined variables. Thus, Guile based applications that are linked with private main() routines can take advantage of all of AutoOpts' functionality.
Various forms of main procedures can be added to the output, See section Generating main procedures. There are four basic forms:
1. A program that processes the arguments and writes to standard out portable shell commands containing the digested options.
2. A program that will generate portable shell commands to parse the defined options. The expectation is that this result will be copied into a shell script and used there.
3. A "for-each" main that will invoke a named function once for either each non-option argument on the command line or, if there are none, then once for each non-blank, non-comment input line read from stdin.
4. A main procedure of your own design. Its code can be supplied in the option description template or by incorporating another template.
Library suppliers can specify command line options that their client programs will accept. They specify option definitions that get #include-d into the client option definitions and they specify an "anchor" option that has a callback and must be invoked. That will give the library access to the option state for their options.
The generated usage text can be emitted in either AutoOpts standard format (maximizing the information about each option), or GNU-ish normal form. The default form is selected by either specifying or not specifying the gnu-usage attribute (see section Program Information Attributes). This can be overridden by the user himself with the AUTOOPTS_USAGE environment variable. If it exists and is set to the string gnu, it will force GNU-ish style format; if it is set to the string autoopts, it will force AutoOpts standard format; otherwise, it will have no effect.
If you compile with ENABLE_NLS defined and _() defined to a localization function such as gettext(3GNU), then the option processing code will be localizable (see section Internationalizing AutoOpts).
Intermingled option processing. AutoOpts options may be intermingled with command line operands and options processed with other parsing techniques. This is accomplished by setting the allow-errors (see section Program Description Attributes) attribute. When processing reaches a point where optionProcess (see section optionProcess) needs to be called again, the current option can be set with RESTART_OPT(n) (see section RESTART_OPT( n ) - Resume Option Processing) before calling optionProcess.
See: See section Options for Library Code.
library options. An AutoOpt-ed library may export its options for use in an AutoOpt-ed program. This is done by providing an option definition file that client programs #include into their own option definitions. See "AutoOpt-ed Library for AutoOpt-ed Program" (see section AutoOpt-ed Library for AutoOpt-ed Program) for more details.

7.2 AutoOpts Licensing

When AutoGen is installed, the AutoOpts project is installed with it. AutoOpts includes various AutoGen templates and a pair of shared libraries. These libraries may be used under the terms of the GNU Lesser General Public License (LGPL).

One of these libraries (libopts) is needed by programs that are built using AutoOpts generated code. This library is available as a separate "tear-off" source tarball. It is redistributable for use under either of two licenses: The GNU Lesser General Public License ("Lesser" meaning you have greater license with it and may link it into commercial programs), and the advertising-clause-free BSD license. Both of these license terms are incorporated into appropriate COPYING files included with the libopts source tarball. This source may be incorporated into your package with the following simple commands:

rm -rf liboptsliboptslIndex]

7.1 AutoOpts Features

AutoOpts supports option processing; option state saving; and program documentation with innumerable features. Here, we list a few obvious ones and some important ones, but the full list is really defined by all the attributes defined in the Option Definitions section.

POSIX-compliant short (flag) option processing.
GNU-style long options processing. Long options are recognized without case sensitivity, and they may be abbreviated.
Environment variable initializations, See section environment variable presets.
Initialization from configuration files (aka RC or INI files), and saving the option state back into one, See section configuration file presets.
Config files may be partitioned. One config file may be used by several programs by partitioning it with lines containing, "[PROGRAM_NAME]", See section configuration file presets.
Options may be marked as dis-abled with a disablement prefix. Such options may default to either an enabled or a disabled state. You may also provide an enablement prefix, too, e.g., --allow-mumble and --prevent-mumble.
Verify that required options are present between the minimum and maximum number of times on the command line.
Verify that conflicting options do not appear together, and that options that require the presence of other options are, in fact, used in the presence of other options.
Provides a callable routine to parse a text string as if it were from one of the rc/ini/config files, hereafter referred to as a configuration file.
--help and --version are automatically supported. --more-help will page the generated help.
By adding a `doc' and `arg-name' attributes to each option, AutoGen will also be able to produce a man page and the `invoking' section of a texinfo document.
Insert the option processing state into Scheme-defined variables. Thus, Guile based applications that are linked with private main() routines can take advantage of all of AutoOpts' functionality.
Various forms of main procedures can be added to the output, See section Generating main procedures. There are four basic forms:
1. A program that processes the arguments and writes to standard out portable shell commands containing the digested options.
2. A program that will generate portable shell commands to parse the defined options. The expectation is that this result will be copied into a shell script and used there.
3. A "for-each" main that will invoke a named function once for either each non-option argument on the command line or, if there are none, then once for each non-blank, non-comment input line read from stdin.
4. A main procedure of your own design. Its code can be supplied in the option description template or by incorporating another template.
Library suppliers can specify command line options that their client programs will accept. They specify option definitions that get #include-d into the client option definitions and they specify an "anchor" option that has a callback and must be invoked. That will give the library access to the option state for their options.
The generated usage text can be emitted in either AutoOpts standard format (maximizing the information about each option), or GNU-ish normal form. The default form is selected by either specifying or not specifying the gnu-usage attribute (see section Program Information Attributes). This can be overridden by the user himself with the AUTOOPTS_USAGE environment variable. If it exists and is set to the string gnu, it will force GNU-ish style format; if it is set to the string autoopts, it will force AutoOpts standard format; otherwise, it will have no effect.
If you compile with ENABLE_NLS defined and _() defined to a localization function such as gettext(3GNU), then the option processing code will be localizable (see section Internationalizing AutoOpts).
Intermingled option processing. AutoOpts options may be intermingled with command line operands and options processed with other parsing techniques. This is accomplished by setting the allow-errors (see section Program Description Attributes) attribute. When processing reaches a point where optionProcess (see section optionProcess) needs to be called again, the current option can be set with RESTART_OPT(n) (see section RESTART_OPT( n ) - Resume Option Processing) before calling optionProcess.
See: See section Options for Library Code.
library options. An AutoOpt-ed library may export its options for use in an AutoOpt-ed program. This is done by providing an option definition file that client programs #include into their own option definitions. See "AutoOpt-ed Library for AutoOpt-ed Program" (see section AutoOpt-ed Library for AutoOpt-ed Program) for more details.

7.2 AutoOpts Licensing

When AutoGen is installed, the AutoOpts project is installed with it. AutoOpts includes various AutoGen templates and a pair of shared libraries. These libraries may be used under the terms of the GNU Lesser General Public License (LGPL).

One of these libraries (libopts) is needed by programs that are built using AutoOpts generated code. This library is available as a separate "tear-off" source tarball. It is redistributable for use under either of two licenses: The GNU Lesser General Public License ("Lesser" meaning you have greater license with it and may link it into commercial programs), and the advertising-clause-free BSD license. Both of these license terms are incorporated into appropriate COPYING files included with the libopts source tarball. This source may be incorporated into your package with the following simple commands:

rm -rf liboptsliboptslIndex]

7.1 AutoOpts Features

AutoOpts supports option processing; option state saving; and program documentation with innumerable features. Here, we list a few obvious ones and some important ones, but the full list is really defined by all the attributes defined in the Option Definitions section.

POSIX-compliant short (flag) option processing.
GNU-style long options processing. Long options are recognized without case sensitivity, and they may be abbreviated.
Environment variable initializations, See section environment variable presets.
Initialization from configuration files (aka RC or INI files), and saving the option state back into one, See section configuration file presets.
Config files may be partitioned. One config file may be used by several programs by partitioning it with lines containing, "[PROGRAM_NAME]", See section configuration file presets.
Options may be marked as dis-abled with a disablement prefix. Such options may default to either an enabled or a disabled state. You may also provide an enablement prefix, too, e.g., --allow-mumble and --prevent-mumble.
Verify that required options are present between the minimum and maximum number of times on the command line.
Verify that conflicting options do not appear together, and that options that require the presence of other options are, in fact, used in the presence of other options.
Provides a callable routine to parse a text string as if it were from one of the rc/ini/config files, hereafter referred to as a configuration file.
--help and --version are automatically supported. --more-help will page the generated help.
By adding a `doc' and `arg-name' attributes to each option, AutoGen will also be able to produce a man page and the `invoking' section of a texinfo document.
Insert the option processing state into Scheme-defined variables. Thus, Guile based applications that are linked with private main() routines can take advantage of all of AutoOpts' functionality.
Various forms of main procedures can be added to the output, See section Generating main procedures. There are four basic forms:
1. A program that processes the arguments and writes to standard out portable shell commands containing the digested options.
2. A program that will generate portable shell commands to parse the defined options. The expectation is that this result will be copied into a shell script and used there.
3. A "for-each" main that will invoke a named function once for either each non-option argument on the command line or, if there are none, then once for each non-blank, non-comment input line read from stdin.
4. A main procedure of your own design. Its code can be supplied in the option description template or by incorporating another template.
Library suppliers can specify command line options that their client programs will accept. They specify option definitions that get #include-d into the client option definitions and they specify an "anchor" option that has a callback and must be invoked. That will give the library access to the option state for their options.
The generated usage text can be emitted in either AutoOpts standard format (maximizing the information about each option), or GNU-ish normal form. The default form is selected by either specifying or not specifying the gnu-usage attribute (see section Program Information Attributes). This can be overridden by the user himself with the AUTOOPTS_USAGE environment variable. If it exists and is set to the string gnu, it will force GNU-ish style format; if it is set to the string autoopts, it will force AutoOpts standard format; otherwise, it will have no effect.
If you compile with ENABLE_NLS defined and _() defined to a localization function such as gettext(3GNU), then the option processing code will be localizable (see section Internationalizing AutoOpts).
Intermingled option processing. AutoOpts options may be intermingled with command line operands and options processed with other parsing techniques. This is accomplished by setting the allow-errors (see section Program Description Attributes) attribute. When processing reaches a point where optionProcess (see section optionProcess) needs to be called again, the current option can be set with RESTART_OPT(n) (see section RESTART_OPT( n ) - Resume Option Processing) before calling optionProcess.
See: See section Options for Library Code.
library options. An AutoOpt-ed library may export its options for use in an AutoOpt-ed program. This is done by providing an option definition file that client programs #include into their own option definitions. See "AutoOpt-ed Library for AutoOpt-ed Program" (see section AutoOpt-ed Library for AutoOpt-ed Program) for more details.

7.2 AutoOpts Licensing

When AutoGen is installed, the AutoOpts project is installed with it. AutoOpts includes various AutoGen templates and a pair of shared libraries. These libraries may be used under the terms of the GNU Lesser General Public License (LGPL).

One of these libraries (libopts) is needed by programs that are built using AutoOpts generated code. This library is available as a separate "tear-off" source tarball. It is redistributable for use under either of two licenses: The GNU Lesser General Public License ("Lesser" meaning you have greater license with it and may link it into commercial programs), and the advertising-clause-free BSD license. Both of these license terms are incorporated into appropriate COPYING files included with the libopts source tarball. This source may be incorporated into your package with the following simple commands:

rm -rf liboptsliboptslIndex]

7.1 AutoOpts Features

AutoOpts supports option processing; option state saving; and program documentation with innumerable features. Here, we list a few obvious ones and some important ones, but the full list is really defined by all the attributes defined in the Option Definitions section.

POSIX-compliant short (flag) option processing.
GNU-style long options processing. Long options are recognized without case sensitivity, and they may be abbreviated.
Environment variable initializations, See section environment variable presets.
Initialization from configuration files (aka RC or INI files), and saving the option state back into one, See section configuration file presets.
Config files may be partitioned. One config file may be used by several programs by partitioning it with lines containing, "[PROGRAM_NAME]", See section configuration file presets.
Options may be marked as dis-abled with a disablement prefix. Such options may default to either an enabled or a disabled state. You may also provide an enablement prefix, too, e.g., --allow-mumble and --prevent-mumble.
Verify that required options are present between the minimum and maximum number of times on the command line.
Verify that conflicting options do not appear together, and that options that require the presence of other options are, in fact, used in the presence of other options.
Provides a callable routine to parse a text string as if it were from one of the rc/ini/config files, hereafter referred to as a configuration file.
--help and --version are automatically supported. --more-help will page the generated help.
By adding a `doc' and `arg-name' attributes to each option, AutoGen will also be able to produce a man page and the `invoking' section of a texinfo document.
Insert the option processing state into Scheme-defined variables. Thus, Guile based applications that are linked with private main() routines can take advantage of all of AutoOpts' functionality.
Various forms of main procedures can be added to the output, See section Generating main procedures. There are four basic forms:
1. A program that processes the arguments and writes to standard out portable shell commands containing the digested options.
2. A program that will generate portable shell commands to parse the defined options. The expectation is that this result will be copied into a shell script and used there.
3. A "for-each" main that will invoke a named function once for either each non-option argument on the command line or, if there are none, then once for each non-blank, non-comment input line read from stdin.
4. A main procedure of your own design. Its code can be supplied in the option description template or by incorporating another template.
Library suppliers can specify command line options that their client programs will accept. They specify option definitions that get #include-d into the client option definitions and they specify an "anchor" option that has a callback and must be invoked. That will give the library access to the option state for their options.
The generated usage text can be emitted in either AutoOpts standard format (maximizing the information about each option), or GNU-ish normal form. The default form is selected by either specifying or not specifying the gnu-usage attribute (see section Program Information Attributes). This can be overridden by the user himself with the AUTOOPTS_USAGE environment variable. If it exists and is set to the string gnu, it will force GNU-ish style format; if it is set to the string autoopts, it will force AutoOpts standard format; otherwise, it will have no effect.
If you compile with ENABLE_NLS defined and _() defined to a localization function such as gettext(3GNU), then the option processing code will be localizable (see section Internationalizing AutoOpts).
Intermingled option processing. AutoOpts options may be intermingled with command line operands and options processed with other parsing techniques. This is accomplished by setting the allow-errors (see section Program Description Attributes) attribute. When processing reaches a point where optionProcess (see section optionProcess) needs to be called again, the current option can be set with RESTART_OPT(n) (see section RESTART_OPT( n ) - Resume Option Processing) before calling optionProcess.
See: See section Options for Library Code.
library options. An AutoOpt-ed library may export its options for use in an AutoOpt-ed program. This is done by providing an option definition file that client programs #include into their own option definitions. See "AutoOpt-ed Library for AutoOpt-ed Program" (see section AutoOpt-ed Library for AutoOpt-ed Program) for more details.

7.2 AutoOpts Licensing

When AutoGen is installed, the AutoOpts project is installed with it. AutoOpts includes various AutoGen templates and a pair of shared libraries. These libraries may be used under the terms of the GNU Lesser General Public License (LGPL).

One of these libraries (libopts) is needed by programs that are built using AutoOpts generated code. This library is available as a separate "tear-off" source tarball. It is redistributable for use under either of two licenses: The GNU Lesser General Public License ("Lesser" meaning you have greater license with it and may link it into commercial programs), and the advertising-clause-free BSD license. Both of these license terms are incorporated into appropriate COPYING files included with the libopts source tarball. This source may be incorporated into your package with the following simple commands:

rm -rf liboptsliboptslIndex]

7.1 AutoOpts Features

AutoOpts supports option processing; option state saving; and program documentation with innumerable features. Here, we list a few obvious ones and some important ones, but the full list is really defined by all the attributes defined in the Option Definitions section.

POSIX-compliant short (flag) option processing.
GNU-style long options processing. Long options are recognized without case sensitivity, and they may be abbreviated.
Environment variable initializations, See section environment variable presets.
Initialization from configuration files (aka RC or INI files), and saving the option state back into one, See section configuration file presets.
Config files may be partitioned. One config file may be used by several programs by partitioning it with lines containing, "[PROGRAM_NAME]", See section configuration file presets.
Options may be marked as dis-abled with a disablement prefix. Such options may default to either an enabled or a disabled state. You may also provide an enablement prefix, too, e.g., --allow-mumble and --prevent-mumble.
Verify that required options are present between the minimum and maximum number of times on the command line.
Verify that conflicting options do not appear together, and that options that require the presence of other options are, in fact, used in the presence of other options.
Provides a callable routine to parse a text string as if it were from one of the rc/ini/config files, hereafter referred to as a configuration file.
--help and --version are automatically supported. --more-help will page the generated help.
By adding a `doc' and `arg-name' attributes to each option, AutoGen will also be able to produce a man page and the `invoking' section of a texinfo document.
Insert the option processing state into Scheme-defined variables. Thus, Guile based applications that are linked with private main() routines can take advantage of all of AutoOpts' functionality.
Various forms of main procedures can be added to the output, See section Generating main procedures. There are four basic forms:
1. A program that processes the arguments and writes to standard out portable shell commands containing the digested options.
2. A program that will generate portable shell commands to parse the defined options. The expectation is that this result will be copied into a shell script and used there.
3. A "for-each" main that will invoke a named function once for either each non-option argument on the command line or, if there are none, then once for each non-blank, non-comment input line read from stdin.
4. A main procedure of your own design. Its code can be supplied in the option description template or by incorporating another template.
Library suppliers can specify command line options that their client programs will accept. They specify option definitions that get #include-d into the client option definitions and they specify an "anchor" option that has a callback and must be invoked. That will give the library access to the option state for their options.
The generated usage text can be emitted in either AutoOpts standard format (maximizing the information about each option), or GNU-ish normal form. The default form is selected by either specifying or not specifying the gnu-usage attribute (see section Program Information Attributes). This can be overridden by the user himself with the AUTOOPTS_USAGE environment variable. If it exists and is set to the string gnu, it will force GNU-ish style format; if it is set to the string autoopts, it will force AutoOpts standard format; otherwise, it will have no effect.
If you compile with ENABLE_NLS defined and _() defined to a localization function such as gettext(3GNU), then the option processing code will be localizable (see section Internationalizing AutoOpts).
Intermingled option processing. AutoOpts options may be intermingled with command line operands and options processed with other parsing techniques. This is accomplished by setting the allow-errors (see section Program Description Attributes) attribute. When processing reaches a point where optionProcess (see section optionProcess) needs to be called again, the current option can be set with RESTART_OPT(n) (see section RESTART_OPT( n ) - Resume Option Processing) before calling optionProcess.
See: See section Options for Library Code.
library options. An AutoOpt-ed library may export its options for use in an AutoOpt-ed program. This is done by providing an option definition file that client programs #include into their own option definitions. See "AutoOpt-ed Library for AutoOpt-ed Program" (see section AutoOpt-ed Library for AutoOpt-ed Program) for more details.

7.2 AutoOpts Licensing

When AutoGen is installed, the AutoOpts project is installed with it. AutoOpts includes various AutoGen templates and a pair of shared libraries. These libraries may be used under the terms of the GNU Lesser General Public License (LGPL).

One of these libraries (libopts) is needed by programs that are built using AutoOpts generated code. This library is available as a separate "tear-off" source tarball. It is redistributable for use under either of two licenses: The GNU Lesser General Public License ("Lesser" meaning you have greater license with it and may link it into commercial programs), and the advertising-clause-free BSD license. Both of these license terms are incorporated into appropriate COPYING files included with the libopts source tarball. This source may be incorporated into your package with the following simple commands:

rm -rf liboptsliboptslIndex]

7.1 AutoOpts Features

AutoOpts supports option processing; option state saving; and program documentation with innumerable features. Here, we list a few obvious ones and some important ones, but the full list is really defined by all the attributes defined in the Option Definitions section.

POSIX-compliant short (flag) option processing.
GNU-style long options processing. Long options are recognized without case sensitivity, and they may be abbreviated.
Environment variable initializations, See section environment variable presets.
Initialization from configuration files (aka RC or INI files), and saving the option state back into one, See section configuration file presets.
Config files may be partitioned. One config file may be used by several programs by partitioning it with lines containing, "[PROGRAM_NAME]", See section configuration file presets.
Options may be marked as dis-abled with a disablement prefix. Such options may default to either an enabled or a disabled state. You may also provide an enablement prefix, too, e.g., --allow-mumble and --prevent-mumble.
Verify that required options are present between the minimum and maximum number of times on the command line.
Verify that conflicting options do not appear together, and that options that require the presence of other options are, in fact, used in the presence of other options.
Provides a callable routine to parse a text string as if it were from one of the rc/ini/config files, hereafter referred to as a configuration file.
--help and --version are automatically supported. --more-help will page the generated help.
By adding a `doc' and `arg-name' attributes to each option, AutoGen will also be able to produce a man page and the `invoking' section of a texinfo document.
Insert the option processing state into Scheme-defined variables. Thus, Guile based applications that are linked with private main() routines can take advantage of all of AutoOpts' functionality.
Various forms of main procedures can be added to the output, See section Generating main procedures. There are four basic forms:
1. A program that processes the arguments and writes to standard out portable shell commands containing the digested options.
2. A program that will generate portable shell commands to parse the defined options. The expectation is that this result will be copied into a shell script and used there.
3. A "for-each" main that will invoke a named function once for either each non-option argument on the command line or, if there are none, then once for each non-blank, non-comment input line read from stdin.
4. A main procedure of your own design. Its code can be supplied in the option description template or by incorporating another template.
Library suppliers can specify command line options that their client programs will accept. They specify option definitions that get #include-d into the client option definitions and they specify an "anchor" option that has a callback and must be invoked. That will give the library access to the option state for their options.
The generated usage text can be emitted in either AutoOpts standard format (maximizing the information about each option), or GNU-ish normal form. The default form is selected by either specifying or not specifying the gnu-usage attribute (see section Program Information Attributes). This can be overridden by the user himself with the AUTOOPTS_USAGE environment variable. If it exists and is set to the string gnu, it will force GNU-ish style format; if it is set to the string autoopts, it will force AutoOpts standard format; otherwise, it will have no effect.
If you compile with ENABLE_NLS defined and _() defined to a localization function such as gettext(3GNU), then the option processing code will be localizable (see section Internationalizing AutoOpts).
Intermingled option processing. AutoOpts options may be intermingled with command line operands and options processed with other parsing techniques. This is accomplished by setting the allow-errors (see section Program Description Attributes) attribute. When processing reaches a point where optionProcess (see section optionProcess) needs to be called again, the current option can be set with RESTART_OPT(n) (see section RESTART_OPT( n ) - Resume Option Processing) before calling optionProcess.
See: See section Options for Library Code.
library options. An AutoOpt-ed library may export its options for use in an AutoOpt-ed program. This is done by providing an option definition file that client programs #include into their own option definitions. See "AutoOpt-ed Library for AutoOpt-ed Program" (see section AutoOpt-ed Library for AutoOpt-ed Program) for more details.

7.2 AutoOpts Licensing

When AutoGen is installed, the AutoOpts project is installed with it. AutoOpts includes various AutoGen templates and a pair of shared libraries. These libraries may be used under the terms of the GNU Lesser General Public License (LGPL).

One of these libraries (libopts) is needed by programs that are built using AutoOpts generated code. This library is available as a separate "tear-off" source tarball. It is redistributable for use under either of two licenses: The GNU Lesser General Public License ("Lesser" meaning you have greater license with it and may link it into commercial programs), and the advertising-clause-free BSD license. Both of these license terms are incorporated into appropriate COPYING files included with the libopts source tarball. This source may be incorporated into your package with the following simple commands:

rm -rf liboptsliboptslIndex]

7.1 AutoOpts Features

AutoOpts supports option processing; option state saving; and program documentation with innumerable features. Here, we list a few obvious ones and some important ones, but the full list is really defined by all the attributes defined in the Option Definitions section.

POSIX-compliant short (flag) option processing.
GNU-style long options processing. Long options are recognized without case sensitivity, and they may be abbreviated.
Environment variable initializations, See section environment variable presets.
Initialization from configuration files (aka RC or INI files), and saving the option state back into one, See section configuration file presets.
Config files may be partitioned. One config file may be used by several programs by partitioning it with lines containing, "[PROGRAM_NAME]", See section configuration file presets.
Options may be marked as dis-abled with a disablement prefix. Such options may default to either an enabled or a disabled state. You may also provide an enablement prefix, too, e.g., --allow-mumble and --prevent-mumble.
Verify that required options are present between the minimum and maximum number of times on the command line.
Verify that conflicting options do not appear together, and that options that require the presence of other options are, in fact, used in the presence of other options.
Provides a callable routine to parse a text string as if it were from one of the rc/ini/config files, hereafter referred to as a configuration file.
--help and --version are automatically supported. --more-help will page the generated help.
By adding a `doc' and `arg-name' attributes to each option, AutoGen will also be able to produce a man page and the `invoking' section of a texinfo document.
Insert the option processing state into Scheme-defined variables. Thus, Guile based applications that are linked with private main() routines can take advantage of all of AutoOpts' functionality.
Various forms of main procedures can be added to the output, See section Generating main procedures. There are four basic forms:
1. A program that processes the arguments and writes to standard out portable shell commands containing the digested options.
2. A program that will generate portable shell commands to parse the defined options. The expectation is that this result will be copied into a shell script and used there.
3. A "for-each" main that will invoke a named function once for either each non-option argument on the command line or, if there are none, then once for each non-blank, non-comment input line read from stdin.
4. A main procedure of your own design. Its code can be supplied in the option description template or by incorporating another template.
Library suppliers can specify command line options that their client programs will accept. They specify option definitions that get #include-d into the client option definitions and they specify an "anchor" option that has a callback and must be invoked. That will give the library access to the option state for their options.
The generated usage text can be emitted in either AutoOpts standard format (maximizing the information about each option), or GNU-ish normal form. The default form is selected by either specifying or not specifying the gnu-usage attribute (see section Program Information Attributes). This can be overridden by the user himself with the AUTOOPTS_USAGE environment variable. If it exists and is set to the string gnu, it will force GNU-ish style format; if it is set to the string autoopts, it will force AutoOpts standard format; otherwise, it will have no effect.
If you compile with ENABLE_NLS defined and _() defined to a localization function such as gettext(3GNU), then the option processing code will be localizable (see section Internationalizing AutoOpts).
Intermingled option processing. AutoOpts options may be intermingled with command line operands and options processed with other parsing techniques. This is accomplished by setting the allow-errors (see section Program Description Attributes) attribute. When processing reaches a point where optionProcess (see section optionProcess) needs to be called again, the current option can be set with RESTART_OPT(n) (see section RESTART_OPT( n ) - Resume Option Processing) before calling optionProcess.
See: See section Options for Library Code.
library options. An AutoOpt-ed library may export its options for use in an AutoOpt-ed program. This is done by providing an option definition file that client programs #include into their own option definitions. See "AutoOpt-ed Library for AutoOpt-ed Program" (see section AutoOpt-ed Library for AutoOpt-ed Program) for more details.

7.2 AutoOpts Licensing

When AutoGen is installed, the AutoOpts project is installed with it. AutoOpts includes various AutoGen templates and a pair of shared libraries. These libraries may be used under the terms of the GNU Lesser General Public License (LGPL).

One of these libraries (libopts) is needed by programs that are built using AutoOpts generated code. This library is available as a separate "tear-off" source tarball. It is redistributable for use under either of two licenses: The GNU Lesser General Public License ("Lesser" meaning you have greater license with it and may link it into commercial programs), and the advertising-clause-free BSD license. Both of these license terms are incorporated into appropriate COPYING files included with the libopts source tarball. This source may be incorporated into your package with the following simple commands:

rm -rf liboptsliboptslIndex]

7.1 AutoOpts Features

AutoOpts supports option processing; option state saving; and program documentation with innumerable features. Here, we list a few obvious ones and some important ones, but the full list is really defined by all the attributes defined in the Option Definitions section.

POSIX-compliant short (flag) option processing.
GNU-style long options processing. Long options are recognized without case sensitivity, and they may be abbreviated.
Environment variable initializations, See section environment variable presets.
Initialization from configuration files (aka RC or INI files), and saving the option state back into one, See section configuration file presets.
Config files may be partitioned. One config file may be used by several programs by partitioning it with lines containing, "[PROGRAM_NAME]", See section configuration file presets.
Options may be marked as dis-abled with a disablement prefix. Such options may default to either an enabled or a disabled state. You may also provide an enablement prefix, too, e.g., --allow-mumble and --prevent-mumble.
Verify that required options are present between the minimum and maximum number of times on the command line.
Verify that conflicting options do not appear together, and that options that require the presence of other options are, in fact, used in the presence of other options.
Provides a callable routine to parse a text string as if it were from one of the rc/ini/config files, hereafter referred to as a configuration file.
--help and --version are automatically supported. --more-help will page the generated help.
By adding a `doc' and `arg-name' attributes to each option, AutoGen will also be able to produce a man page and the `invoking' section of a texinfo document.
Insert the option processing state into Scheme-defined variables. Thus, Guile based applications that are linked with private main() routines can take advantage of all of AutoOpts' functionality.
Various forms of main procedures can be added to the output, See section Generating main procedures. There are four basic forms:
1. A program that processes the arguments and writes to standard out portable shell commands containing the digested options.
2. A program that will generate portable shell commands to parse the defined options. The expectation is that this result will be copied into a shell script and used there.
3. A "for-each" main that will invoke a named function once for either each non-option argument on the command line or, if there are none, then once for each non-blank, non-comment input line read from stdin.
4. A main procedure of your own design. Its code can be supplied in the option description template or by incorporating another template.
Library suppliers can specify command line options that their client programs will accept. They specify option definitions that get #include-d into the client option definitions and they specify an "anchor" option that has a callback and must be invoked. That will give the library access to the option state for their options.
The generated usage text can be emitted in either AutoOpts standard format (maximizing the information about each option), or GNU-ish normal form. The default form is selected by either specifying or not specifying the gnu-usage attribute (see section Program Information Attributes). This can be overridden by the user himself with the AUTOOPTS_USAGE environment variable. If it exists and is set to the string gnu, it will force GNU-ish style format; if it is set to the string autoopts, it will force AutoOpts standard format; otherwise, it will have no effect.
If you compile with ENABLE_NLS defined and _() defined to a localization function such as gettext(3GNU), then the option processing code will be localizable (see section Internationalizing AutoOpts).
Intermingled option processing. AutoOpts options may be intermingled with command line operands and options processed with other parsing techniques. This is accomplished by setting the allow-errors (see section Program Description Attributes) attribute. When processing reaches a point where optionProcess (see section optionProcess) needs to be called again, the current option can be set with RESTART_OPT(n) (see section RESTART_OPT( n ) - Resume Option Processing) before calling optionProcess.
See: See section Options for Library Code.
library options. An AutoOpt-ed library may export its options for use in an AutoOpt-ed program. This is done by providing an option definition file that client programs #include into their own option definitions. See "AutoOpt-ed Library for AutoOpt-ed Program" (see section AutoOpt-ed Library for AutoOpt-ed Program) for more details.

7.2 AutoOpts Licensing

When AutoGen is installed, the AutoOpts project is installed with it. AutoOpts includes various AutoGen templates and a pair of shared libraries. These libraries may be used under the terms of the GNU Lesser General Public License (LGPL).

One of these libraries (libopts) is needed by programs that are built using AutoOpts generated code. This library is available as a separate "tear-off" source tarball. It is redistributable for use under either of two licenses: The GNU Lesser General Public License ("Lesser" meaning you have greater license with it and may link it into commercial programs), and the advertising-clause-free BSD license. Both of these license terms are incorporated into appropriate COPYING files included with the libopts source tarball. This source may be incorporated into your package with the following simple commands:

rm -rf liboptsliboptslIndex]

7.1 AutoOpts Features

AutoOpts supports option processing; option state saving; and program documentation with innumerable features. Here, we list a few obvious ones and some important ones, but the full list is really defined by all the attributes defined in the Option Definitions section.

POSIX-compliant short (flag) option processing.
GNU-style long options processing. Long options are recognized without case sensitivity, and they may be abbreviated.
Environment variable initializations, See section environment variable presets.
Initialization from configuration files (aka RC or INI files), and saving the option state back into one, See section configuration file presets.
Config files may be partitioned. One config file may be used by several programs by partitioning it with lines containing, "[PROGRAM_NAME]", See section configuration file presets.
Options may be marked as dis-abled with a disablement prefix. Such options may default to either an enabled or a disabled state. You may also provide an enablement prefix, too, e.g., --allow-mumble and --prevent-mumble.
Verify that required options are present between the minimum and maximum number of times on the command line.
Verify that conflicting options do not appear together, and that options that require the presence of other options are, in fact, used in the presence of other options.
Provides a callable routine to parse a text string as if it were from one of the rc/ini/config files, hereafter referred to as a configuration file.
--help and --version are automatically supported. --more-help will page the generated help.
By adding a `doc' and `arg-name' attributes to each option, AutoGen will also be able to produce a man page and the `invoking' section of a texinfo document.
Insert the option processing state into Scheme-defined variables. Thus, Guile based applications that are linked with private main() routines can take advantage of all of AutoOpts' functionality.
Various forms of main procedures can be added to the output, See section Generating main procedures. There are four basic forms:
1. A program that processes the arguments and writes to standard out portable shell commands containing the digested options.
2. A program that will generate portable shell commands to parse the defined options. The expectation is that this result will be copied into a shell script and used there.
3. A "for-each" main that will invoke a named function once for either each non-option argument on the command line or, if there are none, then once for each non-blank, non-comment input line read from stdin.
4. A main procedure of your own design. Its code can be supplied in the option description template or by incorporating another template.
Library suppliers can specify command line options that their client programs will accept. They specify option definitions that get #include-d into the client option definitions and they specify an "anchor" option that has a callback and must be invoked. That will give the library access to the option state for their options.
The generated usage text can be emitted in either AutoOpts standard format (maximizing the information about each option), or GNU-ish normal form. The default form is selected by either specifying or not specifying the gnu-usage attribute (see section Program Information Attributes). This can be overridden by the user himself with the AUTOOPTS_USAGE environment variable. If it exists and is set to the string gnu, it will force GNU-ish style format; if it is set to the string autoopts, it will force AutoOpts standard format; otherwise, it will have no effect.
If you compile with ENABLE_NLS defined and _() defined to a localization function such as gettext(3GNU), then the option processing code will be localizable (see section Internationalizing AutoOpts).
Intermingled option processing. AutoOpts options may be intermingled with command line operands and options processed with other parsing techniques. This is accomplished by setting the allow-errors (see section Program Description Attributes) attribute. When processing reaches a point where optionProcess (see section optionProcess) needs to be called again, the current option can be set with RESTART_OPT(n) (see section RESTART_OPT( n ) - Resume Option Processing) before calling optionProcess.
See: See section Options for Library Code.
library options. An AutoOpt-ed library may export its options for use in an AutoOpt-ed program. This is done by providing an option definition file that client programs #include into their own option definitions. See "AutoOpt-ed Library for AutoOpt-ed Program" (see section AutoOpt-ed Library for AutoOpt-ed Program) for more details.

7.2 AutoOpts Licensing

When AutoGen is installed, the AutoOpts project is installed with it. AutoOpts includes various AutoGen templates and a pair of shared libraries. These libraries may be used under the terms of the GNU Lesser General Public License (LGPL).

One of these libraries (libopts) is needed by programs that are built using AutoOpts generated code. This library is available as a separate "tear-off" source tarball. It is redistributable for use under either of two licenses: The GNU Lesser General Public License ("Lesser" meaning you have greater license with it and may link it into commercial programs), and the advertising-clause-free BSD license. Both of these license terms are incorporated into appropriate COPYING files included with the libopts source tarball. This source may be incorporated into your package with the following simple commands:

rm -rf liboptsliboptslIndex]

7.1 AutoOpts Features

AutoOpts supports option processing; option state saving; and program documentation with innumerable features. Here, we list a few obvious ones and some important ones, but the full list is really defined by all the attributes defined in the Option Definitions section.

POSIX-compliant short (flag) option processing.
GNU-style long options processing. Long options are recognized without case sensitivity, and they may be abbreviated.
Environment variable initializations, See section environment variable presets.
Initialization from configuration files (aka RC or INI files), and saving the option state back into one, See section configuration file presets.
Config files may be partitioned. One config file may be used by several programs by partitioning it with lines containing, "[PROGRAM_NAME]", See section configuration file presets.
Options may be marked as dis-abled with a disablement prefix. Such options may default to either an enabled or a disabled state. You may also provide an enablement prefix, too, e.g., --allow-mumble and --prevent-mumble.
Verify that required options are present between the minimum and maximum number of times on the command line.
Verify that conflicting options do not appear together, and that options that require the presence of other options are, in fact, used in the presence of other options.
Provides a callable routine to parse a text string as if it were from one of the rc/ini/config files, hereafter referred to as a configuration file.
--help and --version are automatically supported. --more-help will page the generated help.
By adding a `doc' and `arg-name' attributes to each option, AutoGen will also be able to produce a man page and the `invoking' section of a texinfo document.
Insert the option processing state into Scheme-defined variables. Thus, Guile based applications that are linked with private main() routines can take advantage of all of AutoOpts' functionality.
Various forms of main procedures can be added to the output, See section Generating main procedures. There are four basic forms:
1. A program that processes the arguments and writes to standard out portable shell commands containing the digested options.
2. A program that will generate portable shell commands to parse the defined options. The expectation is that this result will be copied into a shell script and used there.
3. A "for-each" main that will invoke a named function once for either each non-option argument on the command line or, if there are none, then once for each non-blank, non-comment input line read from stdin.
4. A main procedure of your own design. Its code can be supplied in the option description template or by incorporating another template.
Library suppliers can specify command line options that their client programs will accept. They specify option definitions that get #include-d into the client option definitions and they specify an "anchor" option that has a callback and must be invoked. That will give the library access to the option state for their options.
The generated usage text can be emitted in either AutoOpts standard format (maximizing the information about each option), or GNU-ish normal form. The default form is selected by either specifying or not specifying the gnu-usage attribute (see section Program Information Attributes). This can be overridden by the user himself with the AUTOOPTS_USAGE environment variable. If it exists and is set to the string gnu, it will force GNU-ish style format; if it is set to the string autoopts, it will force AutoOpts standard format; otherwise, it will have no effect.
If you compile with ENABLE_NLS defined and _() defined to a localization function such as gettext(3GNU), then the option processing code will be localizable (see section Internationalizing AutoOpts).
Intermingled option processing. AutoOpts options may be intermingled with command line operands and options processed with other parsing techniques. This is accomplished by setting the allow-errors (see section Program Description Attributes) attribute. When processing reaches a point where optionProcess (see section optionProcess) needs to be called again, the current option can be set with RESTART_OPT(n) (see section RESTART_OPT( n ) - Resume Option Processing) before calling optionProcess.
See: See section Options for Library Code.
library options. An AutoOpt-ed library may export its options for use in an AutoOpt-ed program. This is done by providing an option definition file that client programs #include into their own option definitions. See "AutoOpt-ed Library for AutoOpt-ed Program" (see section AutoOpt-ed Library for AutoOpt-ed Program) for more details.

7.2 AutoOpts Licensing

When AutoGen is installed, the AutoOpts project is installed with it. AutoOpts includes various AutoGen templates and a pair of shared libraries. These libraries may be used under the terms of the GNU Lesser General Public License (LGPL).

One of these libraries (libopts) is needed by programs that are built using AutoOpts generated code. This library is available as a separate "tear-off" source tarball. It is redistributable for use under either of two licenses: The GNU Lesser General Public License ("Lesser" meaning you have greater license with it and may link it into commercial programs), and the advertising-clause-free BSD license. Both of these license terms are incorporated into appropriate COPYING files included with the libopts source tarball. This source may be incorporated into your package with the following simple commands:

rm -rf liboptsliboptslIndex]

7.1 AutoOpts Features

AutoOpts supports option processing; option state saving; and program documentation with innumerable features. Here, we list a few obvious ones and some important ones, but the full list is really defined by all the attributes defined in the Option Definitions section.

POSIX-compliant short (flag) option processing.
GNU-style long options processing. Long options are recognized without case sensitivity, and they may be abbreviated.
Environment variable initializations, See section environment variable presets.
Initialization from configuration files (aka RC or INI files), and saving the option state back into one, See section configuration file presets.
Config files may be partitioned. One config file may be used by several programs by partitioning it with lines containing, "[PROGRAM_NAME]", See section configuration file presets.
Options may be marked as dis-abled with a disablement prefix. Such options may default to either an enabled or a disabled state. You may also provide an enablement prefix, too, e.g., --allow-mumble and --prevent-mumble.
Verify that required options are present between the minimum and maximum number of times on the command line.
Verify that conflicting options do not appear together, and that options that require the presence of other options are, in fact, used in the presence of other options.
Provides a callable routine to parse a text string as if it were from one of the rc/ini/config files, hereafter referred to as a configuration file.
--help and --version are automatically supported. --more-help will page the generated help.
By adding a `doc' and `arg-name' attributes to each option, AutoGen will also be able to produce a man page and the `invoking' section of a texinfo document.
Insert the option processing state into Scheme-defined variables. Thus, Guile based applications that are linked with private main() routines can take advantage of all of AutoOpts' functionality.
Various forms of main procedures can be added to the output, See section Generating main procedures. There are four basic forms:
1. A program that processes the arguments and writes to standard out portable shell commands containing the digested options.
2. A program that will generate portable shell commands to parse the defined options. The expectation is that this result will be copied into a shell script and used there.
3. A "for-each" main that will invoke a named function once for either each non-option argument on the command line or, if there are none, then once for each non-blank, non-comment input line read from stdin.
4. A main procedure of your own design. Its code can be supplied in the option description template or by incorporating another template.
Library suppliers can specify command line options that their client programs will accept. They specify option definitions that get #include-d into the client option definitions and they specify an "anchor" option that has a callback and must be invoked. That will give the library access to the option state for their options.
The generated usage text can be emitted in either AutoOpts standard format (maximizing the information about each option), or GNU-ish normal form. The default form is selected by either specifying or not specifying the gnu-usage attribute (see section Program Information Attributes). This can be overridden by the user himself with the AUTOOPTS_USAGE environment variable. If it exists and is set to the string gnu, it will force GNU-ish style format; if it is set to the string autoopts, it will force AutoOpts standard format; otherwise, it will have no effect.
If you compile with ENABLE_NLS defined and _() defined to a localization function such as gettext(3GNU), then the option processing code will be localizable (see section Internationalizing AutoOpts).
Intermingled option processing. AutoOpts options may be intermingled with command line operands and options processed with other parsing techniques. This is accomplished by setting the allow-errors (see section Program Description Attributes) attribute. When processing reaches a point where optionProcess (see section optionProcess) needs to be called again, the current option can be set with RESTART_OPT(n) (see section RESTART_OPT( n ) - Resume Option Processing) before calling optionProcess.
See: See section Options for Library Code.
library options. An AutoOpt-ed library may export its options for use in an AutoOpt-ed program. This is done by providing an option definition file that client programs #include into their own option definitions. See "AutoOpt-ed Library for AutoOpt-ed Program" (see section AutoOpt-ed Library for AutoOpt-ed Program) for more details.

7.2 AutoOpts Licensing

When AutoGen is installed, the AutoOpts project is installed with it. AutoOpts includes various AutoGen templates and a pair of shared libraries. These libraries may be used under the terms of the GNU Lesser General Public License (LGPL).

One of these libraries (libopts) is needed by programs that are built using AutoOpts generated code. This library is available as a separate "tear-off" source tarball. It is redistributable for use under either of two licenses: The GNU Lesser General Public License ("Lesser" meaning you have greater license with it and may link it into commercial programs), and the advertising-clause-free BSD license. Both of these license terms are incorporated into appropriate COPYING files included with the libopts source tarball. This source may be incorporated into your package with the following simple commands:

rm -rf liboptsliboptslIndex]

7.1 AutoOpts Features

AutoOpts supports option processing; option state saving; and program documentation with innumerable features. Here, we list a few obvious ones and some important ones, but the full list is really defined by all the attributes defined in the Option Definitions section.

POSIX-compliant short (flag) option processing.
GNU-style long options processing. Long options are recognized without case sensitivity, and they may be abbreviated.
Environment variable initializations, See section environment variable presets.
Initialization from configuration files (aka RC or INI files), and saving the option state back into one, See section configuration file presets.
Config files may be partitioned. One config file may be used by several programs by partitioning it with lines containing, "[PROGRAM_NAME]", See section configuration file presets.
Options may be marked as dis-abled with a disablement prefix. Such options may default to either an enabled or a disabled state. You may also provide an enablement prefix, too, e.g., --allow-mumble and --prevent-mumble.
Verify that required options are present between the minimum and maximum number of times on the command line.
Verify that conflicting options do not appear together, and that options that require the presence of other options are, in fact, used in the presence of other options.
Provides a callable routine to parse a text string as if it were from one of the rc/ini/config files, hereafter referred to as a configuration file.
--help and --version are automatically supported. --more-help will page the generated help.
By adding a `doc' and `arg-name' attributes to each option, AutoGen will also be able to produce a man page and the `invoking' section of a texinfo document.
Insert the option processing state into Scheme-defined variables. Thus, Guile based applications that are linked with private main() routines can take advantage of all of AutoOpts' functionality.
Various forms of main procedures can be added to the output, See section Generating main procedures. There are four basic forms:
1. A program that processes the arguments and writes to standard out portable shell commands containing the digested options.
2. A program that will generate portable shell commands to parse the defined options. The expectation is that this result will be copied into a shell script and used there.
3. A "for-each" main that will invoke a named function once for either each non-option argument on the command line or, if there are none, then once for each non-blank, non-comment input line read from stdin.
4. A main procedure of your own design. Its code can be supplied in the option description template or by incorporating another template.
Library suppliers can specify command line options that their client programs will accept. They specify option definitions that get #include-d into the client option definitions and they specify an "anchor" option that has a callback and must be invoked. That will give the library access to the option state for their options.
The generated usage text can be emitted in either AutoOpts standard format (maximizing the information about each option), or GNU-ish normal form. The default form is selected by either specifying or not specifying the gnu-usage attribute (see section Program Information Attributes). This can be overridden by the user himself with the AUTOOPTS_USAGE environment variable. If it exists and is set to the string gnu, it will force GNU-ish style format; if it is set to the string autoopts, it will force AutoOpts standard format; otherwise, it will have no effect.
If you compile with ENABLE_NLS defined and _() defined to a localization function such as gettext(3GNU), then the option processing code will be localizable (see section Internationalizing AutoOpts).
Intermingled option processing. AutoOpts options may be intermingled with command line operands and options processed with other parsing techniques. This is accomplished by setting the allow-errors (see section Program Description Attributes) attribute. When processing reaches a point where optionProcess (see section optionProcess) needs to be called again, the current option can be set with RESTART_OPT(n) (see section RESTART_OPT( n ) - Resume Option Processing) before calling optionProcess.
See: See section Options for Library Code.
library options. An AutoOpt-ed library may export its options for use in an AutoOpt-ed program. This is done by providing an option definition file that client programs #include into their own option definitions. See "AutoOpt-ed Library for AutoOpt-ed Program" (see section AutoOpt-ed Library for AutoOpt-ed Program) for more details.

7.2 AutoOpts Licensing

When AutoGen is installed, the AutoOpts project is installed with it. AutoOpts includes various AutoGen templates and a pair of shared libraries. These libraries may be used under the terms of the GNU Lesser General Public License (LGPL).

One of these libraries (libopts) is needed by programs that are built using AutoOpts generated code. This library is available as a separate "tear-off" source tarball. It is redistributable for use under either of two licenses: The GNU Lesser General Public License ("Lesser" meaning you have greater license with it and may link it into commercial programs), and the advertising-clause-free BSD license. Both of these license terms are incorporated into appropriate COPYING files included with the libopts source tarball. This source may be incorporated into your package with the following simple commands:

rm -rf liboptsliboptslIndex]

7.1 AutoOpts Features

AutoOpts supports option processing; option state saving; and program documentation with innumerable features. Here, we list a few obvious ones and some important ones, but the full list is really defined by all the attributes defined in the Option Definitions section.

POSIX-compliant short (flag) option processing.
GNU-style long options processing. Long options are recognized without case sensitivity, and they may be abbreviated.
Environment variable initializations, See section environment variable presets.
Initialization from configuration files (aka RC or INI files), and saving the option state back into one, See section configuration file presets.
Config files may be partitioned. One config file may be used by several programs by partitioning it with lines containing, "[PROGRAM_NAME]", See section configuration file presets.
Options may be marked as dis-abled with a disablement prefix. Such options may default to either an enabled or a disabled state. You may also provide an enablement prefix, too, e.g., --allow-mumble and --prevent-mumble.
Verify that required options are present between the minimum and maximum number of times on the command line.
Verify that conflicting options do not appear together, and that options that require the presence of other options are, in fact, used in the presence of other options.
Provides a callable routine to parse a text string as if it were from one of the rc/ini/config files, hereafter referred to as a configuration file.
--help and --version are automatically supported. --more-help will page the generated help.
By adding a `doc' and `arg-name' attributes to each option, AutoGen will also be able to produce a man page and the `invoking' section of a texinfo document.
Insert the option processing state into Scheme-defined variables. Thus, Guile based applications that are linked with private main() routines can take advantage of all of AutoOpts' functionality.
Various forms of main procedures can be added to the output, See section Generating main procedures. There are four basic forms:
1. A program that processes the arguments and writes to standard out portable shell commands containing the digested options.
2. A program that will generate portable shell commands to parse the defined options. The expectation is that this result will be copied into a shell script and used there.
3. A "for-each" main that will invoke a named function once for either each non-option argument on the command line or, if there are none, then once for each non-blank, non-comment input line read from stdin.
4. A main procedure of your own design. Its code can be supplied in the option description template or by incorporating another template.
Library suppliers can specify command line options that their client programs will accept. They specify option definitions that get #include-d into the client option definitions and they specify an "anchor" option that has a callback and must be invoked. That will give the library access to the option state for their options.
The generated usage text can be emitted in either AutoOpts standard format (maximizing the information about each option), or GNU-ish normal form. The default form is selected by either specifying or not specifying the gnu-usage attribute (see section Program Information Attributes). This can be overridden by the user himself with the AUTOOPTS_USAGE environment variable. If it exists and is set to the string gnu, it will force GNU-ish style format; if it is set to the string autoopts, it will force AutoOpts standard format; otherwise, it will have no effect.
If you compile with ENABLE_NLS defined and _() defined to a localization function such as gettext(3GNU), then the option processing code will be localizable (see section Internationalizing AutoOpts).
Intermingled option processing. AutoOpts options may be intermingled with command line operands and options processed with other parsing techniques. This is accomplished by setting the allow-errors (see section Program Description Attributes) attribute. When processing reaches a point where optionProcess (see section optionProcess) needs to be called again, the current option can be set with RESTART_OPT(n) (see section RESTART_OPT( n ) - Resume Option Processing) before calling optionProcess.
See: See section Options for Library Code.
library options. An AutoOpt-ed library may export its options for use in an AutoOpt-ed program. This is done by providing an option definition file that client programs #include into their own option definitions. See "AutoOpt-ed Library for AutoOpt-ed Program" (see section AutoOpt-ed Library for AutoOpt-ed Program) for more details.

7.2 AutoOpts Licensing

When AutoGen is installed, the AutoOpts project is installed with it. AutoOpts includes various AutoGen templates and a pair of shared libraries. These libraries may be used under the terms of the GNU Lesser General Public License (LGPL).

One of these libraries (libopts) is needed by programs that are built using AutoOpts generated code. This library is available as a separate "tear-off" source tarball. It is redistributable for use under either of two licenses: The GNU Lesser General Public License ("Lesser" meaning you have greater license with it and may link it into commercial programs), and the advertising-clause-free BSD license. Both of these license terms are incorporated into appropriate COPYING files included with the libopts source tarball. This source may be incorporated into your package with the following simple commands:

rm -rf liboptsliboptslIndex]

7.1 AutoOpts Features

AutoOpts supports option processing; option state saving; and program documentation with innumerable features. Here, we list a few obvious ones and some important ones, but the full list is really defined by all the attributes defined in the Option Definitions section.

POSIX-compliant short (flag) option processing.
GNU-style long options processing. Long options are recognized without case sensitivity, and they may be abbreviated.
Environment variable initializations, See section environment variable presets.
Initialization from configuration files (aka RC or INI files), and saving the option state back into one, See section configuration file presets.
Config files may be partitioned. One config file may be used by several programs by partitioning it with lines containing, "[PROGRAM_NAME]", See section configuration file presets.
Options may be marked as dis-abled with a disablement prefix. Such options may default to either an enabled or a disabled state. You may also provide an enablement prefix, too, e.g., --allow-mumble and --prevent-mumble.
Verify that required options are present between the minimum and maximum number of times on the command line.
Verify that conflicting options do not appear together, and that options that require the presence of other options are, in fact, used in the presence of other options.
Provides a callable routine to parse a text string as if it were from one of the rc/ini/config files, hereafter referred to as a configuration file.
--help and --version are automatically supported. --more-help will page the generated help.
By adding a `doc' and `arg-name' attributes to each option, AutoGen will also be able to produce a man page and the `invoking' section of a texinfo document.
Insert the option processing state into Scheme-defined variables. Thus, Guile based applications that are linked with private main() routines can take advantage of all of AutoOpts' functionality.
Various forms of main procedures can be added to the output, See section Generating main procedures. There are four basic forms:
1. A program that processes the arguments and writes to standard out portable shell commands containing the digested options.
2. A program that will generate portable shell commands to parse the defined options. The expectation is that this result will be copied into a shell script and used there.
3. A "for-each" main that will invoke a named function once for either each non-option argument on the command line or, if there are none, then once for each non-blank, non-comment input line read from stdin.
4. A main procedure of your own design. Its code can be supplied in the option description template or by incorporating another template.
Library suppliers can specify command line options that their client programs will accept. They specify option definitions that get #include-d into the client option definitions and they specify an "anchor" option that has a callback and must be invoked. That will give the library access to the option state for their options.
The generated usage text can be emitted in either AutoOpts standard format (maximizing the information about each option), or GNU-ish normal form. The default form is selected by either specifying or not specifying the gnu-usage attribute (see section Program Information Attributes). This can be overridden by the user himself with the AUTOOPTS_USAGE environment variable. If it exists and is set to the string gnu, it will force GNU-ish style format; if it is set to the string autoopts, it will force AutoOpts standard format; otherwise, it will have no effect.
If you compile with ENABLE_NLS defined and _() defined to a localization function such as gettext(3GNU), then the option processing code will be localizable (see section Internationalizing AutoOpts).
Intermingled option processing. AutoOpts options may be intermingled with command line operands and options processed with other parsing techniques. This is accomplished by setting the allow-errors (see section Program Description Attributes) attribute. When processing reaches a point where optionProcess (see section optionProcess) needs to be called again, the current option can be set with RESTART_OPT(n) (see section RESTART_OPT( n ) - Resume Option Processing) before calling optionProcess.
See: See section Options for Library Code.
library options. An AutoOpt-ed library may export its options for use in an AutoOpt-ed program. This is done by providing an option definition file that client programs #include into their own option definitions. See "AutoOpt-ed Library for AutoOpt-ed Program" (see section AutoOpt-ed Library for AutoOpt-ed Program) for more details.

7.2 AutoOpts Licensing

When AutoGen is installed, the AutoOpts project is installed with it. AutoOpts includes various AutoGen templates and a pair of shared libraries. These libraries may be used under the terms of the GNU Lesser General Public License (LGPL).

One of these libraries (libopts) is needed by programs that are built using AutoOpts generated code. This library is available as a separate "tear-off" source tarball. It is redistributable for use under either of two licenses: The GNU Lesser General Public License ("Lesser" meaning you have greater license with it and may link it into commercial programs), and the advertising-clause-free BSD license. Both of these license terms are incorporated into appropriate COPYING files included with the libopts source tarball. This source may be incorporated into your package with the following simple commands:

rm -rf liboptsliboptslIndex]

7.1 AutoOpts Features

AutoOpts supports option processing; option state saving; and program documentation with innumerable features. Here, we list a few obvious ones and some important ones, but the full list is really defined by all the attributes defined in the Option Definitions section.

POSIX-compliant short (flag) option processing.
GNU-style long options processing. Long options are recognized without case sensitivity, and they may be abbreviated.
Environment variable initializations, See section environment variable presets.
Initialization from configuration files (aka RC or INI files), and saving the option state back into one, See section configuration file presets.
Config files may be partitioned. One config file may be used by several programs by partitioning it with lines containing, "[PROGRAM_NAME]", See section configuration file presets.
Options may be marked as dis-abled with a disablement prefix. Such options may default to either an enabled or a disabled state. You may also provide an enablement prefix, too, e.g., --allow-mumble and --prevent-mumble.
Verify that required options are present between the minimum and maximum number of times on the command line.
Verify that conflicting options do not appear together, and that options that require the presence of other options are, in fact, used in the presence of other options.
Provides a callable routine to parse a text string as if it were from one of the rc/ini/config files, hereafter referred to as a configuration file.
--help and --version are automatically supported. --more-help will page the generated help.
By adding a `doc' and `arg-name' attributes to each option, AutoGen will also be able to produce a man page and the `invoking' section of a texinfo document.
Insert the option processing state into Scheme-defined variables. Thus, Guile based applications that are linked with private main() routines can take advantage of all of AutoOpts' functionality.
Various forms of main procedures can be added to the output, See section Generating main procedures. There are four basic forms:
1. A program that processes the arguments and writes to standard out portable shell commands containing the digested options.
2. A program that will generate portable shell commands to parse the defined options. The expectation is that this result will be copied into a shell script and used there.
3. A "for-each" main that will invoke a named function once for either each non-option argument on the command line or, if there are none, then once for each non-blank, non-comment input line read from stdin.
4. A main procedure of your own design. Its code can be supplied in the option description template or by incorporating another template.
Library suppliers can specify command line options that their client programs will accept. They specify option definitions that get #include-d into the client option definitions and they specify an "anchor" option that has a callback and must be invoked. That will give the library access to the option state for their options.
The generated usage text can be emitted in either AutoOpts standard format (maximizing the information about each option), or GNU-ish normal form. The default form is selected by either specifying or not specifying the gnu-usage attribute (see section Program Information Attributes). This can be overridden by the user himself with the AUTOOPTS_USAGE environment variable. If it exists and is set to the string gnu, it will force GNU-ish style format; if it is set to the string autoopts, it will force AutoOpts standard format; otherwise, it will have no effect.
If you compile with ENABLE_NLS defined and _() defined to a localization function such as gettext(3GNU), then the option processing code will be localizable (see section Internationalizing AutoOpts).
Intermingled option processing. AutoOpts options may be intermingled with command line operands and options processed with other parsing techniques. This is accomplished by setting the allow-errors (see section Program Description Attributes) attribute. When processing reaches a point where optionProcess (see section optionProcess) needs to be called again, the current option can be set with RESTART_OPT(n) (see section RESTART_OPT( n ) - Resume Option Processing) before calling optionProcess.
See: See section Options for Library Code.
library options. An AutoOpt-ed library may export its options for use in an AutoOpt-ed program. This is done by providing an option definition file that client programs #include into their own option definitions. See "AutoOpt-ed Library for AutoOpt-ed Program" (see section AutoOpt-ed Library for AutoOpt-ed Program) for more details.

7.2 AutoOpts Licensing

When AutoGen is installed, the AutoOpts project is installed with it. AutoOpts includes various AutoGen templates and a pair of shared libraries. These libraries may be used under the terms of the GNU Lesser General Public License (LGPL).

One of these libraries (libopts) is needed by programs that are built using AutoOpts generated code. This library is available as a separate "tear-off" source tarball. It is redistributable for use under either of two licenses: The GNU Lesser General Public License ("Lesser" meaning you have greater license with it and may link it into commercial programs), and the advertising-clause-free BSD license. Both of these license terms are incorporated into appropriate COPYING files included with the libopts source tarball. This source may be incorporated into your package with the following simple commands:

rm -rf liboptsliboptslIndex]

7.1 AutoOpts Features

AutoOpts supports option processing; option state saving; and program documentation with innumerable features. Here, we list a few obvious ones and some important ones, but the full list is really defined by all the attributes defined in the Option Definitions section.

POSIX-compliant short (flag) option processing.
GNU-style long options processing. Long options are recognized without case sensitivity, and they may be abbreviated.
Environment variable initializations, See section environment variable presets.
Initialization from configuration files (aka RC or INI files), and saving the option state back into one, See section configuration file presets.
Config files may be partitioned. One config file may be used by several programs by partitioning it with lines containing, "[PROGRAM_NAME]", See section configuration file presets.
Options may be marked as dis-abled with a disablement prefix. Such options may default to either an enabled or a disabled state. You may also provide an enablement prefix, too, e.g., --allow-mumble and --prevent-mumble.
Verify that required options are present between the minimum and maximum number of times on the command line.
Verify that conflicting options do not appear together, and that options that require the presence of other options are, in fact, used in the presence of other options.
Provides a callable routine to parse a text string as if it were from one of the rc/ini/config files, hereafter referred to as a configuration file.
--help and --version are automatically supported. --more-help will page the generated help.
By adding a `doc' and `arg-name' attributes to each option, AutoGen will also be able to produce a man page and the `invoking' section of a texinfo document.
Insert the option processing state into Scheme-defined variables. Thus, Guile based applications that are linked with private main() routines can take advantage of all of AutoOpts' functionality.
Various forms of main procedures can be added to the output, See section Generating main procedures. There are four basic forms:
1. A program that processes the arguments and writes to standard out portable shell commands containing the digested options.
2. A program that will generate portable shell commands to parse the defined options. The expectation is that this result will be copied into a shell script and used there.
3. A "for-each" main that will invoke a named function once for either each non-option argument on the command line or, if there are none, then once for each non-blank, non-comment input line read from stdin.
4. A main procedure of your own design. Its code can be supplied in the option description template or by incorporating another template.
Library suppliers can specify command line options that their client programs will accept. They specify option definitions that get #include-d into the client option definitions and they specify an "anchor" option that has a callback and must be invoked. That will give the library access to the option state for their options.
The generated usage text can be emitted in either AutoOpts standard format (maximizing the information about each option), or GNU-ish normal form. The default form is selected by either specifying or not specifying the gnu-usage attribute (see section Program Information Attributes). This can be overridden by the user himself with the AUTOOPTS_USAGE environment variable. If it exists and is set to the string gnu, it will force GNU-ish style format; if it is set to the string autoopts, it will force AutoOpts standard format; otherwise, it will have no effect.
If you compile with ENABLE_NLS defined and _() defined to a localization function such as gettext(3GNU), then the option processing code will be localizable (see section Internationalizing AutoOpts).
Intermingled option processing. AutoOpts options may be intermingled with command line operands and options processed with other parsing techniques. This is accomplished by setting the allow-errors (see section Program Description Attributes) attribute. When processing reaches a point where optionProcess (see section optionProcess) needs to be called again, the current option can be set with RESTART_OPT(n) (see section RESTART_OPT( n ) - Resume Option Processing) before calling optionProcess.
See: See section Options for Library Code.
library options. An AutoOpt-ed library may export its options for use in an AutoOpt-ed program. This is done by providing an option definition file that client programs #include into their own option definitions. See "AutoOpt-ed Library for AutoOpt-ed Program" (see section AutoOpt-ed Library for AutoOpt-ed Program) for more details.

7.2 AutoOpts Licensing

When AutoGen is installed, the AutoOpts project is installed with it. AutoOpts includes various AutoGen templates and a pair of shared libraries. These libraries may be used under the terms of the GNU Lesser General Public License (LGPL).

One of these libraries (libopts) is needed by programs that are built using AutoOpts generated code. This library is available as a separate "tear-off" source tarball. It is redistributable for use under either of two licenses: The GNU Lesser General Public License ("Lesser" meaning you have greater license with it and may link it into commercial programs), and the advertising-clause-free BSD license. Both of these license terms are incorporated into appropriate COPYING files included with the libopts source tarball. This source may be incorporated into your package with the following simple commands:

rm -rf liboptsliboptslIndex]

7.1 AutoOpts Features

AutoOpts supports option processing; option state saving; and program documentation with innumerable features. Here, we list a few obvious ones and some important ones, but the full list is really defined by all the attributes defined in the Option Definitions section.

POSIX-compliant short (flag) option processing.
GNU-style long options processing. Long options are recognized without case sensitivity, and they may be abbreviated.
Environment variable initializations, See section environment variable presets.
Initialization from configuration files (aka RC or INI files), and saving the option state back into one, See section configuration file presets.
Config files may be partitioned. One config file may be used by several programs by partitioning it with lines containing, "[PROGRAM_NAME]", See section configuration file presets.
Options may be marked as dis-abled with a disablement prefix. Such options may default to either an enabled or a disabled state. You may also provide an enablement prefix, too, e.g., --allow-mumble and --prevent-mumble.
Verify that required options are present between the minimum and maximum number of times on the command line.
Verify that conflicting options do not appear together, and that options that require the presence of other options are, in fact, used in the presence of other options.
Provides a callable routine to parse a text string as if it were from one of the rc/ini/config files, hereafter referred to as a configuration file.
--help and --version are automatically supported. --more-help will page the generated help.
By adding a `doc' and `arg-name' attributes to each option, AutoGen will also be able to produce a man page and the `invoking' section of a texinfo document.
Insert the option processing state into Scheme-defined variables. Thus, Guile based applications that are linked with private main() routines can take advantage of all of AutoOpts' functionality.
Various forms of main procedures can be added to the output, See section Generating main procedures. There are four basic forms:
1. A program that processes the arguments and writes to standard out portable shell commands containing the digested options.
2. A program that will generate portable shell commands to parse the defined options. The expectation is that this result will be copied into a shell script and used there.
3. A "for-each" main that will invoke a named function once for either each non-option argument on the command line or, if there are none, then once for each non-blank, non-comment input line read from stdin.
4. A main procedure of your own design. Its code can be supplied in the option description template or by incorporating another template.
Library suppliers can specify command line options that their client programs will accept. They specify option definitions that get #include-d into the client option definitions and they specify an "anchor" option that has a callback and must be invoked. That will give the library access to the option state for their options.
The generated usage text can be emitted in either AutoOpts standard format (maximizing the information about each option), or GNU-ish normal form. The default form is selected by either specifying or not specifying the gnu-usage attribute (see section Program Information Attributes). This can be overridden by the user himself with the AUTOOPTS_USAGE environment variable. If it exists and is set to the string gnu, it will force GNU-ish style format; if it is set to the string autoopts, it will force AutoOpts standard format; otherwise, it will have no effect.
If you compile with ENABLE_NLS defined and _() defined to a localization function such as gettext(3GNU), then the option processing code will be localizable (see section Internationalizing AutoOpts).
Intermingled option processing. AutoOpts options may be intermingled with command line operands and options processed with other parsing techniques. This is accomplished by setting the allow-errors (see section Program Description Attributes) attribute. When processing reaches a point where optionProcess (see section optionProcess) needs to be called again, the current option can be set with RESTART_OPT(n) (see section RESTART_OPT( n ) - Resume Option Processing) before calling optionProcess.
See: See section Options for Library Code.
library options. An AutoOpt-ed library may export its options for use in an AutoOpt-ed program. This is done by providing an option definition file that client programs #include into their own option definitions. See "AutoOpt-ed Library for AutoOpt-ed Program" (see section AutoOpt-ed Library for AutoOpt-ed Program) for more details.

7.2 AutoOpts Licensing

When AutoGen is installed, the AutoOpts project is installed with it. AutoOpts includes various AutoGen templates and a pair of shared libraries. These libraries may be used under the terms of the GNU Lesser General Public License (LGPL).

One of these libraries (libopts) is needed by programs that are built using AutoOpts generated code. This library is available as a separate "tear-off" source tarball. It is redistributable for use under either of two licenses: The GNU Lesser General Public License ("Lesser" meaning you have greater license with it and may link it into commercial programs), and the advertising-clause-free BSD license. Both of these license terms are incorporated into appropriate COPYING files included with the libopts source tarball. This source may be incorporated into your package with the following simple commands:

rm -rf liboptsliboptslIndex]

7.1 AutoOpts Features

AutoOpts supports option processing; option state saving; and program documentation with innumerable features. Here, we list a few obvious ones and some important ones, but the full list is really defined by all the attributes defined in the Option Definitions section.

POSIX-compliant short (flag) option processing.
GNU-style long options processing. Long options are recognized without case sensitivity, and they may be abbreviated.
Environment variable initializations, See section environment variable presets.
Initialization from configuration files (aka RC or INI files), and saving the option state back into one, See section configuration file presets.
Config files may be partitioned. One config file may be used by several programs by partitioning it with lines containing, "[PROGRAM_NAME]", See section configuration file presets.
Options may be marked as dis-abled with a disablement prefix. Such options may default to either an enabled or a disabled state. You may also provide an enablement prefix, too, e.g., --allow-mumble and --prevent-mumble.
Verify that required options are present between the minimum and maximum number of times on the command line.
Verify that conflicting options do not appear together, and that options that require the presence of other options are, in fact, used in the presence of other options.
Provides a callable routine to parse a text string as if it were from one of the rc/ini/config files, hereafter referred to as a configuration file.
--help and --version are automatically supported. --more-help will page the generated help.
By adding a `doc' and `arg-name' attributes to each option, AutoGen will also be able to produce a man page and the `invoking' section of a texinfo document.
Insert the option processing state into Scheme-defined variables. Thus, Guile based applications that are linked with private main() routines can take advantage of all of AutoOpts' functionality.
Various forms of main procedures can be added to the output, See section Generating main procedures. There are four basic forms:
1. A program that processes the arguments and writes to standard out portable shell commands containing the digested options.
2. A program that will generate portable shell commands to parse the defined options. The expectation is that this result will be copied into a shell script and used there.
3. A "for-each" main that will invoke a named function once for either each non-option argument on the command line or, if there are none, then once for each non-blank, non-comment input line read from stdin.
4. A main procedure of your own design. Its code can be supplied in the option description template or by incorporating another template.
Library suppliers can specify command line options that their client programs will accept. They specify option definitions that get #include-d into the client option definitions and they specify an "anchor" option that has a callback and must be invoked. That will give the library access to the option state for their options.
The generated usage text can be emitted in either AutoOpts standard format (maximizing the information about each option), or GNU-ish normal form. The default form is selected by either specifying or not specifying the gnu-usage attribute (see section Program Information Attributes). This can be overridden by the user himself with the AUTOOPTS_USAGE environment variable. If it exists and is set to the string gnu, it will force GNU-ish style format; if it is set to the string autoopts, it will force AutoOpts standard format; otherwise, it will have no effect.
If you compile with ENABLE_NLS defined and _() defined to a localization function such as gettext(3GNU), then the option processing code will be localizable (see section Internationalizing AutoOpts).
Intermingled option processing. AutoOpts options may be intermingled with command line operands and options processed with other parsing techniques. This is accomplished by setting the allow-errors (see section Program Description Attributes) attribute. When processing reaches a point where optionProcess (see section optionProcess) needs to be called again, the current option can be set with RESTART_OPT(n) (see section RESTART_OPT( n ) - Resume Option Processing) before calling optionProcess.
See: See section Options for Library Code.
library options. An AutoOpt-ed library may export its options for use in an AutoOpt-ed program. This is done by providing an option definition file that client programs #include into their own option definitions. See "AutoOpt-ed Library for AutoOpt-ed Program" (see section AutoOpt-ed Library for AutoOpt-ed Program) for more details.

7.2 AutoOpts Licensing

When AutoGen is installed, the AutoOpts project is installed with it. AutoOpts includes various AutoGen templates and a pair of shared libraries. These libraries may be used under the terms of the GNU Lesser General Public License (LGPL).

One of these libraries (libopts) is needed by programs that are built using AutoOpts generated code. This library is available as a separate "tear-off" source tarball. It is redistributable for use under either of two licenses: The GNU Lesser General Public License ("Lesser" meaning you have greater license with it and may link it into commercial programs), and the advertising-clause-free BSD license. Both of these license terms are incorporated into appropriate COPYING files included with the libopts source tarball. This source may be incorporated into your package with the following simple commands:

rm -rf liboptsliboptslIndex]

7.1 AutoOpts Features

AutoOpts supports option processing; option state saving; and program documentation with innumerable features. Here, we list a few obvious ones and some important ones, but the full list is really defined by all the attributes defined in the Option Definitions section.

POSIX-compliant short (flag) option processing.
GNU-style long options processing. Long options are recognized without case sensitivity, and they may be abbreviated.
Environment variable initializations, See section environment variable presets.
Initialization from configuration files (aka RC or INI files), and saving the option state back into one, See section configuration file presets.
Config files may be partitioned. One config file may be used by several programs by partitioning it with lines containing, "[PROGRAM_NAME]", See section configuration file presets.
Options may be marked as dis-abled with a disablement prefix. Such options may default to either an enabled or a disabled state. You may also provide an enablement prefix, too, e.g., --allow-mumble and --prevent-mumble.
Verify that required options are present between the minimum and maximum number of times on the command line.
Verify that conflicting options do not appear together, and that options that require the presence of other options are, in fact, used in the presence of other options.
Provides a callable routine to parse a text string as if it were from one of the rc/ini/config files, hereafter referred to as a configuration file.
--help and --version are automatically supported. --more-help will page the generated help.
By adding a `doc' and `arg-name' attributes to each option, AutoGen will also be able to produce a man page and the `invoking' section of a texinfo document.
Insert the option processing state into Scheme-defined variables. Thus, Guile based applications that are linked with private main() routines can take advantage of all of AutoOpts' functionality.
Various forms of main procedures can be added to the output, See section Generating main procedures. There are four basic forms:
1. A program that processes the arguments and writes to standard out portable shell commands containing the digested options.
2. A program that will generate portable shell commands to parse the defined options. The expectation is that this result will be copied into a shell script and used there.
3. A "for-each" main that will invoke a named function once for either each non-option argument on the command line or, if there are none, then once for each non-blank, non-comment input line read from stdin.
4. A main procedure of your own design. Its code can be supplied in the option description template or by incorporating another template.
Library suppliers can specify command line options that their client programs will accept. They specify option definitions that get #include-d into the client option definitions and they specify an "anchor" option that has a callback and must be invoked. That will give the library access to the option state for their options.
The generated usage text can be emitted in either AutoOpts standard format (maximizing the information about each option), or GNU-ish normal form. The default form is selected by either specifying or not specifying the gnu-usage attribute (see section Program Information Attributes). This can be overridden by the user himself with the AUTOOPTS_USAGE environment variable. If it exists and is set to the string gnu, it will force GNU-ish style format; if it is set to the string autoopts, it will force AutoOpts standard format; otherwise, it will have no effect.
If you compile with ENABLE_NLS defined and _() defined to a localization function such as gettext(3GNU), then the option processing code will be localizable (see section Internationalizing AutoOpts).
Intermingled option processing. AutoOpts options may be intermingled with command line operands and options processed with other parsing techniques. This is accomplished by setting the allow-errors (see section Program Description Attributes) attribute. When processing reaches a point where optionProcess (see section optionProcess) needs to be called again, the current option can be set with RESTART_OPT(n) (see section RESTART_OPT( n ) - Resume Option Processing) before calling optionProcess.
See: See section Options for Library Code.
library options. An AutoOpt-ed library may export its options for use in an AutoOpt-ed program. This is done by providing an option definition file that client programs #include into their own option definitions. See "AutoOpt-ed Library for AutoOpt-ed Program" (see section AutoOpt-ed Library for AutoOpt-ed Program) for more details.

7.2 AutoOpts Licensing

When AutoGen is installed, the AutoOpts project is installed with it. AutoOpts includes various AutoGen templates and a pair of shared libraries. These libraries may be used under the terms of the GNU Lesser General Public License (LGPL).

One of these libraries (libopts) is needed by programs that are built using AutoOpts generated code. This library is available as a separate "tear-off" source tarball. It is redistributable for use under either of two licenses: The GNU Lesser General Public License ("Lesser" meaning you have greater license with it and may link it into commercial programs), and the advertising-clause-free BSD license. Both of these license terms are incorporated into appropriate COPYING files included with the libopts source tarball. This source may be incorporated into your package with the following simple commands:

rm -rf liboptsliboptslIndex]

7.1 AutoOpts Features

AutoOpts supports option processing; option state saving; and program documentation with innumerable features. Here, we list a few obvious ones and some important ones, but the full list is really defined by all the attributes defined in the Option Definitions section.

POSIX-compliant short (flag) option processing.
GNU-style long options processing. Long options are recognized without case sensitivity, and they may be abbreviated.
Environment variable initializations, See section environment variable presets.
Initialization from configuration files (aka RC or INI files), and saving the option state back into one, See section configuration file presets.
Config files may be partitioned. One config file may be used by several programs by partitioning it with lines containing, "[PROGRAM_NAME]", See section configuration file presets.
Options may be marked as dis-abled with a disablement prefix. Such options may default to either an enabled or a disabled state. You may also provide an enablement prefix, too, e.g., --allow-mumble and --prevent-mumble.
Verify that required options are present between the minimum and maximum number of times on the command line.
Verify that conflicting options do not appear together, and that options that require the presence of other options are, in fact, used in the presence of other options.
Provides a callable routine to parse a text string as if it were from one of the rc/ini/config files, hereafter referred to as a configuration file.
--help and --version are automatically supported. --more-help will page the generated help.
By adding a `doc' and `arg-name' attributes to each option, AutoGen will also be able to produce a man page and the `invoking' section of a texinfo document.
Insert the option processing state into Scheme-defined variables. Thus, Guile based applications that are linked with private main() routines can take advantage of all of AutoOpts' functionality.
Various forms of main procedures can be added to the output, See section Generating main procedures. There are four basic forms:
1. A program that processes the arguments and writes to standard out portable shell commands containing the digested options.
2. A program that will generate portable shell commands to parse the defined options. The expectation is that this result will be copied into a shell script and used there.
3. A "for-each" main that will invoke a named function once for either each non-option argument on the command line or, if there are none, then once for each non-blank, non-comment input line read from stdin.
4. A main procedure of your own design. Its code can be supplied in the option description template or by incorporating another template.
Library suppliers can specify command line options that their client programs will accept. They specify option definitions that get #include-d into the client option definitions and they specify an "anchor" option that has a callback and must be invoked. That will give the library access to the option state for their options.
The generated usage text can be emitted in either AutoOpts standard format (maximizing the information about each option), or GNU-ish normal form. The default form is selected by either specifying or not specifying the gnu-usage attribute (see section Program Information Attributes). This can be overridden by the user himself with the AUTOOPTS_USAGE environment variable. If it exists and is set to the string gnu, it will force GNU-ish style format; if it is set to the string autoopts, it will force AutoOpts standard format; otherwise, it will have no effect.
If you compile with ENABLE_NLS defined and _() defined to a localization function such as gettext(3GNU), then the option processing code will be localizable (see section Internationalizing AutoOpts).
Intermingled option processing. AutoOpts options may be intermingled with command line operands and options processed with other parsing techniques. This is accomplished by setting the allow-errors (see section Program Description Attributes) attribute. When processing reaches a point where optionProcess (see section optionProcess) needs to be called again, the current option can be set with RESTART_OPT(n) (see section RESTART_OPT( n ) - Resume Option Processing) before calling optionProcess.
See: See section Options for Library Code.
library options. An AutoOpt-ed library may export its options for use in an AutoOpt-ed program. This is done by providing an option definition file that client programs #include into their own option definitions. See "AutoOpt-ed Library for AutoOpt-ed Program" (see section AutoOpt-ed Library for AutoOpt-ed Program) for more details.

7.2 AutoOpts Licensing

When AutoGen is installed, the AutoOpts project is installed with it. AutoOpts includes various AutoGen templates and a pair of shared libraries. These libraries may be used under the terms of the GNU Lesser General Public License (LGPL).

One of these libraries (libopts) is needed by programs that are built using AutoOpts generated code. This library is available as a separate "tear-off" source tarball. It is redistributable for use under either of two licenses: The GNU Lesser General Public License ("Lesser" meaning you have greater license with it and may link it into commercial programs), and the advertising-clause-free BSD license. Both of these license terms are incorporated into appropriate COPYING files included with the libopts source tarball. This source may be incorporated into your package with the following simple commands:

rm -rf liboptsliboptslIndex]

7.1 AutoOpts Features

AutoOpts supports option processing; option state saving; and program documentation with innumerable features. Here, we list a few obvious ones and some important ones, but the full list is really defined by all the attributes defined in the Option Definitions section.

POSIX-compliant short (flag) option processing.
GNU-style long options processing. Long options are recognized without case sensitivity, and they may be abbreviated.
Environment variable initializations, See section environment variable presets.
Initialization from configuration files (aka RC or INI files), and saving the option state back into one, See section configuration file presets.
Config files may be partitioned. One config file may be used by several programs by partitioning it with lines containing, "[PROGRAM_NAME]", See section configuration file presets.
Options may be marked as dis-abled with a disablement prefix. Such options may default to either an enabled or a disabled state. You may also provide an enablement prefix, too, e.g., --allow-mumble and --prevent-mumble.
Verify that required options are present between the minimum and maximum number of times on the command line.
Verify that conflicting options do not appear together, and that options that require the presence of other options are, in fact, used in the presence of other options.
Provides a callable routine to parse a text string as if it were from one of the rc/ini/config files, hereafter referred to as a configuration file.
--help and --version are automatically supported. --more-help will page the generated help.
By adding a `doc' and `arg-name' attributes to each option, AutoGen will also be able to produce a man page and the `invoking' section of a texinfo document.
Insert the option processing state into Scheme-defined variables. Thus, Guile based applications that are linked with private main() routines can take advantage of all of AutoOpts' functionality.
Various forms of main procedures can be added to the output, See section Generating main procedures. There are four basic forms:
1. A program that processes the arguments and writes to standard out portable shell commands containing the digested options.
2. A program that will generate portable shell commands to parse the defined options. The expectation is that this result will be copied into a shell script and used there.
3. A "for-each" main that will invoke a named function once for either each non-option argument on the command line or, if there are none, then once for each non-blank, non-comment input line read from stdin.
4. A main procedure of your own design. Its code can be supplied in the option description template or by incorporating another template.
Library suppliers can specify command line options that their client programs will accept. They specify option definitions that get #include-d into the client option definitions and they specify an "anchor" option that has a callback and must be invoked. That will give the library access to the option state for their options.
The generated usage text can be emitted in either AutoOpts standard format (maximizing the information about each option), or GNU-ish normal form. The default form is selected by either specifying or not specifying the gnu-usage attribute (see section Program Information Attributes). This can be overridden by the user himself with the AUTOOPTS_USAGE environment variable. If it exists and is set to the string gnu, it will force GNU-ish style format; if it is set to the string autoopts, it will force AutoOpts standard format; otherwise, it will have no effect.
If you compile with ENABLE_NLS defined and _() defined to a localization function such as gettext(3GNU), then the option processing code will be localizable (see section Internationalizing AutoOpts).
Intermingled option processing. AutoOpts options may be intermingled with command line operands and options processed with other parsing techniques. This is accomplished by setting the allow-errors (see section Program Description Attributes) attribute. When processing reaches a point where optionProcess (see section optionProcess) needs to be called again, the current option can be set with RESTART_OPT(n) (see section RESTART_OPT( n ) - Resume Option Processing) before calling optionProcess.
See: See section Options for Library Code.
library options. An AutoOpt-ed library may export its options for use in an AutoOpt-ed program. This is done by providing an option definition file that client programs #include into their own option definitions. See "AutoOpt-ed Library for AutoOpt-ed Program" (see section AutoOpt-ed Library for AutoOpt-ed Program) for more details.

7.2 AutoOpts Licensing

When AutoGen is installed, the AutoOpts project is installed with it. AutoOpts includes various AutoGen templates and a pair of shared libraries. These libraries may be used under the terms of the GNU Lesser General Public License (LGPL).

One of these libraries (libopts) is needed by programs that are built using AutoOpts generated code. This library is available as a separate "tear-off" source tarball. It is redistributable for use under either of two licenses: The GNU Lesser General Public License ("Lesser" meaning you have greater license with it and may link it into commercial programs), and the advertising-clause-free BSD license. Both of these license terms are incorporated into appropriate COPYING files included with the libopts source tarball. This source may be incorporated into your package with the following simple commands:

rm -rf liboptsliboptslIndex]

7.1 AutoOpts Features

AutoOpts supports option processing; option state saving; and program documentation with innumerable features. Here, we list a few obvious ones and some important ones, but the full list is really defined by all the attributes defined in the Option Definitions section.

POSIX-compliant short (flag) option processing.
GNU-style long options processing. Long options are recognized without case sensitivity, and they may be abbreviated.
Environment variable initializations, See section environment variable presets.
Initialization from configuration files (aka RC or INI files), and saving the option state back into one, See section configuration file presets.
Config files may be partitioned. One config file may be used by several programs by partitioning it with lines containing, "[PROGRAM_NAME]", See section configuration file presets.
Options may be marked as dis-abled with a disablement prefix. Such options may default to either an enabled or a disabled state. You may also provide an enablement prefix, too, e.g., --allow-mumble and --prevent-mumble.
Verify that required options are present between the minimum and maximum number of times on the command line.
Verify that conflicting options do not appear together, and that options that require the presence of other options are, in fact, used in the presence of other options.
Provides a callable routine to parse a text string as if it were from one of the rc/ini/config files, hereafter referred to as a configuration file.
--help and --version are automatically supported. --more-help will page the generated help.
By adding a `doc' and `arg-name' attributes to each option, AutoGen will also be able to produce a man page and the `invoking' section of a texinfo document.
Insert the option processing state into Scheme-defined variables. Thus, Guile based applications that are linked with private main() routines can take advantage of all of AutoOpts' functionality.
Various forms of main procedures can be added to the output, See section Generating main procedures. There are four basic forms:
1. A program that processes the arguments and writes to standard out portable shell commands containing the digested options.
2. A program that will generate portable shell commands to parse the defined options. The expectation is that this result will be copied into a shell script and used there.
3. A "for-each" main that will invoke a named function once for either each non-option argument on the command line or, if there are none, then once for each non-blank, non-comment input line read from stdin.
4. A main procedure of your own design. Its code can be supplied in the option description template or by incorporating another template.
Library suppliers can specify command line options that their client programs will accept. They specify option definitions that get #include-d into the client option definitions and they specify an "anchor" option that has a callback and must be invoked. That will give the library access to the option state for their options.
The generated usage text can be emitted in either AutoOpts standard format (maximizing the information about each option), or GNU-ish normal form. The default form is selected by either specifying or not specifying the gnu-usage attribute (see section Program Information Attributes). This can be overridden by the user himself with the AUTOOPTS_USAGE environment variable. If it exists and is set to the string gnu, it will force GNU-ish style format; if it is set to the string autoopts, it will force AutoOpts standard format; otherwise, it will have no effect.
If you compile with ENABLE_NLS defined and _() defined to a localization function such as gettext(3GNU), then the option processing code will be localizable (see section Internationalizing AutoOpts).
Intermingled option processing. AutoOpts options may be intermingled with command line operands and options processed with other parsing techniques. This is accomplished by setting the allow-errors (see section Program Description Attributes) attribute. When processing reaches a point where optionProcess (see section optionProcess) needs to be called again, the current option can be set with RESTART_OPT(n) (see section RESTART_OPT( n ) - Resume Option Processing) before calling optionProcess.
See: See section Options for Library Code.
library options. An AutoOpt-ed library may export its options for use in an AutoOpt-ed program. This is done by providing an option definition file that client programs #include into their own option definitions. See "AutoOpt-ed Library for AutoOpt-ed Program" (see section AutoOpt-ed Library for AutoOpt-ed Program) for more details.

7.2 AutoOpts Licensing

When AutoGen is installed, the AutoOpts project is installed with it. AutoOpts includes various AutoGen templates and a pair of shared libraries. These libraries may be used under the terms of the GNU Lesser General Public License (LGPL).

One of these libraries (libopts) is needed by programs that are built using AutoOpts generated code. This library is available as a separate "tear-off" source tarball. It is redistributable for use under either of two licenses: The GNU Lesser General Public License ("Lesser" meaning you have greater license with it and may link it into commercial programs), and the advertising-clause-free BSD license. Both of these license terms are incorporated into appropriate COPYING files included with the libopts source tarball. This source may be incorporated into your package with the following simple commands:

rm -rf liboptsliboptslIndex]

7.1 AutoOpts Features

AutoOpts supports option processing; option state saving; and program documentation with innumerable features. Here, we list a few obvious ones and some important ones, but the full list is really defined by all the attributes defined in the Option Definitions section.

POSIX-compliant short (flag) option processing.
GNU-style long options processing. Long options are recognized without case sensitivity, and they may be abbreviated.
Environment variable initializations, See section environment variable presets.
Initialization from configuration files (aka RC or INI files), and saving the option state back into one, See section configuration file presets.
Config files may be partitioned. One config file may be used by several programs by partitioning it with lines containing, "[PROGRAM_NAME]", See section configuration file presets.
Options may be marked as dis-abled with a disablement prefix. Such options may default to either an enabled or a disabled state. You may also provide an enablement prefix, too, e.g., --allow-mumble and --prevent-mumble.
Verify that required options are present between the minimum and maximum number of times on the command line.
Verify that conflicting options do not appear together, and that options that require the presence of other options are, in fact, used in the presence of other options.
Provides a callable routine to parse a text string as if it were from one of the rc/ini/config files, hereafter referred to as a configuration file.
--help and --version are automatically supported. --more-help will page the generated help.
By adding a `doc' and `arg-name' attributes to each option, AutoGen will also be able to produce a man page and the `invoking' section of a texinfo document.
Insert the option processing state into Scheme-defined variables. Thus, Guile based applications that are linked with private main() routines can take advantage of all of AutoOpts' functionality.
Various forms of main procedures can be added to the output, See section Generating main procedures. There are four basic forms:
1. A program that processes the arguments and writes to standard out portable shell commands containing the digested options.
2. A program that will generate portable shell commands to parse the defined options. The expectation is that this result will be copied into a shell script and used there.
3. A "for-each" main that will invoke a named function once for either each non-option argument on the command line or, if there are none, then once for each non-blank, non-comment input line read from stdin.
4. A main procedure of your own design. Its code can be supplied in the option description template or by incorporating another template.
Library suppliers can specify command line options that their client programs will accept. They specify option definitions that get #include-d into the client option definitions and they specify an "anchor" option that has a callback and must be invoked. That will give the library access to the option state for their options.
The generated usage text can be emitted in either AutoOpts standard format (maximizing the information about each option), or GNU-ish normal form. The default form is selected by either specifying or not specifying the gnu-usage attribute (see section Program Information Attributes). This can be overridden by the user himself with the AUTOOPTS_USAGE environment variable. If it exists and is set to the string gnu, it will force GNU-ish style format; if it is set to the string autoopts, it will force AutoOpts standard format; otherwise, it will have no effect.
If you compile with ENABLE_NLS defined and _() defined to a localization function such as gettext(3GNU), then the option processing code will be localizable (see section Internationalizing AutoOpts).
Intermingled option processing. AutoOpts options may be intermingled with command line operands and options processed with other parsing techniques. This is accomplished by setting the allow-errors (see section Program Description Attributes) attribute. When processing reaches a point where optionProcess (see section optionProcess) needs to be called again, the current option can be set with RESTART_OPT(n) (see section RESTART_OPT( n ) - Resume Option Processing) before calling optionProcess.
See: See section Options for Library Code.
library options. An AutoOpt-ed library may export its options for use in an AutoOpt-ed program. This is done by providing an option definition file that client programs #include into their own option definitions. See "AutoOpt-ed Library for AutoOpt-ed Program" (see section AutoOpt-ed Library for AutoOpt-ed Program) for more details.

7.2 AutoOpts Licensing

When AutoGen is installed, the AutoOpts project is installed with it. AutoOpts includes various AutoGen templates and a pair of shared libraries. These libraries may be used under the terms of the GNU Lesser General Public License (LGPL).

One of these libraries (libopts) is needed by programs that are built using AutoOpts generated code. This library is available as a separate "tear-off" source tarball. It is redistributable for use under either of two licenses: The GNU Lesser General Public License ("Lesser" meaning you have greater license with it and may link it into commercial programs), and the advertising-clause-free BSD license. Both of these license terms are incorporated into appropriate COPYING files included with the libopts source tarball. This source may be incorporated into your package with the following simple commands:

rm -rf liboptsliboptslIndex]

7.1 AutoOpts Features

AutoOpts supports option processing; option state saving; and program documentation with innumerable features. Here, we list a few obvious ones and some important ones, but the full list is really defined by all the attributes defined in the Option Definitions section.

POSIX-compliant short (flag) option processing.
GNU-style long options processing. Long options are recognized without case sensitivity, and they may be abbreviated.
Environment variable initializations, See section environment variable presets.
Initialization from configuration files (aka RC or INI files), and saving the option state back into one, See section configuration file presets.
Config files may be partitioned. One config file may be used by several programs by partitioning it with lines containing, "[PROGRAM_NAME]", See section configuration file presets.
Options may be marked as dis-abled with a disablement prefix. Such options may default to either an enabled or a disabled state. You may also provide an enablement prefix, too, e.g., --allow-mumble and --prevent-mumble.
Verify that required options are present between the minimum and maximum number of times on the command line.
Verify that conflicting options do not appear together, and that options that require the presence of other options are, in fact, used in the presence of other options.
Provides a callable routine to parse a text string as if it were from one of the rc/ini/config files, hereafter referred to as a configuration file.
--help and --version are automatically supported. --more-help will page the generated help.
By adding a `doc' and `arg-name' attributes to each option, AutoGen will also be able to produce a man page and the `invoking' section of a texinfo document.
Insert the option processing state into Scheme-defined variables. Thus, Guile based applications that are linked with private main() routines can take advantage of all of AutoOpts' functionality.
Various forms of main procedures can be added to the output, See section Generating main procedures. There are four basic forms:
1. A program that processes the arguments and writes to standard out portable shell commands containing the digested options.
2. A program that will generate portable shell commands to parse the defined options. The expectation is that this result will be copied into a shell script and used there.
3. A "for-each" main that will invoke a named function once for either each non-option argument on the command line or, if there are none, then once for each non-blank, non-comment input line read from stdin.
4. A main procedure of your own design. Its code can be supplied in the option description template or by incorporating another template.
Library suppliers can specify command line options that their client programs will accept. They specify option definitions that get #include-d into the client option definitions and they specify an "anchor" option that has a callback and must be invoked. That will give the library access to the option state for their options.
The generated usage text can be emitted in either AutoOpts standard format (maximizing the information about each option), or GNU-ish normal form. The default form is selected by either specifying or not specifying the gnu-usage attribute (see section Program Information Attributes). This can be overridden by the user himself with the AUTOOPTS_USAGE environment variable. If it exists and is set to the string gnu, it will force GNU-ish style format; if it is set to the string autoopts, it will force AutoOpts standard format; otherwise, it will have no effect.
If you compile with ENABLE_NLS defined and _() defined to a localization function such as gettext(3GNU), then the option processing code will be localizable (see section Internationalizing AutoOpts).
Intermingled option processing. AutoOpts options may be intermingled with command line operands and options processed with other parsing techniques. This is accomplished by setting the allow-errors (see section Program Description Attributes) attribute. When processing reaches a point where optionProcess (see section optionProcess) needs to be called again, the current option can be set with RESTART_OPT(n) (see section RESTART_OPT( n ) - Resume Option Processing) before calling optionProcess.
See: See section Options for Library Code.
library options. An AutoOpt-ed library may export its options for use in an AutoOpt-ed program. This is done by providing an option definition file that client programs #include into their own option definitions. See "AutoOpt-ed Library for AutoOpt-ed Program" (see section AutoOpt-ed Library for AutoOpt-ed Program) for more details.

7.2 AutoOpts Licensing

When AutoGen is installed, the AutoOpts project is installed with it. AutoOpts includes various AutoGen templates and a pair of shared libraries. These libraries may be used under the terms of the GNU Lesser General Public License (LGPL).

One of these libraries (libopts) is needed by programs that are built using AutoOpts generated code. This library is available as a separate "tear-off" source tarball. It is redistributable for use under either of two licenses: The GNU Lesser General Public License ("Lesser" meaning you have greater license with it and may link it into commercial programs), and the advertising-clause-free BSD license. Both of these license terms are incorporated into appropriate COPYING files included with the libopts source tarball. This source may be incorporated into your package with the following simple commands:

rm -rf liboptsliboptslIndex]

7.1 AutoOpts Features

AutoOpts supports option processing; option state saving; and program documentation with innumerable features. Here, we list a few obvious ones and some important ones, but the full list is really defined by all the attributes defined in the Option Definitions section.

POSIX-compliant short (flag) option processing.
GNU-style long options processing. Long options are recognized without case sensitivity, and they may be abbreviated.
Environment variable initializations, See section environment variable presets.
Initialization from configuration files (aka RC or INI files), and saving the option state back into one, See section configuration file presets.
Config files may be partitioned. One config file may be used by several programs by partitioning it with lines containing, "[PROGRAM_NAME]", See section configuration file presets.
Options may be marked as dis-abled with a disablement prefix. Such options may default to either an enabled or a disabled state. You may also provide an enablement prefix, too, e.g., --allow-mumble and --prevent-mumble.
Verify that required options are present between the minimum and maximum number of times on the command line.
Verify that conflicting options do not appear together, and that options that require the presence of other options are, in fact, used in the presence of other options.
Provides a callable routine to parse a text string as if it were from one of the rc/ini/config files, hereafter referred to as a configuration file.
--help and --version are automatically supported. --more-help will page the generated help.
By adding a `doc' and `arg-name' attributes to each option, AutoGen will also be able to produce a man page and the `invoking' section of a texinfo document.
Insert the option processing state into Scheme-defined variables. Thus, Guile based applications that are linked with private main() routines can take advantage of all of AutoOpts' functionality.
Various forms of main procedures can be added to the output, See section Generating main procedures. There are four basic forms:
1. A program that processes the arguments and writes to standard out portable shell commands containing the digested options.
2. A program that will generate portable shell commands to parse the defined options. The expectation is that this result will be copied into a shell script and used there.
3. A "for-each" main that will invoke a named function once for either each non-option argument on the command line or, if there are none, then once for each non-blank, non-comment input line read from stdin.
4. A main procedure of your own design. Its code can be supplied in the option description template or by incorporating another template.
Library suppliers can specify command line options that their client programs will accept. They specify option definitions that get #include-d into the client option definitions and they specify an "anchor" option that has a callback and must be invoked. That will give the library access to the option state for their options.
The generated usage text can be emitted in either AutoOpts standard format (maximizing the information about each option), or GNU-ish normal form. The default form is selected by either specifying or not specifying the gnu-usage attribute (see section Program Information Attributes). This can be overridden by the user himself with the AUTOOPTS_USAGE environment variable. If it exists and is set to the string gnu, it will force GNU-ish style format; if it is set to the string autoopts, it will force AutoOpts standard format; otherwise, it will have no effect.
If you compile with ENABLE_NLS defined and _() defined to a localization function such as gettext(3GNU), then the option processing code will be localizable (see section Internationalizing AutoOpts).
Intermingled option processing. AutoOpts options may be intermingled with command line operands and options processed with other parsing techniques. This is accomplished by setting the allow-errors (see section Program Description Attributes) attribute. When processing reaches a point where optionProcess (see section optionProcess) needs to be called again, the current option can be set with RESTART_OPT(n) (see section RESTART_OPT( n ) - Resume Option Processing) before calling optionProcess.
See: See section Options for Library Code.
library options. An AutoOpt-ed library may export its options for use in an AutoOpt-ed program. This is done by providing an option definition file that client programs #include into their own option definitions. See "AutoOpt-ed Library for AutoOpt-ed Program" (see section AutoOpt-ed Library for AutoOpt-ed Program) for more details.

7.2 AutoOpts Licensing

When AutoGen is installed, the AutoOpts project is installed with it. AutoOpts includes various AutoGen templates and a pair of shared libraries. These libraries may be used under the terms of the GNU Lesser General Public License (LGPL).

One of these libraries (libopts) is needed by programs that are built using AutoOpts generated code. This library is available as a separate "tear-off" source tarball. It is redistributable for use under either of two licenses: The GNU Lesser General Public License ("Lesser" meaning you have greater license with it and may link it into commercial programs), and the advertising-clause-free BSD license. Both of these license terms are incorporated into appropriate COPYING files included with the libopts source tarball. This source may be incorporated into your package with the following simple commands:

rm -rf liboptsliboptslIndex]

7.1 AutoOpts Features

AutoOpts supports option processing; option state saving; and program documentation with innumerable features. Here, we list a few obvious ones and some important ones, but the full list is really defined by all the attributes defined in the Option Definitions section.

POSIX-compliant short (flag) option processing.
GNU-style long options processing. Long options are recognized without case sensitivity, and they may be abbreviated.
Environment variable initializations, See section environment variable presets.
Initialization from configuration files (aka RC or INI files), and saving the option state back into one, See section configuration file presets.
Config files may be partitioned. One config file may be used by several programs by partitioning it with lines containing, "[PROGRAM_NAME]", See section configuration file presets.
Options may be marked as dis-abled with a disablement prefix. Such options may default to either an enabled or a disabled state. You may also provide an enablement prefix, too, e.g., --allow-mumble and --prevent-mumble.
Verify that required options are present between the minimum and maximum number of times on the command line.
Verify that conflicting options do not appear together, and that options that require the presence of other options are, in fact, used in the presence of other options.
Provides a callable routine to parse a text string as if it were from one of the rc/ini/config files, hereafter referred to as a configuration file.
--help and --version are automatically supported. --more-help will page the generated help.
By adding a `doc' and `arg-name' attributes to each option, AutoGen will also be able to produce a man page and the `invoking' section of a texinfo document.
Insert the option processing state into Scheme-defined variables. Thus, Guile based applications that are linked with private main() routines can take advantage of all of AutoOpts' functionality.
Various forms of main procedures can be added to the output, See section Generating main procedures. There are four basic forms:
1. A program that processes the arguments and writes to standard out portable shell commands containing the digested options.
2. A program that will generate portable shell commands to parse the defined options. The expectation is that this result will be copied into a shell script and used there.
3. A "for-each" main that will invoke a named function once for either each non-option argument on the command line or, if there are none, then once for each non-blank, non-comment input line read from stdin.
4. A main procedure of your own design. Its code can be supplied in the option description template or by incorporating another template.
Library suppliers can specify command line options that their client programs will accept. They specify option definitions that get #include-d into the client option definitions and they specify an "anchor" option that has a callback and must be invoked. That will give the library access to the option state for their options.
The generated usage text can be emitted in either AutoOpts standard format (maximizing the information about each option), or GNU-ish normal form. The default form is selected by either specifying or not specifying the gnu-usage attribute (see section Program Information Attributes). This can be overridden by the user himself with the AUTOOPTS_USAGE environment variable. If it exists and is set to the string gnu, it will force GNU-ish style format; if it is set to the string autoopts, it will force AutoOpts standard format; otherwise, it will have no effect.
If you compile with ENABLE_NLS defined and _() defined to a localization function such as gettext(3GNU), then the option processing code will be localizable (see section Internationalizing AutoOpts).
Intermingled option processing. AutoOpts options may be intermingled with command line operands and options processed with other parsing techniques. This is accomplished by setting the allow-errors (see section Program Description Attributes) attribute. When processing reaches a point where optionProcess (see section optionProcess) needs to be called again, the current option can be set with RESTART_OPT(n) (see section RESTART_OPT( n ) - Resume Option Processing) before calling optionProcess.
See: See section Options for Library Code.
library options. An AutoOpt-ed library may export its options for use in an AutoOpt-ed program. This is done by providing an option definition file that client programs #include into their own option definitions. See "AutoOpt-ed Library for AutoOpt-ed Program" (see section AutoOpt-ed Library for AutoOpt-ed Program) for more details.

7.2 AutoOpts Licensing

When AutoGen is installed, the AutoOpts project is installed with it. AutoOpts includes various AutoGen templates and a pair of shared libraries. These libraries may be used under the terms of the GNU Lesser General Public License (LGPL).

One of these libraries (libopts) is needed by programs that are built using AutoOpts generated code. This library is available as a separate "tear-off" source tarball. It is redistributable for use under either of two licenses: The GNU Lesser General Public License ("Lesser" meaning you have greater license with it and may link it into commercial programs), and the advertising-clause-free BSD license. Both of these license terms are incorporated into appropriate COPYING files included with the libopts source tarball. This source may be incorporated into your package with the following simple commands:

rm -rf liboptsliboptslIndex]

7.1 AutoOpts Features

AutoOpts supports option processing; option state saving; and program documentation with innumerable features. Here, we list a few obvious ones and some important ones, but the full list is really defined by all the attributes defined in the Option Definitions section.

POSIX-compliant short (flag) option processing.
GNU-style long options processing. Long options are recognized without case sensitivity, and they may be abbreviated.
Environment variable initializations, See section environment variable presets.
Initialization from configuration files (aka RC or INI files), and saving the option state back into one, See section configuration file presets.
Config files may be partitioned. One config file may be used by several programs by partitioning it with lines containing, "[PROGRAM_NAME]", See section configuration file presets.
Options may be marked as dis-abled with a disablement prefix. Such options may default to either an enabled or a disabled state. You may also provide an enablement prefix, too, e.g., --allow-mumble and --prevent-mumble.
Verify that required options are present between the minimum and maximum number of times on the command line.
Verify that conflicting options do not appear together, and that options that require the presence of other options are, in fact, used in the presence of other options.
Provides a callable routine to parse a text string as if it were from one of the rc/ini/config files, hereafter referred to as a configuration file.
--help and --version are automatically supported. --more-help will page the generated help.
By adding a `doc' and `arg-name' attributes to each option, AutoGen will also be able to produce a man page and the `invoking' section of a texinfo document.
Insert the option processing state into Scheme-defined variables. Thus, Guile based applications that are linked with private main() routines can take advantage of all of AutoOpts' functionality.
Various forms of main procedures can be added to the output, See section Generating main procedures. There are four basic forms:
1. A program that processes the arguments and writes to standard out portable shell commands containing the digested options.
2. A program that will generate portable shell commands to parse the defined options. The expectation is that this result will be copied into a shell script and used there.
3. A "for-each" main that will invoke a named function once for either each non-option argument on the command line or, if there are none, then once for each non-blank, non-comment input line read from stdin.
4. A main procedure of your own design. Its code can be supplied in the option description template or by incorporating another template.
Library suppliers can specify command line options that their client programs will accept. They specify option definitions that get #include-d into the client option definitions and they specify an "anchor" option that has a callback and must be invoked. That will give the library access to the option state for their options.
The generated usage text can be emitted in either AutoOpts standard format (maximizing the information about each option), or GNU-ish normal form. The default form is selected by either specifying or not specifying the gnu-usage attribute (see section Program Information Attributes). This can be overridden by the user himself with the AUTOOPTS_USAGE environment variable. If it exists and is set to the string gnu, it will force GNU-ish style format; if it is set to the string autoopts, it will force AutoOpts standard format; otherwise, it will have no effect.
If you compile with ENABLE_NLS defined and _() defined to a localization function such as gettext(3GNU), then the option processing code will be localizable (see section Internationalizing AutoOpts).
Intermingled option processing. AutoOpts options may be intermingled with command line operands and options processed with other parsing techniques. This is accomplished by setting the allow-errors (see section Program Description Attributes) attribute. When processing reaches a point where optionProcess (see section optionProcess) needs to be called again, the current option can be set with RESTART_OPT(n) (see section RESTART_OPT( n ) - Resume Option Processing) before calling optionProcess.
See: See section Options for Library Code.
library options. An AutoOpt-ed library may export its options for use in an AutoOpt-ed program. This is done by providing an option definition file that client programs #include into their own option definitions. See "AutoOpt-ed Library for AutoOpt-ed Program" (see section AutoOpt-ed Library for AutoOpt-ed Program) for more details.

7.2 AutoOpts Licensing

When AutoGen is installed, the AutoOpts project is installed with it. AutoOpts includes various AutoGen templates and a pair of shared libraries. These libraries may be used under the terms of the GNU Lesser General Public License (LGPL).

One of these libraries (libopts) is needed by programs that are built using AutoOpts generated code. This library is available as a separate "tear-off" source tarball. It is redistributable for use under either of two licenses: The GNU Lesser General Public License ("Lesser" meaning you have greater license with it and may link it into commercial programs), and the advertising-clause-free BSD license. Both of these license terms are incorporated into appropriate COPYING files included with the libopts source tarball. This source may be incorporated into your package with the following simple commands:

rm -rf liboptsliboptslIndex]

7.1 AutoOpts Features

AutoOpts supports option processing; option state saving; and program documentation with innumerable features. Here, we list a few obvious ones and some important ones, but the full list is really defined by all the attributes defined in the Option Definitions section.

POSIX-compliant short (flag) option processing.
GNU-style long options processing. Long options are recognized without case sensitivity, and they may be abbreviated.
Environment variable initializations, See section environment variable presets.
Initialization from configuration files (aka RC or INI files), and saving the option state back into one, See section configuration file presets.
Config files may be partitioned. One config file may be used by several programs by partitioning it with lines containing, "[PROGRAM_NAME]", See section configuration file presets.
Options may be marked as dis-abled with a disablement prefix. Such options may default to either an enabled or a disabled state. You may also provide an enablement prefix, too, e.g., --allow-mumble and --prevent-mumble.
Verify that required options are present between the minimum and maximum number of times on the command line.
Verify that conflicting options do not appear together, and that options that require the presence of other options are, in fact, used in the presence of other options.
Provides a callable routine to parse a text string as if it were from one of the rc/ini/config files, hereafter referred to as a configuration file.
--help and --version are automatically supported. --more-help will page the generated help.
By adding a `doc' and `arg-name' attributes to each option, AutoGen will also be able to produce a man page and the `invoking' section of a texinfo document.
Insert the option processing state into Scheme-defined variables. Thus, Guile based applications that are linked with private main() routines can take advantage of all of AutoOpts' functionality.
Various forms of main procedures can be added to the output, See section Generating main procedures. There are four basic forms:
1. A program that processes the arguments and writes to standard out portable shell commands containing the digested options.
2. A program that will generate portable shell commands to parse the defined options. The expectation is that this result will be copied into a shell script and used there.
3. A "for-each" main that will invoke a named function once for either each non-option argument on the command line or, if there are none, then once for each non-blank, non-comment input line read from stdin.
4. A main procedure of your own design. Its code can be supplied in the option description template or by incorporating another template.
Library suppliers can specify command line options that their client programs will accept. They specify option definitions that get #include-d into the client option definitions and they specify an "anchor" option that has a callback and must be invoked. That will give the library access to the option state for their options.
The generated usage text can be emitted in either AutoOpts standard format (maximizing the information about each option), or GNU-ish normal form. The default form is selected by either specifying or not specifying the gnu-usage attribute (see section Program Information Attributes). This can be overridden by the user himself with the AUTOOPTS_USAGE environment variable. If it exists and is set to the string gnu, it will force GNU-ish style format; if it is set to the string autoopts, it will force AutoOpts standard format; otherwise, it will have no effect.
If you compile with ENABLE_NLS defined and _() defined to a localization function such as gettext(3GNU), then the option processing code will be localizable (see section Internationalizing AutoOpts).
Intermingled option processing. AutoOpts options may be intermingled with command line operands and options processed with other parsing techniques. This is accomplished by setting the allow-errors (see section Program Description Attributes) attribute. When processing reaches a point where optionProcess (see section optionProcess) needs to be called again, the current option can be set with RESTART_OPT(n) (see section RESTART_OPT( n ) - Resume Option Processing) before calling optionProcess.
See: See section Options for Library Code.
library options. An AutoOpt-ed library may export its options for use in an AutoOpt-ed program. This is done by providing an option definition file that client programs #include into their own option definitions. See "AutoOpt-ed Library for AutoOpt-ed Program" (see section AutoOpt-ed Library for AutoOpt-ed Program) for more details.

7.2 AutoOpts Licensing

When AutoGen is installed, the AutoOpts project is installed with it. AutoOpts includes various AutoGen templates and a pair of shared libraries. These libraries may be used under the terms of the GNU Lesser General Public License (LGPL).

One of these libraries (libopts) is needed by programs that are built using AutoOpts generated code. This library is available as a separate "tear-off" source tarball. It is redistributable for use under either of two licenses: The GNU Lesser General Public License ("Lesser" meaning you have greater license with it and may link it into commercial programs), and the advertising-clause-free BSD license. Both of these license terms are incorporated into appropriate COPYING files included with the libopts source tarball. This source may be incorporated into your package with the following simple commands:

rm -rf liboptsliboptslIndex]

7.1 AutoOpts Features

AutoOpts supports option processing; option state saving; and program documentation with innumerable features. Here, we list a few obvious ones and some important ones, but the full list is really defined by all the attributes defined in the Option Definitions section.

POSIX-compliant short (flag) option processing.
GNU-style long options processing. Long options are recognized without case sensitivity, and they may be abbreviated.
Environment variable initializations, See section environment variable presets.
Initialization from configuration files (aka RC or INI files), and saving the option state back into one, See section configuration file presets.
Config files may be partitioned. One config file may be used by several programs by partitioning it with lines containing, "[PROGRAM_NAME]", See section configuration file presets.
Options may be marked as dis-abled with a disablement prefix. Such options may default to either an enabled or a disabled state. You may also provide an enablement prefix, too, e.g., --allow-mumble and --prevent-mumble.
Verify that required options are present between the minimum and maximum number of times on the command line.
Verify that conflicting options do not appear together, and that options that require the presence of other options are, in fact, used in the presence of other options.
Provides a callable routine to parse a text string as if it were from one of the rc/ini/config files, hereafter referred to as a configuration file.
--help and --version are automatically supported. --more-help will page the generated help.
By adding a `doc' and `arg-name' attributes to each option, AutoGen will also be able to produce a man page and the `invoking' section of a texinfo document.
Insert the option processing state into Scheme-defined variables. Thus, Guile based applications that are linked with private main() routines can take advantage of all of AutoOpts' functionality.
Various forms of main procedures can be added to the output, See section Generating main procedures. There are four basic forms:
1. A program that processes the arguments and writes to standard out portable shell commands containing the digested options.
2. A program that will generate portable shell commands to parse the defined options. The expectation is that this result will be copied into a shell script and used there.
3. A "for-each" main that will invoke a named function once for either each non-option argument on the command line or, if there are none, then once for each non-blank, non-comment input line read from stdin.
4. A main procedure of your own design. Its code can be supplied in the option description template or by incorporating another template.
Library suppliers can specify command line options that their client programs will accept. They specify option definitions that get #include-d into the client option definitions and they specify an "anchor" option that has a callback and must be invoked. That will give the library access to the option state for their options.
The generated usage text can be emitted in either AutoOpts standard format (maximizing the information about each option), or GNU-ish normal form. The default form is selected by either specifying or not specifying the gnu-usage attribute (see section Program Information Attributes). This can be overridden by the user himself with the AUTOOPTS_USAGE environment variable. If it exists and is set to the string gnu, it will force GNU-ish style format; if it is set to the string autoopts, it will force AutoOpts standard format; otherwise, it will have no effect.
If you compile with ENABLE_NLS defined and _() defined to a localization function such as gettext(3GNU), then the option processing code will be localizable (see section Internationalizing AutoOpts).
Intermingled option processing. AutoOpts options may be intermingled with command line operands and options processed with other parsing techniques. This is accomplished by setting the allow-errors (see section Program Description Attributes) attribute. When processing reaches a point where optionProcess (see section optionProcess) needs to be called again, the current option can be set with RESTART_OPT(n) (see section RESTART_OPT( n ) - Resume Option Processing) before calling optionProcess.
See: See section Options for Library Code.
library options. An AutoOpt-ed library may export its options for use in an AutoOpt-ed program. This is done by providing an option definition file that client programs #include into their own option definitions. See "AutoOpt-ed Library for AutoOpt-ed Program" (see section AutoOpt-ed Library for AutoOpt-ed Program) for more details.

7.2 AutoOpts Licensing

When AutoGen is installed, the AutoOpts project is installed with it. AutoOpts includes various AutoGen templates and a pair of shared libraries. These libraries may be used under the terms of the GNU Lesser General Public License (LGPL).

One of these libraries (libopts) is needed by programs that are built using AutoOpts generated code. This library is available as a separate "tear-off" source tarball. It is redistributable for use under either of two licenses: The GNU Lesser General Public License ("Lesser" meaning you have greater license with it and may link it into commercial programs), and the advertising-clause-free BSD license. Both of these license terms are incorporated into appropriate COPYING files included with the libopts source tarball. This source may be incorporated into your package with the following simple commands:

rm -rf liboptsliboptslIndex]

7.1 AutoOpts Features

AutoOpts supports option processing; option state saving; and program documentation with innumerable features. Here, we list a few obvious ones and some important ones, but the full list is really defined by all the attributes defined in the Option Definitions section.

POSIX-compliant short (flag) option processing.
GNU-style long options processing. Long options are recognized without case sensitivity, and they may be abbreviated.
Environment variable initializations, See section environment variable presets.
Initialization from configuration files (aka RC or INI files), and saving the option state back into one, See section configuration file presets.
Config files may be partitioned. One config file may be used by several programs by partitioning it with lines containing, "[PROGRAM_NAME]", See section configuration file presets.
Options may be marked as dis-abled with a disablement prefix. Such options may default to either an enabled or a disabled state. You may also provide an enablement prefix, too, e.g., --allow-mumble and --prevent-mumble.
Verify that required options are present between the minimum and maximum number of times on the command line.
Verify that conflicting options do not appear together, and that options that require the presence of other options are, in fact, used in the presence of other options.
Provides a callable routine to parse a text string as if it were from one of the rc/ini/config files, hereafter referred to as a configuration file.
--help and --version are automatically supported. --more-help will page the generated help.
By adding a `doc' and `arg-name' attributes to each option, AutoGen will also be able to produce a man page and the `invoking' section of a texinfo document.
Insert the option processing state into Scheme-defined variables. Thus, Guile based applications that are linked with private main() routines can take advantage of all of AutoOpts' functionality.
Various forms of main procedures can be added to the output, See section Generating main procedures. There are four basic forms:
1. A program that processes the arguments and writes to standard out portable shell commands containing the digested options.
2. A program that will generate portable shell commands to parse the defined options. The expectation is that this result will be copied into a shell script and used there.
3. A "for-each" main that will invoke a named function once for either each non-option argument on the command line or, if there are none, then once for each non-blank, non-comment input line read from stdin.
4. A main procedure of your own design. Its code can be supplied in the option description template or by incorporating another template.
Library suppliers can specify command line options that their client programs will accept. They specify option definitions that get #include-d into the client option definitions and they specify an "anchor" option that has a callback and must be invoked. That will give the library access to the option state for their options.
The generated usage text can be emitted in either AutoOpts standard format (maximizing the information about each option), or GNU-ish normal form. The default form is selected by either specifying or not specifying the gnu-usage attribute (see section Program Information Attributes). This can be overridden by the user himself with the AUTOOPTS_USAGE environment variable. If it exists and is set to the string gnu, it will force GNU-ish style format; if it is set to the string autoopts, it will force AutoOpts standard format; otherwise, it will have no effect.
If you compile with ENABLE_NLS defined and _() defined to a localization function such as gettext(3GNU), then the option processing code will be localizable (see section Internationalizing AutoOpts).
Intermingled option processing. AutoOpts options may be intermingled with command line operands and options processed with other parsing techniques. This is accomplished by setting the allow-errors (see section Program Description Attributes) attribute. When processing reaches a point where optionProcess (see section optionProcess) needs to be called again, the current option can be set with RESTART_OPT(n) (see section RESTART_OPT( n ) - Resume Option Processing) before calling optionProcess.
See: See section Options for Library Code.
library options. An AutoOpt-ed library may export its options for use in an AutoOpt-ed program. This is done by providing an option definition file that client programs #include into their own option definitions. See "AutoOpt-ed Library for AutoOpt-ed Program" (see section AutoOpt-ed Library for AutoOpt-ed Program) for more details.

7.2 AutoOpts Licensing

When AutoGen is installed, the AutoOpts project is installed with it. AutoOpts includes various AutoGen templates and a pair of shared libraries. These libraries may be used under the terms of the GNU Lesser General Public License (LGPL).

One of these libraries (libopts) is needed by programs that are built using AutoOpts generated code. This library is available as a separate "tear-off" source tarball. It is redistributable for use under either of two licenses: The GNU Lesser General Public License ("Lesser" meaning you have greater license with it and may link it into commercial programs), and the advertising-clause-free BSD license. Both of these license terms are incorporated into appropriate COPYING files included with the libopts source tarball. This source may be incorporated into your package with the following simple commands:

rm -rf liboptsliboptslIndex]

7.1 AutoOpts Features

AutoOpts supports option processing; option state saving; and program documentation with innumerable features. Here, we list a few obvious ones and some important ones, but the full list is really defined by all the attributes defined in the Option Definitions section.

POSIX-compliant short (flag) option processing.
GNU-style long options processing. Long options are recognized without case sensitivity, and they may be abbreviated.
Environment variable initializations, See section environment variable presets.
Initialization from configuration files (aka RC or INI files), and saving the option state back into one, See section configuration file presets.
Config files may be partitioned. One config file may be used by several programs by partitioning it with lines containing, "[PROGRAM_NAME]", See section configuration file presets.
Options may be marked as dis-abled with a disablement prefix. Such options may default to either an enabled or a disabled state. You may also provide an enablement prefix, too, e.g., --allow-mumble and --prevent-mumble.
Verify that required options are present between the minimum and maximum number of times on the command line.
Verify that conflicting options do not appear together, and that options that require the presence of other options are, in fact, used in the presence of other options.
Provides a callable routine to parse a text string as if it were from one of the rc/ini/config files, hereafter referred to as a configuration file.
--help and --version are automatically supported. --more-help will page the generated help.
By adding a `doc' and `arg-name' attributes to each option, AutoGen will also be able to produce a man page and the `invoking' section of a texinfo document.
Insert the option processing state into Scheme-defined variables. Thus, Guile based applications that are linked with private main() routines can take advantage of all of AutoOpts' functionality.
Various forms of main procedures can be added to the output, See section Generating main procedures. There are four basic forms:
1. A program that processes the arguments and writes to standard out portable shell commands containing the digested options.
2. A program that will generate portable shell commands to parse the defined options. The expectation is that this result will be copied into a shell script and used there.
3. A "for-each" main that will invoke a named function once for either each non-option argument on the command line or, if there are none, then once for each non-blank, non-comment input line read from stdin.
4. A main procedure of your own design. Its code can be supplied in the option description template or by incorporating another template.
Library suppliers can specify command line options that their client programs will accept. They specify option definitions that get #include-d into the client option definitions and they specify an "anchor" option that has a callback and must be invoked. That will give the library access to the option state for their options.
The generated usage text can be emitted in either AutoOpts standard format (maximizing the information about each option), or GNU-ish normal form. The default form is selected by either specifying or not specifying the gnu-usage attribute (see section Program Information Attributes). This can be overridden by the user himself with the AUTOOPTS_USAGE environment variable. If it exists and is set to the string gnu, it will force GNU-ish style format; if it is set to the string autoopts, it will force AutoOpts standard format; otherwise, it will have no effect.
If you compile with ENABLE_NLS defined and _() defined to a localization function such as gettext(3GNU), then the option processing code will be localizable (see section Internationalizing AutoOpts).
Intermingled option processing. AutoOpts options may be intermingled with command line operands and options processed with other parsing techniques. This is accomplished by setting the allow-errors (see section Program Description Attributes) attribute. When processing reaches a point where optionProcess (see section optionProcess) needs to be called again, the current option can be set with RESTART_OPT(n) (see section RESTART_OPT( n ) - Resume Option Processing) before calling optionProcess.
See: See section Options for Library Code.
library options. An AutoOpt-ed library may export its options for use in an AutoOpt-ed program. This is done by providing an option definition file that client programs #include into their own option definitions. See "AutoOpt-ed Library for AutoOpt-ed Program" (see section AutoOpt-ed Library for AutoOpt-ed Program) for more details.

7.2 AutoOpts Licensing

When AutoGen is installed, the AutoOpts project is installed with it. AutoOpts includes various AutoGen templates and a pair of shared libraries. These libraries may be used under the terms of the GNU Lesser General Public License (LGPL).

One of these libraries (libopts) is needed by programs that are built using AutoOpts generated code. This library is available as a separate "tear-off" source tarball. It is redistributable for use under either of two licenses: The GNU Lesser General Public License ("Lesser" meaning you have greater license with it and may link it into commercial programs), and the advertising-clause-free BSD license. Both of these license terms are incorporated into appropriate COPYING files included with the libopts source tarball. This source may be incorporated into your package with the following simple commands:

rm -rf liboptsliboptslIndex]

7.1 AutoOpts Features

AutoOpts supports option processing; option state saving; and program documentation with innumerable features. Here, we list a few obvious ones and some important ones, but the full list is really defined by all the attributes defined in the Option Definitions section.

POSIX-compliant short (flag) option processing.
GNU-style long options processing. Long options are recognized without case sensitivity, and they may be abbreviated.
Environment variable initializations, See section environment variable presets.
Initialization from configuration files (aka RC or INI files), and saving the option state back into one, See section configuration file presets.
Config files may be partitioned. One config file may be used by several programs by partitioning it with lines containing, "[PROGRAM_NAME]", See section configuration file presets.
Options may be marked as dis-abled with a disablement prefix. Such options may default to either an enabled or a disabled state. You may also provide an enablement prefix, too, e.g., --allow-mumble and --prevent-mumble.
Verify that required options are present between the minimum and maximum number of times on the command line.
Verify that conflicting options do not appear together, and that options that require the presence of other options are, in fact, used in the presence of other options.
Provides a callable routine to parse a text string as if it were from one of the rc/ini/config files, hereafter referred to as a configuration file.
--help and --version are automatically supported. --more-help will page the generated help.
By adding a `doc' and `arg-name' attributes to each option, AutoGen will also be able to produce a man page and the `invoking' section of a texinfo document.
Insert the option processing state into Scheme-defined variables. Thus, Guile based applications that are linked with private main() routines can take advantage of all of AutoOpts' functionality.
Various forms of main procedures can be added to the output, See section Generating main procedures. There are four basic forms:
1. A program that processes the arguments and writes to standard out portable shell commands containing the digested options.
2. A program that will generate portable shell commands to parse the defined options. The expectation is that this result will be copied into a shell script and used there.
3. A "for-each" main that will invoke a named function once for either each non-option argument on the command line or, if there are none, then once for each non-blank, non-comment input line read from stdin.
4. A main procedure of your own design. Its code can be supplied in the option description template or by incorporating another template.
Library suppliers can specify command line options that their client programs will accept. They specify option definitions that get #include-d into the client option definitions and they specify an "anchor" option that has a callback and must be invoked. That will give the library access to the option state for their options.
The generated usage text can be emitted in either AutoOpts standard format (maximizing the information about each option), or GNU-ish normal form. The default form is selected by either specifying or not specifying the gnu-usage attribute (see section Program Information Attributes). This can be overridden by the user himself with the AUTOOPTS_USAGE environment variable. If it exists and is set to the string gnu, it will force GNU-ish style format; if it is set to the string autoopts, it will force AutoOpts standard format; otherwise, it will have no effect.
If you compile with ENABLE_NLS defined and _() defined to a localization function such as gettext(3GNU), then the option processing code will be localizable (see section Internationalizing AutoOpts).
Intermingled option processing. AutoOpts options may be intermingled with command line operands and options processed with other parsing techniques. This is accomplished by setting the allow-errors (see section Program Description Attributes) attribute. When processing reaches a point where optionProcess (see section optionProcess) needs to be called again, the current option can be set with RESTART_OPT(n) (see section RESTART_OPT( n ) - Resume Option Processing) before calling optionProcess.
See: See section Options for Library Code.
library options. An AutoOpt-ed library may export its options for use in an AutoOpt-ed program. This is done by providing an option definition file that client programs #include into their own option definitions. See "AutoOpt-ed Library for AutoOpt-ed Program" (see section AutoOpt-ed Library for AutoOpt-ed Program) for more details.

7.2 AutoOpts Licensing

When AutoGen is installed, the AutoOpts project is installed with it. AutoOpts includes various AutoGen templates and a pair of shared libraries. These libraries may be used under the terms of the GNU Lesser General Public License (LGPL).

One of these libraries (libopts) is needed by programs that are built using AutoOpts generated code. This library is available as a separate "tear-off" source tarball. It is redistributable for use under either of two licenses: The GNU Lesser General Public License ("Lesser" meaning you have greater license with it and may link it into commercial programs), and the advertising-clause-free BSD license. Both of these license terms are incorporated into appropriate COPYING files included with the libopts source tarball. This source may be incorporated into your package with the following simple commands:

rm -rf liboptsliboptslIndex]

7.1 AutoOpts Features

AutoOpts supports option processing; option state saving; and program documentation with innumerable features. Here, we list a few obvious ones and some important ones, but the full list is really defined by all the attributes defined in the Option Definitions section.

POSIX-compliant short (flag) option processing.
GNU-style long options processing. Long options are recognized without case sensitivity, and they may be abbreviated.
Environment variable initializations, See section environment variable presets.
Initialization from configuration files (aka RC or INI files), and saving the option state back into one, See section configuration file presets.
Config files may be partitioned. One config file may be used by several programs by partitioning it with lines containing, "[PROGRAM_NAME]", See section configuration file presets.
Options may be marked as dis-abled with a disablement prefix. Such options may default to either an enabled or a disabled state. You may also provide an enablement prefix, too, e.g., --allow-mumble and --prevent-mumble.
Verify that required options are present between the minimum and maximum number of times on the command line.
Verify that conflicting options do not appear together, and that options that require the presence of other options are, in fact, used in the presence of other options.
Provides a callable routine to parse a text string as if it were from one of the rc/ini/config files, hereafter referred to as a configuration file.
--help and --version are automatically supported. --more-help will page the generated help.
By adding a `doc' and `arg-name' attributes to each option, AutoGen will also be able to produce a man page and the `invoking' section of a texinfo document.
Insert the option processing state into Scheme-defined variables. Thus, Guile based applications that are linked with private main() routines can take advantage of all of AutoOpts' functionality.
Various forms of main procedures can be added to the output, See section Generating main procedures. There are four basic forms:
1. A program that processes the arguments and writes to standard out portable shell commands containing the digested options.
2. A program that will generate portable shell commands to parse the defined options. The expectation is that this result will be copied into a shell script and used there.
3. A "for-each" main that will invoke a named function once for either each non-option argument on the command line or, if there are none, then once for each non-blank, non-comment input line read from stdin.
4. A main procedure of your own design. Its code can be supplied in the option description template or by incorporating another template.
Library suppliers can specify command line options that their client programs will accept. They specify option definitions that get #include-d into the client option definitions and they specify an "anchor" option that has a callback and must be invoked. That will give the library access to the option state for their options.
The generated usage text can be emitted in either AutoOpts standard format (maximizing the information about each option), or GNU-ish normal form. The default form is selected by either specifying or not specifying the gnu-usage attribute (see section Program Information Attributes). This can be overridden by the user himself with the AUTOOPTS_USAGE environment variable. If it exists and is set to the string gnu, it will force GNU-ish style format; if it is set to the string autoopts, it will force AutoOpts standard format; otherwise, it will have no effect.
If you compile with ENABLE_NLS defined and _() defined to a localization function such as gettext(3GNU), then the option processing code will be localizable (see section Internationalizing AutoOpts).
Intermingled option processing. AutoOpts options may be intermingled with command line operands and options processed with other parsing techniques. This is accomplished by setting the allow-errors (see section Program Description Attributes) attribute. When processing reaches a point where optionProcess (see section optionProcess) needs to be called again, the current option can be set with RESTART_OPT(n) (see section RESTART_OPT( n ) - Resume Option Processing) before calling optionProcess.
See: See section Options for Library Code.
library options. An AutoOpt-ed library may export its options for use in an AutoOpt-ed program. This is done by providing an option definition file that client programs #include into their own option definitions. See "AutoOpt-ed Library for AutoOpt-ed Program" (see section AutoOpt-ed Library for AutoOpt-ed Program) for more details.

7.2 AutoOpts Licensing

When AutoGen is installed, the AutoOpts project is installed with it. AutoOpts includes various AutoGen templates and a pair of shared libraries. These libraries may be used under the terms of the GNU Lesser General Public License (LGPL).

One of these libraries (libopts) is needed by programs that are built using AutoOpts generated code. This library is available as a separate "tear-off" source tarball. It is redistributable for use under either of two licenses: The GNU Lesser General Public License ("Lesser" meaning you have greater license with it and may link it into commercial programs), and the advertising-clause-free BSD license. Both of these license terms are incorporated into appropriate COPYING files included with the libopts source tarball. This source may be incorporated into your package with the following simple commands:

rm -rf liboptsliboptslIndex]

7.1 AutoOpts Features

AutoOpts supports option processing; option state saving; and program documentation with innumerable features. Here, we list a few obvious ones and some important ones, but the full list is really defined by all the attributes defined in the Option Definitions section.

POSIX-compliant short (flag) option processing.
GNU-style long options processing. Long options are recognized without case sensitivity, and they may be abbreviated.
Environment variable initializations, See section environment variable presets.
Initialization from configuration files (aka RC or INI files), and saving the option state back into one, See section configuration file presets.
Config files may be partitioned. One config file may be used by several programs by partitioning it with lines containing, "[PROGRAM_NAME]", See section configuration file presets.
Options may be marked as dis-abled with a disablement prefix. Such options may default to either an enabled or a disabled state. You may also provide an enablement prefix, too, e.g., --allow-mumble and --prevent-mumble.
Verify that required options are present between the minimum and maximum number of times on the command line.
Verify that conflicting options do not appear together, and that options that require the presence of other options are, in fact, used in the presence of other options.
Provides a callable routine to parse a text string as if it were from one of the rc/ini/config files, hereafter referred to as a configuration file.
--help and --version are automatically supported. --more-help will page the generated help.
By adding a `doc' and `arg-name' attributes to each option, AutoGen will also be able to produce a man page and the `invoking' section of a texinfo document.
Insert the option processing state into Scheme-defined variables. Thus, Guile based applications that are linked with private main() routines can take advantage of all of AutoOpts' functionality.
Various forms of main procedures can be added to the output, See section Generating main procedures. There are four basic forms:
1. A program that processes the arguments and writes to standard out portable shell commands containing the digested options.
2. A program that will generate portable shell commands to parse the defined options. The expectation is that this result will be copied into a shell script and used there.
3. A "for-each" main that will invoke a named function once for either each non-option argument on the command line or, if there are none, then once for each non-blank, non-comment input line read from stdin.
4. A main procedure of your own design. Its code can be supplied in the option description template or by incorporating another template.
Library suppliers can specify command line options that their client programs will accept. They specify option definitions that get #include-d into the client option definitions and they specify an "anchor" option that has a callback and must be invoked. That will give the library access to the option state for their options.
The generated usage text can be emitted in either AutoOpts standard format (maximizing the information about each option), or GNU-ish normal form. The default form is selected by either specifying or not specifying the gnu-usage attribute (see section Program Information Attributes). This can be overridden by the user himself with the AUTOOPTS_USAGE environment variable. If it exists and is set to the string gnu, it will force GNU-ish style format; if it is set to the string autoopts, it will force AutoOpts standard format; otherwise, it will have no effect.
If you compile with ENABLE_NLS defined and _() defined to a localization function such as gettext(3GNU), then the option processing code will be localizable (see section Internationalizing AutoOpts).
Intermingled option processing. AutoOpts options may be intermingled with command line operands and options processed with other parsing techniques. This is accomplished by setting the allow-errors (see section Program Description Attributes) attribute. When processing reaches a point where optionProcess (see section optionProcess) needs to be called again, the current option can be set with RESTART_OPT(n) (see section RESTART_OPT( n ) - Resume Option Processing) before calling optionProcess.
See: See section Options for Library Code.
library options. An AutoOpt-ed library may export its options for use in an AutoOpt-ed program. This is done by providing an option definition file that client programs #include into their own option definitions. See "AutoOpt-ed Library for AutoOpt-ed Program" (see section AutoOpt-ed Library for AutoOpt-ed Program) for more details.

7.2 AutoOpts Licensing

When AutoGen is installed, the AutoOpts project is installed with it. AutoOpts includes various AutoGen templates and a pair of shared libraries. These libraries may be used under the terms of the GNU Lesser General Public License (LGPL).

One of these libraries (libopts) is needed by programs that are built using AutoOpts generated code. This library is available as a separate "tear-off" source tarball. It is redistributable for use under either of two licenses: The GNU Lesser General Public License ("Lesser" meaning you have greater license with it and may link it into commercial programs), and the advertising-clause-free BSD license. Both of these license terms are incorporated into appropriate COPYING files included with the libopts source tarball. This source may be incorporated into your package with the following simple commands:

rm -rf liboptsliboptslIndex]

7.1 AutoOpts Features

AutoOpts supports option processing; option state saving; and program documentation with innumerable features. Here, we list a few obvious ones and some important ones, but the full list is really defined by all the attributes defined in the Option Definitions section.

POSIX-compliant short (flag) option processing.
GNU-style long options processing. Long options are recognized without case sensitivity, and they may be abbreviated.
Environment variable initializations, See section environment variable presets.
Initialization from configuration files (aka RC or INI files), and saving the option state back into one, See section configuration file presets.
Config files may be partitioned. One config file may be used by several programs by partitioning it with lines containing, "[PROGRAM_NAME]", See section configuration file presets.
Options may be marked as dis-abled with a disablement prefix. Such options may default to either an enabled or a disabled state. You may also provide an enablement prefix, too, e.g., --allow-mumble and --prevent-mumble.
Verify that required options are present between the minimum and maximum number of times on the command line.
Verify that conflicting options do not appear together, and that options that require the presence of other options are, in fact, used in the presence of other options.
Provides a callable routine to parse a text string as if it were from one of the rc/ini/config files, hereafter referred to as a configuration file.
--help and --version are automatically supported. --more-help will page the generated help.
By adding a `doc' and `arg-name' attributes to each option, AutoGen will also be able to produce a man page and the `invoking' section of a texinfo document.
Insert the option processing state into Scheme-defined variables. Thus, Guile based applications that are linked with private main() routines can take advantage of all of AutoOpts' functionality.
Various forms of main procedures can be added to the output, See section Generating main procedures. There are four basic forms:
1. A program that processes the arguments and writes to standard out portable shell commands containing the digested options.
2. A program that will generate portable shell commands to parse the defined options. The expectation is that this result will be copied into a shell script and used there.
3. A "for-each" main that will invoke a named function once for either each non-option argument on the command line or, if there are none, then once for each non-blank, non-comment input line read from stdin.
4. A main procedure of your own design. Its code can be supplied in the option description template or by incorporating another template.
Library suppliers can specify command line options that their client programs will accept. They specify option definitions that get #include-d into the client option definitions and they specify an "anchor" option that has a callback and must be invoked. That will give the library access to the option state for their options.
The generated usage text can be emitted in either AutoOpts standard format (maximizing the information about each option), or GNU-ish normal form. The default form is selected by either specifying or not specifying the gnu-usage attribute (see section Program Information Attributes). This can be overridden by the user himself with the AUTOOPTS_USAGE environment variable. If it exists and is set to the string gnu, it will force GNU-ish style format; if it is set to the string autoopts, it will force AutoOpts standard format; otherwise, it will have no effect.
If you compile with ENABLE_NLS defined and _() defined to a localization function such as gettext(3GNU), then the option processing code will be localizable (see section Internationalizing AutoOpts).
Intermingled option processing. AutoOpts options may be intermingled with command line operands and options processed with other parsing techniques. This is accomplished by setting the allow-errors (see section Program Description Attributes) attribute. When processing reaches a point where optionProcess (see section optionProcess) needs to be called again, the current option can be set with RESTART_OPT(n) (see section RESTART_OPT( n ) - Resume Option Processing) before calling optionProcess.
See: See section Options for Library Code.
library options. An AutoOpt-ed library may export its options for use in an AutoOpt-ed program. This is done by providing an option definition file that client programs #include into their own option definitions. See "AutoOpt-ed Library for AutoOpt-ed Program" (see section AutoOpt-ed Library for AutoOpt-ed Program) for more details.

7.2 AutoOpts Licensing

When AutoGen is installed, the AutoOpts project is installed with it. AutoOpts includes various AutoGen templates and a pair of shared libraries. These libraries may be used under the terms of the GNU Lesser General Public License (LGPL).

One of these libraries (libopts) is needed by programs that are built using AutoOpts generated code. This library is available as a separate "tear-off" source tarball. It is redistributable for use under either of two licenses: The GNU Lesser General Public License ("Lesser" meaning you have greater license with it and may link it into commercial programs), and the advertising-clause-free BSD license. Both of these license terms are incorporated into appropriate COPYING files included with the libopts source tarball. This source may be incorporated into your package with the following simple commands:

rm -rf liboptsliboptslIndex]

7.1 AutoOpts Features

AutoOpts supports option processing; option state saving; and program documentation with innumerable features. Here, we list a few obvious ones and some important ones, but the full list is really defined by all the attributes defined in the Option Definitions section.

POSIX-compliant short (flag) option processing.
GNU-style long options processing. Long options are recognized without case sensitivity, and they may be abbreviated.
Environment variable initializations, See section environment variable presets.
Initialization from configuration files (aka RC or INI files), and saving the option state back into one, See section configuration file presets.
Config files may be partitioned. One config file may be used by several programs by partitioning it with lines containing, "[PROGRAM_NAME]", See section configuration file presets.
Options may be marked as dis-abled with a disablement prefix. Such options may default to either an enabled or a disabled state. You may also provide an enablement prefix, too, e.g., --allow-mumble and --prevent-mumble.
Verify that required options are present between the minimum and maximum number of times on the command line.
Verify that conflicting options do not appear together, and that options that require the presence of other options are, in fact, used in the presence of other options.
Provides a callable routine to parse a text string as if it were from one of the rc/ini/config files, hereafter referred to as a configuration file.
--help and --version are automatically supported. --more-help will page the generated help.
By adding a `doc' and `arg-name' attributes to each option, AutoGen will also be able to produce a man page and the `invoking' section of a texinfo document.
Insert the option processing state into Scheme-defined variables. Thus, Guile based applications that are linked with private main() routines can take advantage of all of AutoOpts' functionality.
Various forms of main procedures can be added to the output, See section Generating main procedures. There are four basic forms:
1. A program that processes the arguments and writes to standard out portable shell commands containing the digested options.
2. A program that will generate portable shell commands to parse the defined options. The expectation is that this result will be copied into a shell script and used there.
3. A "for-each" main that will invoke a named function once for either each non-option argument on the command line or, if there are none, then once for each non-blank, non-comment input line read from stdin.
4. A main procedure of your own design. Its code can be supplied in the option description template or by incorporating another template.
Library suppliers can specify command line options that their client programs will accept. They specify option definitions that get #include-d into the client option definitions and they specify an "anchor" option that has a callback and must be invoked. That will give the library access to the option state for their options.
The generated usage text can be emitted in either AutoOpts standard format (maximizing the information about each option), or GNU-ish normal form. The default form is selected by either specifying or not specifying the gnu-usage attribute (see section Program Information Attributes). This can be overridden by the user himself with the AUTOOPTS_USAGE environment variable. If it exists and is set to the string gnu, it will force GNU-ish style format; if it is set to the string autoopts, it will force AutoOpts standard format; otherwise, it will have no effect.
If you compile with ENABLE_NLS defined and _() defined to a localization function such as gettext(3GNU), then the option processing code will be localizable (see section Internationalizing AutoOpts).
Intermingled option processing. AutoOpts options may be intermingled with command line operands and options processed with other parsing techniques. This is accomplished by setting the allow-errors (see section Program Description Attributes) attribute. When processing reaches a point where optionProcess (see section optionProcess) needs to be called again, the current option can be set with RESTART_OPT(n) (see section RESTART_OPT( n ) - Resume Option Processing) before calling optionProcess.
See: See section Options for Library Code.
library options. An AutoOpt-ed library may export its options for use in an AutoOpt-ed program. This is done by providing an option definition file that client programs #include into their own option definitions. See "AutoOpt-ed Library for AutoOpt-ed Program" (see section AutoOpt-ed Library for AutoOpt-ed Program) for more details.

7.2 AutoOpts Licensing

When AutoGen is installed, the AutoOpts project is installed with it. AutoOpts includes various AutoGen templates and a pair of shared libraries. These libraries may be used under the terms of the GNU Lesser General Public License (LGPL).

One of these libraries (libopts) is needed by programs that are built using AutoOpts generated code. This library is available as a separate "tear-off" source tarball. It is redistributable for use under either of two licenses: The GNU Lesser General Public License ("Lesser" meaning you have greater license with it and may link it into commercial programs), and the advertising-clause-free BSD license. Both of these license terms are incorporated into appropriate COPYING files included with the libopts source tarball. This source may be incorporated into your package with the following simple commands:

rm -rf liboptsliboptslIndex]

7.1 AutoOpts Features

AutoOpts supports option processing; option state saving; and program documentation with innumerable features. Here, we list a few obvious ones and some important ones, but the full list is really defined by all the attributes defined in the Option Definitions section.

POSIX-compliant short (flag) option processing.
GNU-style long options processing. Long options are recognized without case sensitivity, and they may be abbreviated.
Environment variable initializations, See section environment variable presets.
Initialization from configuration files (aka RC or INI files), and saving the option state back into one, See section configuration file presets.
Config files may be partitioned. One config file may be used by several programs by partitioning it with lines containing, "[PROGRAM_NAME]", See section configuration file presets.
Options may be marked as dis-abled with a disablement prefix. Such options may default to either an enabled or a disabled state. You may also provide an enablement prefix, too, e.g., --allow-mumble and --prevent-mumble.
Verify that required options are present between the minimum and maximum number of times on the command line.
Verify that conflicting options do not appear together, and that options that require the presence of other options are, in fact, used in the presence of other options.
Provides a callable routine to parse a text string as if it were from one of the rc/ini/config files, hereafter referred to as a configuration file.
--help and --version are automatically supported. --more-help will page the generated help.
By adding a `doc' and `arg-name' attributes to each option, AutoGen will also be able to produce a man page and the `invoking' section of a texinfo document.
Insert the option processing state into Scheme-defined variables. Thus, Guile based applications that are linked with private main() routines can take advantage of all of AutoOpts' functionality.
Various forms of main procedures can be added to the output, See section Generating main procedures. There are four basic forms:
1. A program that processes the arguments and writes to standard out portable shell commands containing the digested options.
2. A program that will generate portable shell commands to parse the defined options. The expectation is that this result will be copied into a shell script and used there.
3. A "for-each" main that will invoke a named function once for either each non-option argument on the command line or, if there are none, then once for each non-blank, non-comment input line read from stdin.
4. A main procedure of your own design. Its code can be supplied in the option description template or by incorporating another template.
Library suppliers can specify command line options that their client programs will accept. They specify option definitions that get #include-d into the client option definitions and they specify an "anchor" option that has a callback and must be invoked. That will give the library access to the option state for their options.
The generated usage text can be emitted in either AutoOpts standard format (maximizing the information about each option), or GNU-ish normal form. The default form is selected by either specifying or not specifying the gnu-usage attribute (see section Program Information Attributes). This can be overridden by the user himself with the AUTOOPTS_USAGE environment variable. If it exists and is set to the string gnu, it will force GNU-ish style format; if it is set to the string autoopts, it will force AutoOpts standard format; otherwise, it will have no effect.
If you compile with ENABLE_NLS defined and _() defined to a localization function such as gettext(3GNU), then the option processing code will be localizable (see section Internationalizing AutoOpts).
Intermingled option processing. AutoOpts options may be intermingled with command line operands and options processed with other parsing techniques. This is accomplished by setting the allow-errors (see section Program Description Attributes) attribute. When processing reaches a point where optionProcess (see section optionProcess) needs to be called again, the current option can be set with RESTART_OPT(n) (see section RESTART_OPT( n ) - Resume Option Processing) before calling optionProcess.
See: See section Options for Library Code.
library options. An AutoOpt-ed library may export its options for use in an AutoOpt-ed program. This is done by providing an option definition file that client programs #include into their own option definitions. See "AutoOpt-ed Library for AutoOpt-ed Program" (see section AutoOpt-ed Library for AutoOpt-ed Program) for more details.

7.2 AutoOpts Licensing

When AutoGen is installed, the AutoOpts project is installed with it. AutoOpts includes various AutoGen templates and a pair of shared libraries. These libraries may be used under the terms of the GNU Lesser General Public License (LGPL).

One of these libraries (libopts) is needed by programs that are built using AutoOpts generated code. This library is available as a separate "tear-off" source tarball. It is redistributable for use under either of two licenses: The GNU Lesser General Public License ("Lesser" meaning you have greater license with it and may link it into commercial programs), and the advertising-clause-free BSD license. Both of these license terms are incorporated into appropriate COPYING files included with the libopts source tarball. This source may be incorporated into your package with the following simple commands:

rm -rf liboptsliboptslIndex]

7.1 AutoOpts Features

AutoOpts supports option processing; option state saving; and program documentation with innumerable features. Here, we list a few obvious ones and some important ones, but the full list is really defined by all the attributes defined in the Option Definitions section.

POSIX-compliant short (flag) option processing.
GNU-style long options processing. Long options are recognized without case sensitivity, and they may be abbreviated.
Environment variable initializations, See section environment variable presets.
Initialization from configuration files (aka RC or INI files), and saving the option state back into one, See section configuration file presets.
Config files may be partitioned. One config file may be used by several programs by partitioning it with lines containing, "[PROGRAM_NAME]", See section configuration file presets.
Options may be marked as dis-abled with a disablement prefix. Such options may default to either an enabled or a disabled state. You may also provide an enablement prefix, too, e.g., --allow-mumble and --prevent-mumble.
Verify that required options are present between the minimum and maximum number of times on the command line.
Verify that conflicting options do not appear together, and that options that require the presence of other options are, in fact, used in the presence of other options.
Provides a callable routine to parse a text string as if it were from one of the rc/ini/config files, hereafter referred to as a configuration file.
--help and --version are automatically supported. --more-help will page the generated help.
By adding a `doc' and `arg-name' attributes to each option, AutoGen will also be able to produce a man page and the `invoking' section of a texinfo document.
Insert the option processing state into Scheme-defined variables. Thus, Guile based applications that are linked with private main() routines can take advantage of all of AutoOpts' functionality.
Various forms of main procedures can be added to the output, See section Generating main procedures. There are four basic forms:
1. A program that processes the arguments and writes to standard out portable shell commands containing the digested options.
2. A program that will generate portable shell commands to parse the defined options. The expectation is that this result will be copied into a shell script and used there.
3. A "for-each" main that will invoke a named function once for either each non-option argument on the command line or, if there are none, then once for each non-blank, non-comment input line read from stdin.
4. A main procedure of your own design. Its code can be supplied in the option description template or by incorporating another template.
Library suppliers can specify command line options that their client programs will accept. They specify option definitions that get #include-d into the client option definitions and they specify an "anchor" option that has a callback and must be invoked. That will give the library access to the option state for their options.
The generated usage text can be emitted in either AutoOpts standard format (maximizing the information about each option), or GNU-ish normal form. The default form is selected by either specifying or not specifying the gnu-usage attribute (see section Program Information Attributes). This can be overridden by the user himself with the AUTOOPTS_USAGE environment variable. If it exists and is set to the string gnu, it will force GNU-ish style format; if it is set to the string autoopts, it will force AutoOpts standard format; otherwise, it will have no effect.
If you compile with ENABLE_NLS defined and _() defined to a localization function such as gettext(3GNU), then the option processing code will be localizable (see section Internationalizing AutoOpts).
Intermingled option processing. AutoOpts options may be intermingled with command line operands and options processed with other parsing techniques. This is accomplished by setting the allow-errors (see section Program Description Attributes) attribute. When processing reaches a point where optionProcess (see section optionProcess) needs to be called again, the current option can be set with RESTART_OPT(n) (see section RESTART_OPT( n ) - Resume Option Processing) before calling optionProcess.
See: See section Options for Library Code.
library options. An AutoOpt-ed library may export its options for use in an AutoOpt-ed program. This is done by providing an option definition file that client programs #include into their own option definitions. See "AutoOpt-ed Library for AutoOpt-ed Program" (see section AutoOpt-ed Library for AutoOpt-ed Program) for more details.

7.2 AutoOpts Licensing

When AutoGen is installed, the AutoOpts project is installed with it. AutoOpts includes various AutoGen templates and a pair of shared libraries. These libraries may be used under the terms of the GNU Lesser General Public License (LGPL).

One of these libraries (libopts) is needed by programs that are built using AutoOpts generated code. This library is available as a separate "tear-off" source tarball. It is redistributable for use under either of two licenses: The GNU Lesser General Public License ("Lesser" meaning you have greater license with it and may link it into commercial programs), and the advertising-clause-free BSD license. Both of these license terms are incorporated into appropriate COPYING files included with the libopts source tarball. This source may be incorporated into your package with the following simple commands:

rm -rf liboptsliboptslIndex]

7.1 AutoOpts Features

AutoOpts supports option processing; option state saving; and program documentation with innumerable features. Here, we list a few obvious ones and some important ones, but the full list is really defined by all the attributes defined in the Option Definitions section.

POSIX-compliant short (flag) option processing.
GNU-style long options processing. Long options are recognized without case sensitivity, and they may be abbreviated.
Environment variable initializations, See section environment variable presets.
Initialization from configuration files (aka RC or INI files), and saving the option state back into one, See section configuration file presets.
Config files may be partitioned. One config file may be used by several programs by partitioning it with lines containing, "[PROGRAM_NAME]", See section configuration file presets.
Options may be marked as dis-abled with a disablement prefix. Such options may default to either an enabled or a disabled state. You may also provide an enablement prefix, too, e.g., --allow-mumble and --prevent-mumble.
Verify that required options are present between the minimum and maximum number of times on the command line.
Verify that conflicting options do not appear together, and that options that require the presence of other options are, in fact, used in the presence of other options.
Provides a callable routine to parse a text string as if it were from one of the rc/ini/config files, hereafter referred to as a configuration file.
--help and --version are automatically supported. --more-help will page the generated help.
By adding a `doc' and `arg-name' attributes to each option, AutoGen will also be able to produce a man page and the `invoking' section of a texinfo document.
Insert the option processing state into Scheme-defined variables. Thus, Guile based applications that are linked with private main() routines can take advantage of all of AutoOpts' functionality.
Various forms of main procedures can be added to the output, See section Generating main procedures. There are four basic forms:
1. A program that processes the arguments and writes to standard out portable shell commands containing the digested options.
2. A program that will generate portable shell commands to parse the defined options. The expectation is that this result will be copied into a shell script and used there.
3. A "for-each" main that will invoke a named function once for either each non-option argument on the command line or, if there are none, then once for each non-blank, non-comment input line read from stdin.
4. A main procedure of your own design. Its code can be supplied in the option description template or by incorporating another template.
Library suppliers can specify command line options that their client programs will accept. They specify option definitions that get #include-d into the client option definitions and they specify an "anchor" option that has a callback and must be invoked. That will give the library access to the option state for their options.
The generated usage text can be emitted in either AutoOpts standard format (maximizing the information about each option), or GNU-ish normal form. The default form is selected by either specifying or not specifying the gnu-usage attribute (see section Program Information Attributes). This can be overridden by the user himself with the AUTOOPTS_USAGE environment variable. If it exists and is set to the string gnu, it will force GNU-ish style format; if it is set to the string autoopts, it will force AutoOpts standard format; otherwise, it will have no effect.
If you compile with ENABLE_NLS defined and _() defined to a localization function such as gettext(3GNU), then the option processing code will be localizable (see section Internationalizing AutoOpts).
Intermingled option processing. AutoOpts options may be intermingled with command line operands and options processed with other parsing techniques. This is accomplished by setting the allow-errors (see section Program Description Attributes) attribute. When processing reaches a point where optionProcess (see section optionProcess) needs to be called again, the current option can be set with RESTART_OPT(n) (see section RESTART_OPT( n ) - Resume Option Processing) before calling optionProcess.
See: See section Options for Library Code.
library options. An AutoOpt-ed library may export its options for use in an AutoOpt-ed program. This is done by providing an option definition file that client programs #include into their own option definitions. See "AutoOpt-ed Library for AutoOpt-ed Program" (see section AutoOpt-ed Library for AutoOpt-ed Program) for more details.

7.2 AutoOpts Licensing

When AutoGen is installed, the AutoOpts project is installed with it. AutoOpts includes various AutoGen templates and a pair of shared libraries. These libraries may be used under the terms of the GNU Lesser General Public License (LGPL).

One of these libraries (libopts) is needed by programs that are built using AutoOpts generated code. This library is available as a separate "tear-off" source tarball. It is redistributable for use under either of two licenses: The GNU Lesser General Public License ("Lesser" meaning you have greater license with it and may link it into commercial programs), and the advertising-clause-free BSD license. Both of these license terms are incorporated into appropriate COPYING files included with the libopts source tarball. This source may be incorporated into your package with the following simple commands:

rm -rf liboptsliboptslIndex]

7.1 AutoOpts Features

AutoOpts supports option processing; option state saving; and program documentation with innumerable features. Here, we list a few obvious ones and some important ones, but the full list is really defined by all the attributes defined in the Option Definitions section.

POSIX-compliant short (flag) option processing.
GNU-style long options processing. Long options are recognized without case sensitivity, and they may be abbreviated.
Environment variable initializations, See section environment variable presets.
Initialization from configuration files (aka RC or INI files), and saving the option state back into one, See section configuration file presets.
Config files may be partitioned. One config file may be used by several programs by partitioning it with lines containing, "[PROGRAM_NAME]", See section configuration file presets.
Options may be marked as dis-abled with a disablement prefix. Such options may default to either an enabled or a disabled state. You may also provide an enablement prefix, too, e.g., --allow-mumble and --prevent-mumble.
Verify that required options are present between the minimum and maximum number of times on the command line.
Verify that conflicting options do not appear together, and that options that require the presence of other options are, in fact, used in the presence of other options.
Provides a callable routine to parse a text string as if it were from one of the rc/ini/config files, hereafter referred to as a configuration file.
--help and --version are automatically supported. --more-help will page the generated help.
By adding a `doc' and `arg-name' attributes to each option, AutoGen will also be able to produce a man page and the `invoking' section of a texinfo document.
Insert the option processing state into Scheme-defined variables. Thus, Guile based applications that are linked with private main() routines can take advantage of all of AutoOpts' functionality.
Various forms of main procedures can be added to the output, See section Generating main procedures. There are four basic forms:
1. A program that processes the arguments and writes to standard out portable shell commands containing the digested options.
2. A program that will generate portable shell commands to parse the defined options. The expectation is that this result will be copied into a shell script and used there.
3. A "for-each" main that will invoke a named function once for either each non-option argument on the command line or, if there are none, then once for each non-blank, non-comment input line read from stdin.
4. A main procedure of your own design. Its code can be supplied in the option description template or by incorporating another template.
Library suppliers can specify command line options that their client programs will accept. They specify option definitions that get #include-d into the client option definitions and they specify an "anchor" option that has a callback and must be invoked. That will give the library access to the option state for their options.
The generated usage text can be emitted in either AutoOpts standard format (maximizing the information about each option), or GNU-ish normal form. The default form is selected by either specifying or not specifying the gnu-usage attribute (see section Program Information Attributes). This can be overridden by the user himself with the AUTOOPTS_USAGE environment variable. If it exists and is set to the string gnu, it will force GNU-ish style format; if it is set to the string autoopts, it will force AutoOpts standard format; otherwise, it will have no effect.
If you compile with ENABLE_NLS defined and _() defined to a localization function such as gettext(3GNU), then the option processing code will be localizable (see section Internationalizing AutoOpts).
Intermingled option processing. AutoOpts options may be intermingled with command line operands and options processed with other parsing techniques. This is accomplished by setting the allow-errors (see section Program Description Attributes) attribute. When processing reaches a point where optionProcess (see section optionProcess) needs to be called again, the current option can be set with RESTART_OPT(n) (see section RESTART_OPT( n ) - Resume Option Processing) before calling optionProcess.
See: See section Options for Library Code.
library options. An AutoOpt-ed library may export its options for use in an AutoOpt-ed program. This is done by providing an option definition file that client programs #include into their own option definitions. See "AutoOpt-ed Library for AutoOpt-ed Program" (see section AutoOpt-ed Library for AutoOpt-ed Program) for more details.

7.2 AutoOpts Licensing

When AutoGen is installed, the AutoOpts project is installed with it. AutoOpts includes various AutoGen templates and a pair of shared libraries. These libraries may be used under the terms of the GNU Lesser General Public License (LGPL).

One of these libraries (libopts) is needed by programs that are built using AutoOpts generated code. This library is available as a separate "tear-off" source tarball. It is redistributable for use under either of two licenses: The GNU Lesser General Public License ("Lesser" meaning you have greater license with it and may link it into commercial programs), and the advertising-clause-free BSD license. Both of these license terms are incorporated into appropriate COPYING files included with the libopts source tarball. This source may be incorporated into your package with the following simple commands:

rm -rf liboptsliboptslIndex]

7.1 AutoOpts Features

AutoOpts supports option processing; option state saving; and program documentation with innumerable features. Here, we list a few obvious ones and some important ones, but the full list is really defined by all the attributes defined in the Option Definitions section.

POSIX-compliant short (flag) option processing.
GNU-style long options processing. Long options are recognized without case sensitivity, and they may be abbreviated.
Environment variable initializations, See section environment variable presets.
Initialization from configuration files (aka RC or INI files), and saving the option state back into one, See section configuration file presets.
Config files may be partitioned. One config file may be used by several programs by partitioning it with lines containing, "[PROGRAM_NAME]", See section configuration file presets.
Options may be marked as dis-abled with a disablement prefix. Such options may default to either an enabled or a disabled state. You may also provide an enablement prefix, too, e.g., --allow-mumble and --prevent-mumble.
Verify that required options are present between the minimum and maximum number of times on the command line.
Verify that conflicting options do not appear together, and that options that require the presence of other options are, in fact, used in the presence of other options.
Provides a callable routine to parse a text string as if it were from one of the rc/ini/config files, hereafter referred to as a configuration file.
--help and --version are automatically supported. --more-help will page the generated help.
By adding a `doc' and `arg-name' attributes to each option, AutoGen will also be able to produce a man page and the `invoking' section of a texinfo document.
Insert the option processing state into Scheme-defined variables. Thus, Guile based applications that are linked with private main() routines can take advantage of all of AutoOpts' functionality.
Various forms of main procedures can be added to the output, See section Generating main procedures. There are four basic forms:
1. A program that processes the arguments and writes to standard out portable shell commands containing the digested options.
2. A program that will generate portable shell commands to parse the defined options. The expectation is that this result will be copied into a shell script and used there.
3. A "for-each" main that will invoke a named function once for either each non-option argument on the command line or, if there are none, then once for each non-blank, non-comment input line read from stdin.
4. A main procedure of your own design. Its code can be supplied in the option description template or by incorporating another template.
Library suppliers can specify command line options that their client programs will accept. They specify option definitions that get #include-d into the client option definitions and they specify an "anchor" option that has a callback and must be invoked. That will give the library access to the option state for their options.
The generated usage text can be emitted in either AutoOpts standard format (maximizing the information about each option), or GNU-ish normal form. The default form is selected by either specifying or not specifying the gnu-usage attribute (see section Program Information Attributes). This can be overridden by the user himself with the AUTOOPTS_USAGE environment variable. If it exists and is set to the string gnu, it will force GNU-ish style format; if it is set to the string autoopts, it will force AutoOpts standard format; otherwise, it will have no effect.
If you compile with ENABLE_NLS defined and _() defined to a localization function such as gettext(3GNU), then the option processing code will be localizable (see section Internationalizing AutoOpts).
Intermingled option processing. AutoOpts options may be intermingled with command line operands and options processed with other parsing techniques. This is accomplished by setting the allow-errors (see section Program Description Attributes) attribute. When processing reaches a point where optionProcess (see section optionProcess) needs to be called again, the current option can be set with RESTART_OPT(n) (see section RESTART_OPT( n ) - Resume Option Processing) before calling optionProcess.
See: See section Options for Library Code.
library options. An AutoOpt-ed library may export its options for use in an AutoOpt-ed program. This is done by providing an option definition file that client programs #include into their own option definitions. See "AutoOpt-ed Library for AutoOpt-ed Program" (see section AutoOpt-ed Library for AutoOpt-ed Program) for more details.

7.2 AutoOpts Licensing

When AutoGen is installed, the AutoOpts project is installed with it. AutoOpts includes various AutoGen templates and a pair of shared libraries. These libraries may be used under the terms of the GNU Lesser General Public License (LGPL).

One of these libraries (libopts) is needed by programs that are built using AutoOpts generated code. This library is available as a separate "tear-off" source tarball. It is redistributable for use under either of two licenses: The GNU Lesser General Public License ("Lesser" meaning you have greater license with it and may link it into commercial programs), and the advertising-clause-free BSD license. Both of these license terms are incorporated into appropriate COPYING files included with the libopts source tarball. This source may be incorporated into your package with the following simple commands:

rm -rf liboptsliboptslIndex]

7.1 AutoOpts Features

AutoOpts supports option processing; option state saving; and program documentation with innumerable features. Here, we list a few obvious ones and some important ones, but the full list is really defined by all the attributes defined in the Option Definitions section.

POSIX-compliant short (flag) option processing.
GNU-style long options processing. Long options are recognized without case sensitivity, and they may be abbreviated.
Environment variable initializations, See section environment variable presets.
Initialization from configuration files (aka RC or INI files), and saving the option state back into one, See section configuration file presets.
Config files may be partitioned. One config file may be used by several programs by partitioning it with lines containing, "[PROGRAM_NAME]", See section configuration file presets.
Options may be marked as dis-abled with a disablement prefix. Such options may default to either an enabled or a disabled state. You may also provide an enablement prefix, too, e.g., --allow-mumble and --prevent-mumble.
Verify that required options are present between the minimum and maximum number of times on the command line.
Verify that conflicting options do not appear together, and that options that require the presence of other options are, in fact, used in the presence of other options.
Provides a callable routine to parse a text string as if it were from one of the rc/ini/config files, hereafter referred to as a configuration file.
--help and --version are automatically supported. --more-help will page the generated help.
By adding a `doc' and `arg-name' attributes to each option, AutoGen will also be able to produce a man page and the `invoking' section of a texinfo document.
Insert the option processing state into Scheme-defined variables. Thus, Guile based applications that are linked with private main() routines can take advantage of all of AutoOpts' functionality.
Various forms of main procedures can be added to the output, See section Generating main procedures. There are four basic forms:
1. A program that processes the arguments and writes to standard out portable shell commands containing the digested options.
2. A program that will generate portable shell commands to parse the defined options. The expectation is that this result will be copied into a shell script and used there.
3. A "for-each" main that will invoke a named function once for either each non-option argument on the command line or, if there are none, then once for each non-blank, non-comment input line read from stdin.
4. A main procedure of your own design. Its code can be supplied in the option description template or by incorporating another template.
Library suppliers can specify command line options that their client programs will accept. They specify option definitions that get #include-d into the client option definitions and they specify an "anchor" option that has a callback and must be invoked. That will give the library access to the option state for their options.
The generated usage text can be emitted in either AutoOpts standard format (maximizing the information about each option), or GNU-ish normal form. The default form is selected by either specifying or not specifying the gnu-usage attribute (see section Program Information Attributes). This can be overridden by the user himself with the AUTOOPTS_USAGE environment variable. If it exists and is set to the string gnu, it will force GNU-ish style format; if it is set to the string autoopts, it will force AutoOpts standard format; otherwise, it will have no effect.
If you compile with ENABLE_NLS defined and _() defined to a localization function such as gettext(3GNU), then the option processing code will be localizable (see section Internationalizing AutoOpts).
Intermingled option processing. AutoOpts options may be intermingled with command line operands and options processed with other parsing techniques. This is accomplished by setting the allow-errors (see section Program Description Attributes) attribute. When processing reaches a point where optionProcess (see section optionProcess) needs to be called again, the current option can be set with RESTART_OPT(n) (see section RESTART_OPT( n ) - Resume Option Processing) before calling optionProcess.
See: See section Options for Library Code.
library options. An AutoOpt-ed library may export its options for use in an AutoOpt-ed program. This is done by providing an option definition file that client programs #include into their own option definitions. See "AutoOpt-ed Library for AutoOpt-ed Program" (see section AutoOpt-ed Library for AutoOpt-ed Program) for more details.

7.2 AutoOpts Licensing

When AutoGen is installed, the AutoOpts project is installed with it. AutoOpts includes various AutoGen templates and a pair of shared libraries. These libraries may be used under the terms of the GNU Lesser General Public License (LGPL).

One of these libraries (libopts) is needed by programs that are built using AutoOpts generated code. This library is available as a separate "tear-off" source tarball. It is redistributable for use under either of two licenses: The GNU Lesser General Public License ("Lesser" meaning you have greater license with it and may link it into commercial programs), and the advertising-clause-free BSD license. Both of these license terms are incorporated into appropriate COPYING files included with the libopts source tarball. This source may be incorporated into your package with the following simple commands:

rm -rf liboptsliboptslIndex]

7.1 AutoOpts Features

AutoOpts supports option processing; option state saving; and program documentation with innumerable features. Here, we list a few obvious ones and some important ones, but the full list is really defined by all the attributes defined in the Option Definitions section.

POSIX-compliant short (flag) option processing.
GNU-style long options processing. Long options are recognized without case sensitivity, and they may be abbreviated.
Environment variable initializations, See section environment variable presets.
Initialization from configuration files (aka RC or INI files), and saving the option state back into one, See section configuration file presets.
Config files may be partitioned. One config file may be used by several programs by partitioning it with lines containing, "[PROGRAM_NAME]", See section configuration file presets.
Options may be marked as dis-abled with a disablement prefix. Such options may default to either an enabled or a disabled state. You may also provide an enablement prefix, too, e.g., --allow-mumble and --prevent-mumble.
Verify that required options are present between the minimum and maximum number of times on the command line.
Verify that conflicting options do not appear together, and that options that require the presence of other options are, in fact, used in the presence of other options.
Provides a callable routine to parse a text string as if it were from one of the rc/ini/config files, hereafter referred to as a configuration file.
--help and --version are automatically supported. --more-help will page the generated help.
By adding a `doc' and `arg-name' attributes to each option, AutoGen will also be able to produce a man page and the `invoking' section of a texinfo document.
Insert the option processing state into Scheme-defined variables. Thus, Guile based applications that are linked with private main() routines can take advantage of all of AutoOpts' functionality.
Various forms of main procedures can be added to the output, See section Generating main procedures. There are four basic forms:
1. A program that processes the arguments and writes to standard out portable shell commands containing the digested options.
2. A program that will generate portable shell commands to parse the defined options. The expectation is that this result will be copied into a shell script and used there.
3. A "for-each" main that will invoke a named function once for either each non-option argument on the command line or, if there are none, then once for each non-blank, non-comment input line read from stdin.
4. A main procedure of your own design. Its code can be supplied in the option description template or by incorporating another template.
Library suppliers can specify command line options that their client programs will accept. They specify option definitions that get #include-d into the client option definitions and they specify an "anchor" option that has a callback and must be invoked. That will give the library access to the option state for their options.
The generated usage text can be emitted in either AutoOpts standard format (maximizing the information about each option), or GNU-ish normal form. The default form is selected by either specifying or not specifying the gnu-usage attribute (see section Program Information Attributes). This can be overridden by the user himself with the AUTOOPTS_USAGE environment variable. If it exists and is set to the string gnu, it will force GNU-ish style format; if it is set to the string autoopts, it will force AutoOpts standard format; otherwise, it will have no effect.
If you compile with ENABLE_NLS defined and _() defined to a localization function such as gettext(3GNU), then the option processing code will be localizable (see section Internationalizing AutoOpts).
Intermingled option processing. AutoOpts options may be intermingled with command line operands and options processed with other parsing techniques. This is accomplished by setting the allow-errors (see section Program Description Attributes) attribute. When processing reaches a point where optionProcess (see section optionProcess) needs to be called again, the current option can be set with RESTART_OPT(n) (see section RESTART_OPT( n ) - Resume Option Processing) before calling optionProcess.
See: See section Options for Library Code.
library options. An AutoOpt-ed library may export its options for use in an AutoOpt-ed program. This is done by providing an option definition file that client programs #include into their own option definitions. See "AutoOpt-ed Library for AutoOpt-ed Program" (see section AutoOpt-ed Library for AutoOpt-ed Program) for more details.

7.2 AutoOpts Licensing

When AutoGen is installed, the AutoOpts project is installed with it. AutoOpts includes various AutoGen templates and a pair of shared libraries. These libraries may be used under the terms of the GNU Lesser General Public License (LGPL).

One of these libraries (libopts) is needed by programs that are built using AutoOpts generated code. This library is available as a separate "tear-off" source tarball. It is redistributable for use under either of two licenses: The GNU Lesser General Public License ("Lesser" meaning you have greater license with it and may link it into commercial programs), and the advertising-clause-free BSD license. Both of these license terms are incorporated into appropriate COPYING files included with the libopts source tarball. This source may be incorporated into your package with the following simple commands:

rm -rf liboptsliboptslIndex]

7.1 AutoOpts Features

AutoOpts supports option processing; option state saving; and program documentation with innumerable features. Here, we list a few obvious ones and some important ones, but the full list is really defined by all the attributes defined in the Option Definitions section.

POSIX-compliant short (flag) option processing.
GNU-style long options processing. Long options are recognized without case sensitivity, and they may be abbreviated.
Environment variable initializations, See section environment variable presets.
Initialization from configuration files (aka RC or INI files), and saving the option state back into one, See section configuration file presets.
Config files may be partitioned. One config file may be used by several programs by partitioning it with lines containing, "[PROGRAM_NAME]", See section configuration file presets.
Options may be marked as dis-abled with a disablement prefix. Such options may default to either an enabled or a disabled state. You may also provide an enablement prefix, too, e.g., --allow-mumble and --prevent-mumble.
Verify that required options are present between the minimum and maximum number of times on the command line.
Verify that conflicting options do not appear together, and that options that require the presence of other options are, in fact, used in the presence of other options.
Provides a callable routine to parse a text string as if it were from one of the rc/ini/config files, hereafter referred to as a configuration file.
--help and --version are automatically supported. --more-help will page the generated help.
By adding a `doc' and `arg-name' attributes to each option, AutoGen will also be able to produce a man page and the `invoking' section of a texinfo document