The utility-arguments Reference Manual

Table of Contents

Next: , Previous: , Up: (dir)   [Contents][Index]

The utility-arguments Reference Manual

This is the utility-arguments Reference Manual, version 0.161029, generated automatically by Declt version 2.4 "Will Decker" on Wed Jun 20 12:44:19 2018 GMT+0.


Next: , Previous: , Up: Top   [Contents][Index]

1 Introduction

Utility Arguments

Utility Arguments is a Common Lisp software that handles command-line arguments. The adopted argument syntax is described in the POSIX and the GNU conventions.

Features

Dependencies

Installation

Utility Arguments is hosted on Gitlab.com. The master branch points to the most recent release.

The easiest way to install Utility Arguments is through Quicklisp.

Alternatively, either download a tarball from the project's website or clone the Git repository. Put the source code where ASDF can find it. The system utility-arguments can then be loaded and compiled.

Overview

Utility arguments are formatted strings that conform to the POSIX and the GNU argument syntax conventions. To summarize it here: Option specifications start with one or two hyphens followed by alphanumeric characters. Everything that is not an option specification is an operand. A double hyphen terminates options, i.e., everything to the right of it is considered an operand.

Commonly, the utility arguments will be the arguments received on the command-line. To retrieve the command-line arguments in a portable way, use the function uiop:command-line-arguments.

A usage, which is defined with the macro defusage, can be thought of as a Lisp function applicable to a set of utility arguments. Its positional and keyword parameters receive the values of operands and options. Type parsing can be requested through objects handed over to the function apply-usage; otherwise, a string trimmed of white space at both ends is passed as value.

Usages are applied to utility arguments with the function apply-usage. Among other arguments, it receives two lists of operand and option objects that complement the parameters on usage lambda lists in providing additional type and syntactic information.

A usage is applicable to a set of utility arguments if there is a correlated parameter for each operand and option, and if all parameters are satisfied on the usage lambda list.

API

Symbols exported from the package utility-arguments comprise the API and are documented by their docstrings. The examples below cover the majority of the API.

Example

In this example we create the outline for a hypothetical encryption utility to demonstrate how to use Utility Arguments.

We devise usages to encrypt and decrypt files. The usages are implemented with the macro defusage. Positional parameters on the first lambda list describe operands, and keyword parameters on the second lambda list describe options. Parameters receive the values of operands and options.

