Introduction

Command line is probably the most universal way of passing information from
caller to the program. Concept of a command line is part of most operating
systems and programming languages including C and C++. However model
and terminology for command line processing vary greatly among different
systems.

Single UNIX Specification contains Utility Argument Syntax Conventions and

Guidelines which document basic terminology for command line processing.
Single UNIX Specification model is a "common denominator" for different UNIX
implementations. It is somewhat minimal and targets system utilities rather
than a wide spectrum of applications. Another de-facto command line
processing model is GNU Standard for Command Line Interfaces which
generally encourages conformance to the Single UNIX Specification but adds
few extensions and uses different terminology.

The idea behind this document is to establish terminology and complete model
for command line processing. Terms translation between this document, Single
UNIX Specification and GNU Standard for Command Line Interfaces is provided
in Appendix A.

Model and Terminology

Command line is an array of character strings and not just a string with spaces
between words as some people tend to think.

Each string in a command line array is referred to as argument . First argument

usually contains a string that refers to an executable.

Interpretation of arguments is completely up to a program logic however

conventions exist that vary among different systems. Usually groups of
arguments are translated into a higher-level objects such as commands,
options, and operands. These objects form a model for command line
processing. All of them are defined below.

Command is usually a word, or a single letter that represents a command to

the program logic. Neither Single UNIX Specification nor GNU Standard for
Command Line Interfaces has the notion of a command. Other terms for
command include action and function. Command is usually (but not
necessarily) the first argument after executable name. Here are few examples:

tar x

Here we have a one letter command 'x' (extract). In GNU tar manual it is
called functional letter.

tar xvf

Here we have three commands encoded as a single letter each. Actually

semantically only 'x' is a command while 'v' (verbose) and 'f' (read from a
file) are options.

openssl req

Here we have a word command 'req' (operations with certificate requests).

cvs checkout foo

Here we have a word command 'checkout' and command operand foo.

tar --help

Even though '--help' is usually considered to be an option semantically it is

a command.

Option consists of option name and optionally one or more option values.
Options are usually optional. Non-optional options are usually better
represented by commands or operands.

Option name usually takes up one argument. Option names usually start with a
prefix (e.g. '--compile-only', '-c' or '/c' ). This helps distinguish them from
commands and operands. Option name may have aliases (e.g. for option name
'--output-dir' there could be an '-o' alias).

Option without a value is alway optional and represents an option with implied
binary value (e.g. {0, 1} or {false, true} etc.). Such option is sometimes called
flag.

Option can be associated with a program or a command. Thus the concept of

option can be further refined to program option and command option. Program
option alters behavior of the program as a whole while command option is only
affecting particular command.

Following are some examples:

g++ -o hello.o hello.cpp

Here we have an option with name '-o' which has a value 'hello.o'.
'hello.cpp' is an operand.

ls -l

Here we have a flag with name '-l'.

foo --bar=a,b,c
foo -b "a,b,c"
foo /baz a b c

Here we have a more elaborate example of a multi-format option. It has a

name '--bar' and two aliases: '-b' and '/baz'. It also has three values (in our
case they are 'a', 'b', and 'c').
cvs -z 6 checkout -P foo

Here we have a program option with name '-z' and value '6' (set
compression level to be 6). 'checkout' is a command. -P is a command flag
(prune empty directories). 'foo' is a command operand.

operand usually represents an input value or a parameter. Operands can be

mandatory or optional. Interpretation of operands is usually application-
specific.

Same as with option the concept of operand can be further refined to program
operand and command operand.

Appendix A: Terms Translation

Single UNIX
Term GNU
Specification
command line command line command line
argument argument argument
command -- --
option -- option
option name option name
option value option-argument --
program option -- --
command option -- --
operand operand argument
program operand -- --
command operand -- --