(defusage encrypt ((infile &optional outfile)
                   (&key encrypt (algorithm 'aes) (keysize 256)))
  (declare (ignore encrypt))
  ;; code...
  )

(defusage decrypt ((infile &optional outfile)
                   (&key decrypt algorithm keysize))
  (declare (ignore decrypt))
  ;; code...
  )

For the encryption usage we made algorithm and keysize optional options by specifying an init-form for the keyword parameters.

We have no real use for the encrypt and decrypt parameters inside the body of the usages; however, they are essential for the usages to be distinguishable from each other.

We create operand objects that complement the positional parameters on the usage lambda lists. Correlation is established by option key and parameter name. For type we pass a function object instead of a Lisp type specifier, which gives us full control over the received argument.

(defun probe-infile (string designator)
  (when (not (uiop:probe-file* string))
    (warn "File ~s specified for ~a does not exist." string designator))
  string)

(defun probe-outfile (string designator)
  (when (uiop:probe-file* string)
    (warn "File ~s specified for ~a does already exist." string designator))
  string)

(defparameter *operands*
  (list (make-operand :key 'infile  :type #'probe-infile)
        (make-operand :key 'outfile :type #'probe-outfile)))

We create option objects that complement the keyword parameters on the usage lambda lists. Correlation is established by option key and parameter name. Different kind of options are available. We specify key, short and long designators, and for options that receive an argument a Lisp type specifier. For type parsing, the Lisp reader is used.

(defparameter *options*
  (list (make-option-flag
         :key :encrypt :short #\e :long "encrypt")
        (make-option-flag
         :key :decrypt :short #\d :long "decrypt")
        (make-option-with-argument
         :key :algorithm :short #\a :long "algorithm" :type '(or (eql aes) (eql des)))
        (make-option-with-argument
         :key :keysize :short #\s :long "keysize" :type '(integer 128))))

We apply the usages to utility arguments with the function apply-usage. The next two examples succeed.

(apply-usage '(encrypt decrypt) *operands* *options*
             (list "--encrypt" "secret.txt" "secret.enc"))

(apply-usage '(encrypt decrypt) *operands* *options*
             (list "--decrypt" "secret.enc" "-aAES" "--keysize=256"))

This example signals a utility-argument-error condition, because we didn't make any provisions for an option --help.

(apply-usage '(encrypt decrypt) *operands* *options*
             (list "--help"))

This example signals a usage-error condition, because we did not devise such usage. We need at least an input-file operand for this to succeed.

(apply-usage '(encrypt decrypt) *operands* *options*
             (list "--encrypt"))

The reason defusage takes two lambda lists instead of one is to allow for a rest parameter to be specified for operands and options each, like in the next example.

(defusage foo ((&rest ints)
               (&rest options &key x &allow-other-keys))
  ;; code...
  )

To successfully apply the usage, we need to provide the option x. Additionally any other option and integer operands are accepted.

(apply-usage '(foo)
             (list (make-operand :key 'ints :type ' (integer * 0)))
             (list (make-option-flag :key :x :short #\x)
                   (make-option-flag :key :y :short #\y))
             (list "-xy" "--" "-3" "-7"))

Next: , Previous: , Up: Top   [Contents][Index]

2 Systems

The main system appears first, followed by any subsystem dependency.


Previous: , Up: Systems   [Contents][Index]

2.1 utility-arguments

Author

Frank A. U.

Contact

fau@riseup.net

License

ICS

Description

Utility to handle command-line arguments.

Version

0.161029

Dependency

alexandria

Source

utility-arguments.asd (file)

Components

Next: , Previous: , Up: Top   [Contents][Index]

3 Files

Files are sorted by type and then listed depth-first from the systems components trees.


Previous: , Up: Files   [Contents][Index]

3.1 Lisp


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.1 utility-arguments.asd

Location

utility-arguments.asd

Systems

utility-arguments (system)


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.2 utility-arguments/packages.lisp

Parent

utility-arguments (system)

Location

packages.lisp

Packages

utility-arguments


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.3 utility-arguments/utils.lisp

Dependency

packages.lisp (file)

Parent

utility-arguments (system)

Location

utils.lisp

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.4 utility-arguments/error.lisp

Dependency

utils.lisp (file)

Parent

utility-arguments (system)

Location

error.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.5 utility-arguments/option.lisp

Dependency

error.lisp (file)

Parent

utility-arguments (system)

Location

option.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.6 utility-arguments/parser.lisp

Dependency

option.lisp (file)

Parent

utility-arguments (system)

Location

parser.lisp

Exported Definitions

*separator* (special variable)

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.7 utility-arguments/operand.lisp

Dependency

parser.lisp (file)

Parent

utility-arguments (system)

Location

operand.lisp

Exported Definitions
Internal Definitions

Previous: , Up: Lisp files   [Contents][Index]

3.1.8 utility-arguments/usage.lisp

Dependency

operand.lisp (file)

Parent

utility-arguments (system)

Location

usage.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Top   [Contents][Index]

4 Packages

Packages are listed by definition order.


Previous: , Up: Packages   [Contents][Index]

4.1 utility-arguments

Source

packages.lisp (file)

Use List
Exported Definitions
Internal Definitions

Next: , Previous: , Up: Top   [Contents][Index]

5 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


Next: , Previous: , Up: Definitions   [Contents][Index]

5.1 Exported definitions


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.1 Special variables

Special Variable: *separator*

Character that separates the arguments in a sequence. Setting it to nil, disables separation.

Package

utility-arguments

Source

parser.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.2 Macros

Macro: defusage NAME (OPERAND-LAMBDA-LIST OPTION-LAMBDA-LIST) &body BODY

Define a new usage for operands and options.

NAME is a symbol and denotes the name of the usage.

OPERAND-LAMBDA-LIST describes operands. It resembles a lambda list with required, optional, or rest parameter specifiers as the only elements allowed. The parameters receive the operands’ values.

OPTION-LAMBDA-LIST describes options. It resembles a lambda list with keyword and rest parameter specifiers as the only elements allowed. The parameters receive the options’ values.

Optional and keyword parameter that specify an init-form make it optional in this usage.

The forms of BODY are executed when the usage is applied.

Package

utility-arguments

Source

usage.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.3 Functions

Function: apply-usage USAGES OPERANDS OPTIONS UTILITY-ARGUMENTS

Apply a usage to utility arguments.

USAGES is a list of symbols naming usages defined with defusage.

The lists OPERANDS and OPTIONS hold objects that complement the parameters on usage lambda lists in providing additional type and syntactic information. Correlation is established by object key and parameter name.

UTILITY-ARGUMENTS is a list of strings that is parsed into operands and options. The operand and options are matched against the usage lambda lists to find a suitable usage which is then applied to the operand’s and option’s values.

An error condition of utility-argument-error, no-such-usage, or usage-conflict may be signaled.

Package

utility-arguments

Source

usage.lisp (file)

Function: find-operand KEY OPERANDS

Find operand identifiable by KEY.

KEY is a symbol. OPERANDS is a list of operand objects.

Package

utility-arguments

Source

operand.lisp (file)

Function: make-operand &key KEY TYPE

Make a new operand.

KEY is a symbol that correlates the operand with a positional parameter on a usage lambda list.

The parameter TYPE is documented in make-option-with-argument.

Package

utility-arguments

Source

operand.lisp (file)

Function: make-option-flag &key KEY SHORT LONG

Make a new option flag.

Its number of appearances on a utility argument list is the assumed value.

The parameters KEY, SHORT, and LONG are documented in make-option-with-argument.

Package

utility-arguments

Source

option.lisp (file)

Function: make-option-with-argument &key KEY SHORT LONG TYPE

Make a new option that receives one argument.

KEY is a symbol that correlates the option with a keyword parameter on a usage lambda list.

SHORT is a case-sensitive character. LONG is a case-insensitive but case-preserving string. Both designators are equivalent and request the option on a utility argument list. At least one of the two must be specified.

TYPE is a Lisp type specifier the object must conform to the Lisp reader builds from the received argument. The built object becomes the assumed value.

TYPE is a function of two string arguments: the first of which is the received argument for the option, and the second the designator that requested the option. The object returned becomes the assumed value.

TYPE is nil, the received argument is the assumed value.

Package

utility-arguments

Source

option.lisp (file)

Function: make-option-with-optional-argument &key KEY SHORT LONG TYPE

Make a new option that optionally receives one argument.

If the option doesn’t receive an argument, nil is assumed.

The parameters KEY, SHORT, LONG, and TYPE are documented in make-option-with-argument.

Package

utility-arguments

Source

option.lisp (file)

Function: make-option-with-optional-sequence &key KEY SHORT LONG TYPE

Make a new option that optionally receives a sequence of arguments.

If the option doesn’t receive an argument, nil is assumed. See also make-option-with-sequence.

The parameters KEY, SHORT, LONG, and TYPE are documented in make-option-with-argument.

Package

utility-arguments

Source

option.lisp (file)

Function: make-option-with-sequence &key KEY SHORT LONG TYPE

Make a new option that receives a sequence of arguments.

Multiple arguments in a sequence are separated from each other by the separator registered with *separator*.

Received arguments are subject to type parsing as described in make-option-with-argument. The assumed values are collected into a list by order of utility arguments.

The parameters KEY, SHORT, LONG, and TYPE are documented in make-option-with-argument.

Package

utility-arguments

Source

option.lisp (file)

Function: no-such-usage UTILITY-ARGUMENTS
Package

utility-arguments

Source

error.lisp (file)

Function: usage-conflict USAGES
Package

utility-arguments

Source

error.lisp (file)

Function: utility-argument-error CONTROL &rest ARGUMENTS
Package

utility-arguments

Source

error.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.4 Generic functions

Generic Function: conflicting-usages CONDITION
Package

utility-arguments

Methods
Method: conflicting-usages (CONDITION usage-conflict)
Source

error.lisp (file)

Generic Function: find-option ITEM OPTIONS

Find option identifiable by ITEM.

ITEM is either a symbol, character, or a string. OPTIONS is a list of option objects.

Package

utility-arguments

Source

option.lisp (file)

Methods
Method: find-option (LONG string) OPTIONS
Method: find-option (SHORT character) OPTIONS
Method: find-option (KEY symbol) OPTIONS
Generic Function: utility-arguments CONDITION
Package

utility-arguments

Methods
Method: utility-arguments (CONDITION no-such-usage)
Source

error.lisp (file)


Previous: , Up: Exported definitions   [Contents][Index]

5.1.5 Conditions

Condition: no-such-usage ()

Condition signaled if no suitable usage was found.

Package

utility-arguments

Source

error.lisp (file)

Direct superclasses

usage-error (condition)

Direct methods

utility-arguments (method)

Direct slots
Slot: utility-arguments
Initargs

:utility-arguments

Readers

utility-arguments (generic function)

Condition: usage-conflict ()

Condition signaled if more than one suitable usage was found.

Package

utility-arguments

Source

error.lisp (file)

Direct superclasses

usage-error (condition)

Direct methods

conflicting-usages (method)

Direct slots
Slot: usages
Initargs

:usages

Readers

conflicting-usages (generic function)

Condition: usage-error ()

Condition signaled for usage related errors.

Package

utility-arguments

Source

error.lisp (file)

Direct superclasses

error (condition)

Direct subclasses
Condition: utility-argument-error ()

Condition signaled for utility argument related errors, such as bad syntax, unknown options, or type errors.

Package

utility-arguments

Source

error.lisp (file)

Direct superclasses

error (condition)

Direct methods

utility-argument-error-text (method)

Direct slots
Slot: text
Initargs

:text

Readers

utility-argument-error-text (generic function)


Previous: , Up: Definitions   [Contents][Index]

5.2 Internal definitions


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.1 Functions

Function: allow-other-keys-lambda? LAMBDA-LIST
Package

utility-arguments

Source

utils.lisp (file)

Function: blank? CHAR
Package

utility-arguments

Source

utils.lisp (file)

Function: complete-usage ARITY KEYS USAGES
Package

utility-arguments

Source

usage.lisp (file)

Function: csv STRING
Package

utility-arguments

Source

parser.lisp (file)

Function: end-of-options? STRING
Package

utility-arguments

Source

parser.lisp (file)

Function: excessive-option-arguments DESIGNATOR ARGUMENTS
Package

utility-arguments

Source

error.lisp (file)

Function: find-all-usages ARITY KEYS USAGES
Package

utility-arguments

Source

usage.lisp (file)

Function: invalid-operand-argument DESIGNATOR ARGUMENT TYPE
Package

utility-arguments

Source

error.lisp (file)

Function: invalid-option-argument DESIGNATOR ARGUMENT TYPE
Package

utility-arguments

Source

error.lisp (file)

Function: lambda-arity LAMBDA-LIST
Package

utility-arguments

Source

utils.lisp (file)

Function: lambda-key-parameters LAMBDA-LIST
Package

utility-arguments

Source

utils.lisp (file)

Function: lambda-variables LAMBDA-LIST
Package

utility-arguments

Source

utils.lisp (file)

Function: long-option? STRING
Package

utility-arguments

Source

parser.lisp (file)

Function: missing-option-argument DESIGNATOR
Package

utility-arguments

Source

error.lisp (file)

Function: no-such-option LITERAL
Package

utility-arguments

Source

error.lisp (file)

Function: normalize-space STRING
Package

utility-arguments

Source

utils.lisp (file)

Function: operand-lambda-list USAGE
Package

utility-arguments

Source

usage.lisp (file)

Function: option-lambda-list USAGE
Package

utility-arguments

Source

usage.lisp (file)

Function: parse-long-spec SPEC UTILITY-ARGUMENTS OPTIONS PLIST
Package

utility-arguments

Source

parser.lisp (file)

Function: parse-operand-argument ARGUMENT OPERAND
Package

utility-arguments

Source

operand.lisp (file)

Function: parse-operands OPERANDS ARGUMENTS USAGE
Package

utility-arguments

Source

usage.lisp (file)

Function: parse-option-argument STRING OPTION DESIGNATOR
Package

utility-arguments

Source

option.lisp (file)

Function: parse-short-spec SPEC UTILITY-ARGUMENTS OPTIONS PLIST
Package

utility-arguments

Source

parser.lisp (file)

Function: parse-utility-arguments UTILITY-ARGUMENTS OPTIONS
Package

utility-arguments

Source

parser.lisp (file)

Function: plist-keys PLIST
Package

utility-arguments

Source

utils.lisp (file)

Function: plist-keys-if PREDICATE PLIST
Package

utility-arguments

Source

utils.lisp (file)

Function: separate SEQUENCE SEPARATOR
Package

utility-arguments

Source

utils.lisp (file)

Function: short-option? STRING
Package

utility-arguments

Source

parser.lisp (file)

Function: split-at SEQUENCE POSITION
Package

utility-arguments

Source

utils.lisp (file)

Function: split-long-spec STRING
Package

utility-arguments

Source

parser.lisp (file)

Function: syntax-error LITERAL
Package

utility-arguments

Source

error.lisp (file)

Function: trim-space STRING
Package

utility-arguments

Source

utils.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.2 Generic functions

Generic Function: parse-option OPTION DESIGNATOR PLIST UTILITY-ARGUMENTS ARGUMENT
Package

utility-arguments

Source

parser.lisp (file)

Methods
Method: parse-option (SELF option-with-optional-sequence) DESIGNATOR PLIST UTILITY-ARGUMENTS ARGUMENT
Method: parse-option (SELF option-with-sequence) DESIGNATOR PLIST UTILITY-ARGUMENTS ARGUMENT
Method: parse-option (SELF option-with-optional-argument) DESIGNATOR PLIST UTILITY-ARGUMENTS ARGUMENT
Method: parse-option (SELF option-with-argument) DESIGNATOR PLIST UTILITY-ARGUMENTS ARGUMENT
Method: parse-option (SELF option-flag) DESIGNATOR PLIST UTILITY-ARGUMENTS ARGUMENT
Generic Function: utility-argument-error-text CONDITION
Package

utility-arguments

Methods
Method: utility-argument-error-text (CONDITION utility-argument-error)
Source

error.lisp (file)


Previous: , Up: Internal definitions   [Contents][Index]

5.2.3 Classes

Class: operand ()
Package

utility-arguments

Source

operand.lisp (file)

Direct superclasses

standard-object (class)

Direct methods

initialize-instance (method)

Direct slots
Slot: key
Initargs

:key

Slot: type
Initargs

:type

Class: option ()
Package

utility-arguments

Source

option.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods

initialize-instance (method)

Direct slots
Slot: key
Initargs

:key

Slot: short
Initargs

:short

Slot: long
Initargs

:long

Slot: type
Initargs

:type

Class: option-flag ()
Package

utility-arguments

Source

option.lisp (file)

Direct superclasses

option (class)

Direct methods

parse-option (method)

Class: option-with-argument ()
Package

utility-arguments

Source

option.lisp (file)

Direct superclasses

option (class)

Direct methods

parse-option (method)

Class: option-with-optional-argument ()
Package

utility-arguments

Source

option.lisp (file)

Direct superclasses

option (class)

Direct methods

parse-option (method)

Class: option-with-optional-sequence ()
Package

utility-arguments

Source

option.lisp (file)

Direct superclasses

option (class)

Direct methods

parse-option (method)

Class: option-with-sequence ()
Package

utility-arguments

Source

option.lisp (file)

Direct superclasses

option (class)

Direct methods

parse-option (method)


Previous: , Up: Top   [Contents][Index]

Appendix A Indexes


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts

Jump to:   F   L   U  
Index Entry  Section

F
File, Lisp, utility-arguments.asd: The utility-arguments<dot>asd file
File, Lisp, utility-arguments/error.lisp: The utility-arguments/error<dot>lisp file
File, Lisp, utility-arguments/operand.lisp: The utility-arguments/operand<dot>lisp file
File, Lisp, utility-arguments/option.lisp: The utility-arguments/option<dot>lisp file
File, Lisp, utility-arguments/packages.lisp: The utility-arguments/packages<dot>lisp file
File, Lisp, utility-arguments/parser.lisp: The utility-arguments/parser<dot>lisp file
File, Lisp, utility-arguments/usage.lisp: The utility-arguments/usage<dot>lisp file
File, Lisp, utility-arguments/utils.lisp: The utility-arguments/utils<dot>lisp file

L
Lisp File, utility-arguments.asd: The utility-arguments<dot>asd file
Lisp File, utility-arguments/error.lisp: The utility-arguments/error<dot>lisp file
Lisp File, utility-arguments/operand.lisp: The utility-arguments/operand<dot>lisp file
Lisp File, utility-arguments/option.lisp: The utility-arguments/option<dot>lisp file
Lisp File, utility-arguments/packages.lisp: The utility-arguments/packages<dot>lisp file
Lisp File, utility-arguments/parser.lisp: The utility-arguments/parser<dot>lisp file
Lisp File, utility-arguments/usage.lisp: The utility-arguments/usage<dot>lisp file
Lisp File, utility-arguments/utils.lisp: The utility-arguments/utils<dot>lisp file

U
utility-arguments.asd: The utility-arguments<dot>asd file
utility-arguments/error.lisp: The utility-arguments/error<dot>lisp file
utility-arguments/operand.lisp: The utility-arguments/operand<dot>lisp file
utility-arguments/option.lisp: The utility-arguments/option<dot>lisp file
utility-arguments/packages.lisp: The utility-arguments/packages<dot>lisp file
utility-arguments/parser.lisp: The utility-arguments/parser<dot>lisp file
utility-arguments/usage.lisp: The utility-arguments/usage<dot>lisp file
utility-arguments/utils.lisp: The utility-arguments/utils<dot>lisp file

Jump to:   F   L   U  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.2 Functions

Jump to:   A   B   C   D   E   F   G   I   L   M   N   O   P   S   T   U  
Index Entry  Section

A
allow-other-keys-lambda?: Internal functions
apply-usage: Exported functions

B
blank?: Internal functions

C
complete-usage: Internal functions
conflicting-usages: Exported generic functions
conflicting-usages: Exported generic functions
csv: Internal functions

D
defusage: Exported macros

E
end-of-options?: Internal functions
excessive-option-arguments: Internal functions

F
find-all-usages: Internal functions
find-operand: Exported functions
find-option: Exported generic functions
find-option: Exported generic functions
find-option: Exported generic functions
find-option: Exported generic functions
Function, allow-other-keys-lambda?: Internal functions
Function, apply-usage: Exported functions
Function, blank?: Internal functions
Function, complete-usage: Internal functions
Function, csv: Internal functions
Function, end-of-options?: Internal functions
Function, excessive-option-arguments: Internal functions
Function, find-all-usages: Internal functions
Function, find-operand: Exported functions
Function, invalid-operand-argument: Internal functions
Function, invalid-option-argument: Internal functions
Function, lambda-arity: Internal functions
Function, lambda-key-parameters: Internal functions
Function, lambda-variables: Internal functions
Function, long-option?: Internal functions
Function, make-operand: Exported functions
Function, make-option-flag: Exported functions
Function, make-option-with-argument: Exported functions
Function, make-option-with-optional-argument: Exported functions
Function, make-option-with-optional-sequence: Exported functions
Function, make-option-with-sequence: Exported functions
Function, missing-option-argument: Internal functions
Function, no-such-option: Internal functions
Function, no-such-usage: Exported functions
Function, normalize-space: Internal functions
Function, operand-lambda-list: Internal functions
Function, option-lambda-list: Internal functions
Function, parse-long-spec: Internal functions
Function, parse-operand-argument: Internal functions
Function, parse-operands: Internal functions
Function, parse-option-argument: Internal functions
Function, parse-short-spec: Internal functions
Function, parse-utility-arguments: Internal functions
Function, plist-keys: Internal functions
Function, plist-keys-if: Internal functions
Function, separate: Internal functions
Function, short-option?: Internal functions
Function, split-at: Internal functions
Function, split-long-spec: Internal functions
Function, syntax-error: Internal functions
Function, trim-space: Internal functions
Function, usage-conflict: Exported functions
Function, utility-argument-error: Exported functions

G
Generic Function, conflicting-usages: Exported generic functions
Generic Function, find-option: Exported generic functions
Generic Function, parse-option: Internal generic functions
Generic Function, utility-argument-error-text: Internal generic functions
Generic Function, utility-arguments: Exported generic functions

I
invalid-operand-argument: Internal functions
invalid-option-argument: Internal functions

L
lambda-arity: Internal functions
lambda-key-parameters: Internal functions
lambda-variables: Internal functions
long-option?: Internal functions

M
Macro, defusage: Exported macros
make-operand: Exported functions
make-option-flag: Exported functions
make-option-with-argument: Exported functions
make-option-with-optional-argument: Exported functions
make-option-with-optional-sequence: Exported functions
make-option-with-sequence: Exported functions
Method, conflicting-usages: Exported generic functions
Method, find-option: Exported generic functions
Method, find-option: Exported generic functions
Method, find-option: Exported generic functions
Method, parse-option: Internal generic functions
Method, parse-option: Internal generic functions
Method, parse-option: Internal generic functions
Method, parse-option: Internal generic functions
Method, parse-option: Internal generic functions
Method, utility-argument-error-text: Internal generic functions
Method, utility-arguments: Exported generic functions
missing-option-argument: Internal functions

N
no-such-option: Internal functions
no-such-usage: Exported functions
normalize-space: Internal functions

O
operand-lambda-list: Internal functions
option-lambda-list: Internal functions

P
parse-long-spec: Internal functions
parse-operand-argument: Internal functions
parse-operands: Internal functions
parse-option: Internal generic functions
parse-option: Internal generic functions
parse-option: Internal generic functions
parse-option: Internal generic functions
parse-option: Internal generic functions
parse-option: Internal generic functions
parse-option-argument: Internal functions
parse-short-spec: Internal functions
parse-utility-arguments: Internal functions
plist-keys: Internal functions
plist-keys-if: Internal functions

S
separate: Internal functions
short-option?: Internal functions
split-at: Internal functions
split-long-spec: Internal functions
syntax-error: Internal functions

T
trim-space: Internal functions

U
usage-conflict: Exported functions
utility-argument-error: Exported functions
utility-argument-error-text: Internal generic functions
utility-argument-error-text: Internal generic functions
utility-arguments: Exported generic functions
utility-arguments: Exported generic functions

Jump to:   A   B   C   D   E   F   G   I   L   M   N   O   P   S   T   U  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.3 Variables

Jump to:   *  
K   L   S   T   U  
Index Entry  Section

*
*separator*: Exported special variables

K
key: Internal classes
key: Internal classes

L
long: Internal classes

S
short: Internal classes
Slot, key: Internal classes
Slot, key: Internal classes
Slot, long: Internal classes
Slot, short: Internal classes
Slot, text: Exported conditions
Slot, type: Internal classes
Slot, type: Internal classes
Slot, usages: Exported conditions
Slot, utility-arguments: Exported conditions
Special Variable, *separator*: Exported special variables

T
text: Exported conditions
type: Internal classes
type: Internal classes

U
usages: Exported conditions
utility-arguments: Exported conditions

Jump to:   *  
K   L   S   T   U  

Previous: , Up: Indexes   [Contents][Index]

A.4 Data types

Jump to:   C   N   O   P   S   U  
Index Entry  Section

C
Class, operand: Internal classes
Class, option: Internal classes
Class, option-flag: Internal classes
Class, option-with-argument: Internal classes
Class, option-with-optional-argument: Internal classes
Class, option-with-optional-sequence: Internal classes
Class, option-with-sequence: Internal classes
Condition, no-such-usage: Exported conditions
Condition, usage-conflict: Exported conditions
Condition, usage-error: Exported conditions
Condition, utility-argument-error: Exported conditions

N
no-such-usage: Exported conditions

O
operand: Internal classes
option: Internal classes
option-flag: Internal classes
option-with-argument: Internal classes
option-with-optional-argument: Internal classes
option-with-optional-sequence: Internal classes
option-with-sequence: Internal classes

P
Package, utility-arguments: The utility-arguments package

S
System, utility-arguments: The utility-arguments system

U
usage-conflict: Exported conditions
usage-error: Exported conditions
utility-argument-error: Exported conditions
utility-arguments: The utility-arguments system
utility-arguments: The utility-arguments package

Jump to:   C   N   O   P   S   U