mirror of
git://git.sv.gnu.org/autoconf
synced 2024-12-09 02:10:22 +08:00
2509 lines
74 KiB
Plaintext
2509 lines
74 KiB
Plaintext
\input texinfo @c -*-texinfo-*-
|
|
@c %**start of header
|
|
@setfilename standards.info
|
|
@settitle GNU Coding Standards
|
|
@c UPDATE THIS DATE WHENEVER YOU MAKE CHANGES!
|
|
@set lastupdate 24 January 1995
|
|
@c %**end of header
|
|
|
|
@ifinfo
|
|
@format
|
|
START-INFO-DIR-ENTRY
|
|
* Standards: (standards). GNU coding standards.
|
|
END-INFO-DIR-ENTRY
|
|
@end format
|
|
@end ifinfo
|
|
|
|
@setchapternewpage off
|
|
|
|
@ifinfo
|
|
GNU Coding Standards
|
|
Copyright (C) 1992, 1993, 1994 Free Software Foundation, Inc.
|
|
|
|
Permission is granted to make and distribute verbatim copies of
|
|
this manual provided the copyright notice and this permission notice
|
|
are preserved on all copies.
|
|
|
|
@ignore
|
|
Permission is granted to process this file through TeX and print the
|
|
results, provided the printed document carries copying permission
|
|
notice identical to this one except for the removal of this paragraph
|
|
(this paragraph not being relevant to the printed manual).
|
|
@end ignore
|
|
|
|
Permission is granted to copy and distribute modified versions of this
|
|
manual under the conditions for verbatim copying, provided that the entire
|
|
resulting derived work is distributed under the terms of a permission
|
|
notice identical to this one.
|
|
|
|
Permission is granted to copy and distribute translations of this manual
|
|
into another language, under the above conditions for modified versions,
|
|
except that this permission notice may be stated in a translation approved
|
|
by the Free Software Foundation.
|
|
@end ifinfo
|
|
|
|
@titlepage
|
|
@title GNU Coding Standards
|
|
@author Richard Stallman
|
|
@author last updated @value{lastupdate}
|
|
@page
|
|
|
|
@vskip 0pt plus 1filll
|
|
Copyright @copyright{} 1992, 1993, 1994 Free Software Foundation, Inc.
|
|
|
|
Permission is granted to make and distribute verbatim copies of
|
|
this manual provided the copyright notice and this permission notice
|
|
are preserved on all copies.
|
|
|
|
Permission is granted to copy and distribute modified versions of this
|
|
manual under the conditions for verbatim copying, provided that the entire
|
|
resulting derived work is distributed under the terms of a permission
|
|
notice identical to this one.
|
|
|
|
Permission is granted to copy and distribute translations of this manual
|
|
into another language, under the above conditions for modified versions,
|
|
except that this permission notice may be stated in a translation approved
|
|
by the Free Software Foundation.
|
|
@end titlepage
|
|
|
|
@ifinfo
|
|
@node Top, Preface, (dir), (dir)
|
|
@top Version
|
|
|
|
Last updated @value{lastupdate}.
|
|
@end ifinfo
|
|
|
|
@menu
|
|
* Preface:: About the GNU Coding Standards
|
|
* Reading Non-Free Code:: Referring to Proprietary Programs
|
|
* Contributions:: Accepting Contributions
|
|
* Change Logs:: Recording Changes
|
|
* Compatibility:: Compatibility with Other Implementations
|
|
* Makefile Conventions:: Makefile Conventions
|
|
* Configuration:: How Configuration Should Work
|
|
* Source Language:: Using Languages Other Than C
|
|
* Formatting:: Formatting Your Source Code
|
|
* Comments:: Commenting Your Work
|
|
* Syntactic Conventions:: Clean Use of C Constructs
|
|
* Names:: Naming Variables and Functions
|
|
* Using Extensions:: Using Non-standard Features
|
|
* System Functions:: Portability and ``standard'' library functions
|
|
* Semantics:: Program Behavior for All Programs
|
|
* Errors:: Formatting Error Messages
|
|
* Libraries:: Library Behavior
|
|
* Portability:: Portability As It Applies to GNU
|
|
* User Interfaces:: Standards for Command Line Interfaces
|
|
* Documentation:: Documenting Programs
|
|
* Releases:: Making Releases
|
|
@end menu
|
|
|
|
@node Preface
|
|
@chapter About the GNU Coding Standards
|
|
|
|
The GNU Coding Standards were written by Richard Stallman and other GNU
|
|
Project volunteers. Their purpose is to make the GNU system clean,
|
|
consistent, and easy to install. This document can also be read as a
|
|
guide to write portable, robust and reliable programs. It focuses on
|
|
programs written in C, but many of the rules and principles are useful
|
|
even if you write in another programming language. The rules often
|
|
state reasons for writing in a certain way.
|
|
|
|
Corrections or suggestions regarding this document should be sent to
|
|
@code{gnu@@prep.ai.mit.edu}. If you make a suggestion, please include a
|
|
suggested new wording for it; our time is limited. We prefer a context
|
|
diff to the @file{standards.texi} or @file{make-stds.texi} files, but if
|
|
you don't have those files, please mail your suggestion anyway.
|
|
|
|
This release of the GNU Coding Standards was last updated
|
|
@value{lastupdate}.
|
|
|
|
@node Reading Non-Free Code
|
|
@chapter Referring to Proprietary Programs
|
|
|
|
Don't in any circumstances refer to Unix source code for or during
|
|
your work on GNU! (Or to any other proprietary programs.)
|
|
|
|
If you have a vague recollection of the internals of a Unix program,
|
|
this does not absolutely mean you can't write an imitation of it, but
|
|
do try to organize the imitation internally along different lines,
|
|
because this is likely to make the details of the Unix version
|
|
irrelevant and dissimilar to your results.
|
|
|
|
For example, Unix utilities were generally optimized to minimize
|
|
memory use; if you go for speed instead, your program will be very
|
|
different. You could keep the entire input file in core and scan it
|
|
there instead of using stdio. Use a smarter algorithm discovered more
|
|
recently than the Unix program. Eliminate use of temporary files. Do
|
|
it in one pass instead of two (we did this in the assembler).
|
|
|
|
Or, on the contrary, emphasize simplicity instead of speed. For some
|
|
applications, the speed of today's computers makes simpler algorithms
|
|
adequate.
|
|
|
|
Or go for generality. For example, Unix programs often have static
|
|
tables or fixed-size strings, which make for arbitrary limits; use
|
|
dynamic allocation instead. Make sure your program handles NULs and
|
|
other funny characters in the input files. Add a programming language
|
|
for extensibility and write part of the program in that language.
|
|
|
|
Or turn some parts of the program into independently usable libraries.
|
|
Or use a simple garbage collector instead of tracking precisely when
|
|
to free memory, or use a new GNU facility such as obstacks.
|
|
|
|
|
|
@node Contributions
|
|
@chapter Accepting Contributions
|
|
|
|
If someone else sends you a piece of code to add to the program you are
|
|
working on, we need legal papers to use it---the same sort of legal
|
|
papers we will need to get from you. @emph{Each} significant
|
|
contributor to a program must sign some sort of legal papers in order
|
|
for us to have clear title to the program. The main author alone is not
|
|
enough.
|
|
|
|
So, before adding in any contributions from other people, tell us
|
|
so we can arrange to get the papers. Then wait until we tell you
|
|
that we have received the signed papers, before you actually use the
|
|
contribution.
|
|
|
|
This applies both before you release the program and afterward. If
|
|
you receive diffs to fix a bug, and they make significant change, we
|
|
need legal papers for it.
|
|
|
|
You don't need papers for changes of a few lines here or there, since
|
|
they are not significant for copyright purposes. Also, you don't need
|
|
papers if all you get from the suggestion is some ideas, not actual code
|
|
which you use. For example, if you write a different solution to the
|
|
problem, you don't need to get papers.
|
|
|
|
I know this is frustrating; it's frustrating for us as well. But if
|
|
you don't wait, you are going out on a limb---for example, what if the
|
|
contributor's employer won't sign a disclaimer? You might have to take
|
|
that code out again!
|
|
|
|
The very worst thing is if you forget to tell us about the other
|
|
contributor. We could be very embarrassed in court some day as a
|
|
result.
|
|
|
|
@node Change Logs
|
|
@chapter Change Logs
|
|
|
|
Keep a change log for each directory, describing the changes made to
|
|
source files in that directory. The purpose of this is so that people
|
|
investigating bugs in the future will know about the changes that
|
|
might have introduced the bug. Often a new bug can be found by
|
|
looking at what was recently changed. More importantly, change logs
|
|
can help eliminate conceptual inconsistencies between different parts
|
|
of a program; they can give you a history of how the conflicting
|
|
concepts arose.
|
|
|
|
Use the Emacs command @kbd{M-x add-change-log-entry} to start a new
|
|
entry in the
|
|
change log. An entry should have an asterisk, the name of the changed
|
|
file, and then in parentheses the name of the changed functions,
|
|
variables or whatever, followed by a colon. Then describe the changes
|
|
you made to that function or variable.
|
|
|
|
Separate unrelated entries with blank lines. When two entries
|
|
represent parts of the same change, so that they work together, then
|
|
don't put blank lines between them. Then you can omit the file name
|
|
and the asterisk when successive entries are in the same file.
|
|
|
|
Here are some examples:
|
|
|
|
@example
|
|
* register.el (insert-register): Return nil.
|
|
(jump-to-register): Likewise.
|
|
|
|
* sort.el (sort-subr): Return nil.
|
|
|
|
* tex-mode.el (tex-bibtex-file, tex-file, tex-region):
|
|
Restart the tex shell if process is gone or stopped.
|
|
(tex-shell-running): New function.
|
|
|
|
* expr.c (store_one_arg): Round size up for move_block_to_reg.
|
|
(expand_call): Round up when emitting USE insns.
|
|
* stmt.c (assign_parms): Round size up for move_block_from_reg.
|
|
@end example
|
|
|
|
It's important to name the changed function or variable in full. Don't
|
|
abbreviate them; don't combine them. Subsequent maintainers will often
|
|
search for a function name to find all the change log entries that
|
|
pertain to it; if you abbreviate the name, they won't find it when they
|
|
search. For example, some people are tempted to abbreviate groups of
|
|
function names by writing @samp{* register.el
|
|
(@{insert,jump-to@}-register)}; this is not a good idea, since searching
|
|
for @code{jump-to-register} or @code{insert-register} would not find the
|
|
entry.
|
|
|
|
There's no need to describe the full purpose of the changes or how they
|
|
work together. It is better to put such explanations in comments in the
|
|
code. That's why just ``New function'' is enough; there is a comment
|
|
with the function in the source to explain what it does.
|
|
|
|
However, sometimes it is useful to write one line to describe the
|
|
overall purpose of a large batch of changes.
|
|
|
|
You can think of the change log as a conceptual ``undo list'' which
|
|
explains how earlier versions were different from the current version.
|
|
People can see the current version; they don't need the change log
|
|
to tell them what is in it. What they want from a change log is a
|
|
clear explanation of how the earlier version differed.
|
|
|
|
When you change the calling sequence of a function in a simple
|
|
fashion, and you change all the callers of the function, there is no
|
|
need to make individual entries for all the callers. Just write in
|
|
the entry for the function being called, ``All callers changed.''
|
|
|
|
When you change just comments or doc strings, it is enough to write an
|
|
entry for the file, without mentioning the functions. Write just,
|
|
``Doc fix.'' There's no need to keep a change log for documentation
|
|
files. This is because documentation is not susceptible to bugs that
|
|
are hard to fix. Documentation does not consist of parts that must
|
|
interact in a precisely engineered fashion; to correct an error, you
|
|
need not know the history of the erroneous passage.
|
|
|
|
|
|
@node Compatibility
|
|
@chapter Compatibility with Other Implementations
|
|
|
|
With certain exceptions, utility programs and libraries for GNU should
|
|
be upward compatible with those in Berkeley Unix, and upward compatible
|
|
with @sc{ANSI} C if @sc{ANSI} C specifies their behavior, and upward
|
|
compatible with @sc{POSIX} if @sc{POSIX} specifies their behavior.
|
|
|
|
When these standards conflict, it is useful to offer compatibility
|
|
modes for each of them.
|
|
|
|
@sc{ANSI} C and @sc{POSIX} prohibit many kinds of extensions. Feel
|
|
free to make the extensions anyway, and include a @samp{--ansi} or
|
|
@samp{--compatible} option to turn them off. However, if the extension
|
|
has a significant chance of breaking any real programs or scripts,
|
|
then it is not really upward compatible. Try to redesign its
|
|
interface.
|
|
|
|
Many GNU programs suppress extensions that conflict with POSIX if the
|
|
environment variable @code{POSIXLY_CORRECT} is defined (even if it is
|
|
defined with a null value). Please make your program recognize this
|
|
variable if appropriate.
|
|
|
|
When a feature is used only by users (not by programs or command
|
|
files), and it is done poorly in Unix, feel free to replace it
|
|
completely with something totally different and better. (For example,
|
|
vi is replaced with Emacs.) But it is nice to offer a compatible
|
|
feature as well. (There is a free vi clone, so we offer it.)
|
|
|
|
Additional useful features not in Berkeley Unix are welcome.
|
|
Additional programs with no counterpart in Unix may be useful,
|
|
but our first priority is usually to duplicate what Unix already
|
|
has.
|
|
|
|
@comment The makefile standards are in a separate file that is also
|
|
@comment included by make.texinfo. Done by roland@gnu.ai.mit.edu on 1/6/93.
|
|
@include make-stds.texi
|
|
|
|
@node Configuration
|
|
@chapter How Configuration Should Work
|
|
|
|
Each GNU distribution should come with a shell script named
|
|
@code{configure}. This script is given arguments which describe the
|
|
kind of machine and system you want to compile the program for.
|
|
|
|
The @code{configure} script must record the configuration options so
|
|
that they affect compilation.
|
|
|
|
One way to do this is to make a link from a standard name such as
|
|
@file{config.h} to the proper configuration file for the chosen system.
|
|
If you use this technique, the distribution should @emph{not} contain a
|
|
file named @file{config.h}. This is so that people won't be able to
|
|
build the program without configuring it first.
|
|
|
|
Another thing that @code{configure} can do is to edit the Makefile. If
|
|
you do this, the distribution should @emph{not} contain a file named
|
|
@file{Makefile}. Instead, include a file @file{Makefile.in} which
|
|
contains the input used for editing. Once again, this is so that people
|
|
won't be able to build the program without configuring it first.
|
|
|
|
If @code{configure} does write the @file{Makefile}, then @file{Makefile}
|
|
should have a target named @file{Makefile} which causes @code{configure}
|
|
to be rerun, setting up the same configuration that was set up last
|
|
time. The files that @code{configure} reads should be listed as
|
|
dependencies of @file{Makefile}.
|
|
|
|
All the files which are output from the @code{configure} script should
|
|
have comments at the beginning explaining that they were generated
|
|
automatically using @code{configure}. This is so that users won't think
|
|
of trying to edit them by hand.
|
|
|
|
The @code{configure} script should write a file named @file{config.status}
|
|
which describes which configuration options were specified when the
|
|
program was last configured. This file should be a shell script which,
|
|
if run, will recreate the same configuration.
|
|
|
|
The @code{configure} script should accept an option of the form
|
|
@samp{--srcdir=@var{dirname}} to specify the directory where sources are found
|
|
(if it is not the current directory). This makes it possible to build
|
|
the program in a separate directory, so that the actual source directory
|
|
is not modified.
|
|
|
|
If the user does not specify @samp{--srcdir}, then @code{configure} should
|
|
check both @file{.} and @file{..} to see if it can find the sources. If
|
|
it finds the sources in one of these places, it should use them from
|
|
there. Otherwise, it should report that it cannot find the sources, and
|
|
should exit with nonzero status.
|
|
|
|
Usually the easy way to support @samp{--srcdir} is by editing a
|
|
definition of @code{VPATH} into the Makefile. Some rules may need to
|
|
refer explicitly to the specified source directory. To make this
|
|
possible, @code{configure} can add to the Makefile a variable named
|
|
@code{srcdir} whose value is precisely the specified directory.
|
|
|
|
The @code{configure} script should also take an argument which specifies the
|
|
type of system to build the program for. This argument should look like
|
|
this:
|
|
|
|
@example
|
|
@var{cpu}-@var{company}-@var{system}
|
|
@end example
|
|
|
|
For example, a Sun 3 might be @samp{m68k-sun-sunos4.1}.
|
|
|
|
The @code{configure} script needs to be able to decode all plausible
|
|
alternatives for how to describe a machine. Thus, @samp{sun3-sunos4.1}
|
|
would be a valid alias. For many programs, @samp{vax-dec-ultrix} would
|
|
be an alias for @samp{vax-dec-bsd}, simply because the differences
|
|
between Ultrix and @sc{BSD} are rarely noticeable, but a few programs
|
|
might need to distinguish them.
|
|
@c Real 4.4BSD now runs on some Suns.
|
|
|
|
There is a shell script called @file{config.sub} that you can use
|
|
as a subroutine to validate system types and canonicalize aliases.
|
|
|
|
Other options are permitted to specify in more detail the software
|
|
or hardware present on the machine, and include or exclude optional
|
|
parts of the package:
|
|
|
|
@table @samp
|
|
@item --enable-@var{feature}@r{[}=@var{parameter}@r{]}
|
|
Configure the package to build and install an optional user-level
|
|
facility called @var{feature}. This allows users to choose which
|
|
optional features to include. Giving an optional @var{parameter} of
|
|
@samp{no} should omit @var{feature}, if it is built by default.
|
|
|
|
No @samp{--enable} option should @strong{ever} cause one feature to
|
|
replace another. No @samp{--enable} option should ever substitute one
|
|
useful behavior for another useful behavior. The only proper use for
|
|
@samp{--enable} is for questions of whether to build part of the program
|
|
or exclude it.
|
|
|
|
@item --with-@var{package}
|
|
@c @r{[}=@var{parameter}@r{]}
|
|
The package @var{package} will be installed, so configure this package
|
|
to work with @var{package}.
|
|
|
|
@c Giving an optional @var{parameter} of
|
|
@c @samp{no} should omit @var{package}, if it is used by default.
|
|
|
|
Possible values of @var{package} include @samp{x}, @samp{x-toolkit},
|
|
@samp{gnu-as} (or @samp{gas}), @samp{gnu-ld}, @samp{gnu-libc}, and
|
|
@samp{gdb}.
|
|
|
|
Do not use a @samp{--with} option to specify the file name to use to
|
|
find certain files. That is outside the scope of what @samp{--with}
|
|
options are for.
|
|
|
|
@item --nfp
|
|
The target machine has no floating point processor.
|
|
|
|
@item --gas
|
|
The target machine assembler is GAS, the GNU assembler.
|
|
This is obsolete; users should use @samp{--with-gnu-as} instead.
|
|
|
|
@item --x
|
|
The target machine has the X Window System installed.
|
|
This is obsolete; users should use @samp{--with-x} instead.
|
|
@end table
|
|
|
|
All @code{configure} scripts should accept all of these ``detail''
|
|
options, whether or not they make any difference to the particular
|
|
package at hand. In particular, they should accept any option that
|
|
starts with @samp{--with-} or @samp{--enable-}. This is so users will
|
|
be able to configure an entire GNU source tree at once with a single set
|
|
of options.
|
|
|
|
You will note that the categories @samp{--with-} and @samp{--enable-}
|
|
are narrow: they @strong{do not} provide a place for any sort of option
|
|
you might think of. That is deliberate. We want to limit the possible
|
|
configuration options in GNU software. We do not want GNU programs to
|
|
have idiosyncratic configuration options.
|
|
|
|
Packages that perform part of compilation may support cross-compilation.
|
|
In such a case, the host and target machines for the program may be
|
|
different. The @code{configure} script should normally treat the
|
|
specified type of system as both the host and the target, thus producing
|
|
a program which works for the same type of machine that it runs on.
|
|
|
|
The way to build a cross-compiler, cross-assembler, or what have you, is
|
|
to specify the option @samp{--host=@var{hosttype}} when running
|
|
@code{configure}. This specifies the host system without changing the
|
|
type of target system. The syntax for @var{hosttype} is the same as
|
|
described above.
|
|
|
|
Bootstrapping a cross-compiler requires compiling it on a machine other
|
|
than the host it will run on. Compilation packages accept a
|
|
configuration option @samp{--build=@var{hosttype}} for specifying the
|
|
configuration on which you will compile them, in case that is different
|
|
from the host.
|
|
|
|
Programs for which cross-operation is not meaningful need not accept the
|
|
@samp{--host} option, because configuring an entire operating system for
|
|
cross-operation is not a meaningful thing.
|
|
|
|
Some programs have ways of configuring themselves automatically. If
|
|
your program is set up to do this, your @code{configure} script can simply
|
|
ignore most of its arguments.
|
|
|
|
@node Source Language
|
|
@chapter Using Languages Other Than C
|
|
|
|
Using a language other than C is like using a non-standard feature: it
|
|
will cause trouble for users. Even if GCC supports the other language,
|
|
users may find it inconvenient to have to install the compiler for that
|
|
other language in order to build your program. So please write in C.
|
|
|
|
There are three exceptions for this rule:
|
|
|
|
@itemize @bullet
|
|
@item
|
|
It is okay to use a special language if the same program contains an
|
|
interpreter for that language.
|
|
|
|
Thus, it is not a problem that GNU Emacs contains code written in Emacs
|
|
Lisp, because it comes with a Lisp interpreter.
|
|
|
|
@item
|
|
It is okay to use another language in a tool specifically intended for
|
|
use with that language.
|
|
|
|
This is okay because the only people who want to build the tool will be
|
|
those who have installed the other language anyway.
|
|
|
|
@item
|
|
If an application is not of extremely widespread interest, then perhaps
|
|
it's not important if the application is inconvenient to install.
|
|
@end itemize
|
|
|
|
@node Formatting
|
|
@chapter Formatting Your Source Code
|
|
|
|
It is important to put the open-brace that starts the body of a C
|
|
function in column zero, and avoid putting any other open-brace or
|
|
open-parenthesis or open-bracket in column zero. Several tools look
|
|
for open-braces in column zero to find the beginnings of C functions.
|
|
These tools will not work on code not formatted that way.
|
|
|
|
It is also important for function definitions to start the name of the
|
|
function in column zero. This helps people to search for function
|
|
definitions, and may also help certain tools recognize them. Thus,
|
|
the proper format is this:
|
|
|
|
@example
|
|
static char *
|
|
concat (s1, s2) /* Name starts in column zero here */
|
|
char *s1, *s2;
|
|
@{ /* Open brace in column zero here */
|
|
@dots{}
|
|
@}
|
|
@end example
|
|
|
|
@noindent
|
|
or, if you want to use @sc{ANSI} C, format the definition like this:
|
|
|
|
@example
|
|
static char *
|
|
concat (char *s1, char *s2)
|
|
@{
|
|
@dots{}
|
|
@}
|
|
@end example
|
|
|
|
In @sc{ANSI} C, if the arguments don't fit nicely on one line,
|
|
split it like this:
|
|
|
|
@example
|
|
int
|
|
lots_of_args (int an_integer, long a_long, short a_short,
|
|
double a_double, float a_float)
|
|
@dots{}
|
|
@end example
|
|
|
|
For the body of the function, we prefer code formatted like this:
|
|
|
|
@example
|
|
if (x < foo (y, z))
|
|
haha = bar[4] + 5;
|
|
else
|
|
@{
|
|
while (z)
|
|
@{
|
|
haha += foo (z, z);
|
|
z--;
|
|
@}
|
|
return ++x + bar ();
|
|
@}
|
|
@end example
|
|
|
|
We find it easier to read a program when it has spaces before the
|
|
open-parentheses and after the commas. Especially after the commas.
|
|
|
|
When you split an expression into multiple lines, split it
|
|
before an operator, not after one. Here is the right way:
|
|
|
|
@example
|
|
if (foo_this_is_long && bar > win (x, y, z)
|
|
&& remaining_condition)
|
|
@end example
|
|
|
|
Try to avoid having two operators of different precedence at the same
|
|
level of indentation. For example, don't write this:
|
|
|
|
@example
|
|
mode = (inmode[j] == VOIDmode
|
|
|| GET_MODE_SIZE (outmode[j]) > GET_MODE_SIZE (inmode[j])
|
|
? outmode[j] : inmode[j]);
|
|
@end example
|
|
|
|
Instead, use extra parentheses so that the indentation shows the nesting:
|
|
|
|
@example
|
|
mode = ((inmode[j] == VOIDmode
|
|
|| (GET_MODE_SIZE (outmode[j]) > GET_MODE_SIZE (inmode[j])))
|
|
? outmode[j] : inmode[j]);
|
|
@end example
|
|
|
|
Insert extra parentheses so that Emacs will indent the code properly.
|
|
For example, the following indentation looks nice if you do it by hand,
|
|
but Emacs would mess it up:
|
|
|
|
@example
|
|
v = rup->ru_utime.tv_sec*1000 + rup->ru_utime.tv_usec/1000
|
|
+ rup->ru_stime.tv_sec*1000 + rup->ru_stime.tv_usec/1000;
|
|
@end example
|
|
|
|
But adding a set of parentheses solves the problem:
|
|
|
|
@example
|
|
v = (rup->ru_utime.tv_sec*1000 + rup->ru_utime.tv_usec/1000
|
|
+ rup->ru_stime.tv_sec*1000 + rup->ru_stime.tv_usec/1000);
|
|
@end example
|
|
|
|
Format do-while statements like this:
|
|
|
|
@example
|
|
do
|
|
@{
|
|
a = foo (a);
|
|
@}
|
|
while (a > 0);
|
|
@end example
|
|
|
|
Please use formfeed characters (control-L) to divide the program into
|
|
pages at logical places (but not within a function). It does not matter
|
|
just how long the pages are, since they do not have to fit on a printed
|
|
page. The formfeeds should appear alone on lines by themselves.
|
|
|
|
|
|
@node Comments
|
|
@chapter Commenting Your Work
|
|
|
|
Every program should start with a comment saying briefly what it is for.
|
|
Example: @samp{fmt - filter for simple filling of text}.
|
|
|
|
Please put a comment on each function saying what the function does,
|
|
what sorts of arguments it gets, and what the possible values of
|
|
arguments mean and are used for. It is not necessary to duplicate in
|
|
words the meaning of the C argument declarations, if a C type is being
|
|
used in its customary fashion. If there is anything nonstandard about
|
|
its use (such as an argument of type @code{char *} which is really the
|
|
address of the second character of a string, not the first), or any
|
|
possible values that would not work the way one would expect (such as,
|
|
that strings containing newlines are not guaranteed to work), be sure
|
|
to say so.
|
|
|
|
Also explain the significance of the return value, if there is one.
|
|
|
|
Please put two spaces after the end of a sentence in your comments, so
|
|
that the Emacs sentence commands will work. Also, please write
|
|
complete sentences and capitalize the first word. If a lower-case
|
|
identifier comes at the beginning of a sentence, don't capitalize it!
|
|
Changing the spelling makes it a different identifier. If you don't
|
|
like starting a sentence with a lower case letter, write the sentence
|
|
differently (e.g., ``The identifier lower-case is @dots{}'').
|
|
|
|
The comment on a function is much clearer if you use the argument
|
|
names to speak about the argument values. The variable name itself
|
|
should be lower case, but write it in upper case when you are speaking
|
|
about the value rather than the variable itself. Thus, ``the inode
|
|
number NODE_NUM'' rather than ``an inode''.
|
|
|
|
There is usually no purpose in restating the name of the function in
|
|
the comment before it, because the reader can see that for himself.
|
|
There might be an exception when the comment is so long that the function
|
|
itself would be off the bottom of the screen.
|
|
|
|
There should be a comment on each static variable as well, like this:
|
|
|
|
@example
|
|
/* Nonzero means truncate lines in the display;
|
|
zero means continue them. */
|
|
int truncate_lines;
|
|
@end example
|
|
|
|
Every @samp{#endif} should have a comment, except in the case of short
|
|
conditionals (just a few lines) that are not nested. The comment should
|
|
state the condition of the conditional that is ending, @emph{including
|
|
its sense}. @samp{#else} should have a comment describing the condition
|
|
@emph{and sense} of the code that follows. For example:
|
|
|
|
@example
|
|
#ifdef foo
|
|
@dots{}
|
|
#else /* not foo */
|
|
@dots{}
|
|
#endif /* not foo */
|
|
@end example
|
|
|
|
@noindent
|
|
but, by contrast, write the comments this way for a @samp{#ifndef}:
|
|
|
|
@example
|
|
#ifndef foo
|
|
@dots{}
|
|
#else /* foo */
|
|
@dots{}
|
|
#endif /* foo */
|
|
@end example
|
|
|
|
|
|
@node Syntactic Conventions
|
|
@chapter Clean Use of C Constructs
|
|
|
|
Please explicitly declare all arguments to functions.
|
|
Don't omit them just because they are @code{int}s.
|
|
|
|
Declarations of external functions and functions to appear later in the
|
|
source file should all go in one place near the beginning of the file
|
|
(somewhere before the first function definition in the file), or else
|
|
should go in a header file. Don't put @code{extern} declarations inside
|
|
functions.
|
|
|
|
It used to be common practice to use the same local variables (with
|
|
names like @code{tem}) over and over for different values within one
|
|
function. Instead of doing this, it is better declare a separate local
|
|
variable for each distinct purpose, and give it a name which is
|
|
meaningful. This not only makes programs easier to understand, it also
|
|
facilitates optimization by good compilers. You can also move the
|
|
declaration of each local variable into the smallest scope that includes
|
|
all its uses. This makes the program even cleaner.
|
|
|
|
Don't use local variables or parameters that shadow global identifiers.
|
|
|
|
Don't declare multiple variables in one declaration that spans lines.
|
|
Start a new declaration on each line, instead. For example, instead
|
|
of this:
|
|
|
|
@example
|
|
int foo,
|
|
bar;
|
|
@end example
|
|
|
|
@noindent
|
|
write either this:
|
|
|
|
@example
|
|
int foo, bar;
|
|
@end example
|
|
|
|
@noindent
|
|
or this:
|
|
|
|
@example
|
|
int foo;
|
|
int bar;
|
|
@end example
|
|
|
|
@noindent
|
|
(If they are global variables, each should have a comment preceding it
|
|
anyway.)
|
|
|
|
When you have an @code{if}-@code{else} statement nested in another
|
|
@code{if} statement, always put braces around the @code{if}-@code{else}.
|
|
Thus, never write like this:
|
|
|
|
@example
|
|
if (foo)
|
|
if (bar)
|
|
win ();
|
|
else
|
|
lose ();
|
|
@end example
|
|
|
|
@noindent
|
|
always like this:
|
|
|
|
@example
|
|
if (foo)
|
|
@{
|
|
if (bar)
|
|
win ();
|
|
else
|
|
lose ();
|
|
@}
|
|
@end example
|
|
|
|
If you have an @code{if} statement nested inside of an @code{else}
|
|
statement, either write @code{else if} on one line, like this,
|
|
|
|
@example
|
|
if (foo)
|
|
@dots{}
|
|
else if (bar)
|
|
@dots{}
|
|
@end example
|
|
|
|
@noindent
|
|
with its @code{then}-part indented like the preceding @code{then}-part,
|
|
or write the nested @code{if} within braces like this:
|
|
|
|
@example
|
|
if (foo)
|
|
@dots{}
|
|
else
|
|
@{
|
|
if (bar)
|
|
@dots{}
|
|
@}
|
|
@end example
|
|
|
|
Don't declare both a structure tag and variables or typedefs in the
|
|
same declaration. Instead, declare the structure tag separately
|
|
and then use it to declare the variables or typedefs.
|
|
|
|
Try to avoid assignments inside @code{if}-conditions. For example,
|
|
don't write this:
|
|
|
|
@example
|
|
if ((foo = (char *) malloc (sizeof *foo)) == 0)
|
|
fatal ("virtual memory exhausted");
|
|
@end example
|
|
|
|
@noindent
|
|
instead, write this:
|
|
|
|
@example
|
|
foo = (char *) malloc (sizeof *foo);
|
|
if (foo == 0)
|
|
fatal ("virtual memory exhausted");
|
|
@end example
|
|
|
|
Don't make the program ugly to placate @code{lint}. Please don't insert any
|
|
casts to @code{void}. Zero without a cast is perfectly fine as a null
|
|
pointer constant.
|
|
|
|
@node Names
|
|
@chapter Naming Variables and Functions
|
|
|
|
Please use underscores to separate words in a name, so that the Emacs
|
|
word commands can be useful within them. Stick to lower case; reserve
|
|
upper case for macros and @code{enum} constants, and for name-prefixes
|
|
that follow a uniform convention.
|
|
|
|
For example, you should use names like @code{ignore_space_change_flag};
|
|
don't use names like @code{iCantReadThis}.
|
|
|
|
Variables that indicate whether command-line options have been
|
|
specified should be named after the meaning of the option, not after
|
|
the option-letter. A comment should state both the exact meaning of
|
|
the option and its letter. For example,
|
|
|
|
@example
|
|
/* Ignore changes in horizontal whitespace (-b). */
|
|
int ignore_space_change_flag;
|
|
@end example
|
|
|
|
When you want to define names with constant integer values, use
|
|
@code{enum} rather than @samp{#define}. GDB knows about enumeration
|
|
constants.
|
|
|
|
Use file names of 14 characters or less, to avoid creating gratuitous
|
|
problems on System V. You can use the program @code{doschk} to test for
|
|
this. @code{doschk} also tests for potential name conflicts if the
|
|
files were loaded onto an MS-DOS file system---something you may or may
|
|
not care about.
|
|
|
|
|
|
@node Using Extensions
|
|
@chapter Using Non-standard Features
|
|
|
|
Many GNU facilities that already exist support a number of convenient
|
|
extensions over the comparable Unix facilities. Whether to use these
|
|
extensions in implementing your program is a difficult question.
|
|
|
|
On the one hand, using the extensions can make a cleaner program.
|
|
On the other hand, people will not be able to build the program
|
|
unless the other GNU tools are available. This might cause the
|
|
program to work on fewer kinds of machines.
|
|
|
|
With some extensions, it might be easy to provide both alternatives.
|
|
For example, you can define functions with a ``keyword'' @code{INLINE}
|
|
and define that as a macro to expand into either @code{inline} or
|
|
nothing, depending on the compiler.
|
|
|
|
In general, perhaps it is best not to use the extensions if you can
|
|
straightforwardly do without them, but to use the extensions if they
|
|
are a big improvement.
|
|
|
|
An exception to this rule are the large, established programs (such as
|
|
Emacs) which run on a great variety of systems. Such programs would
|
|
be broken by use of GNU extensions.
|
|
|
|
Another exception is for programs that are used as part of
|
|
compilation: anything that must be compiled with other compilers in
|
|
order to bootstrap the GNU compilation facilities. If these require
|
|
the GNU compiler, then no one can compile them without having them
|
|
installed already. That would be no good.
|
|
|
|
Since most computer systems do not yet implement @sc{ANSI} C, using the
|
|
@sc{ANSI} C features is effectively using a GNU extension, so the
|
|
same considerations apply. (Except for @sc{ANSI} features that we
|
|
discourage, such as trigraphs---don't ever use them.)
|
|
|
|
|
|
@node System Functions
|
|
@chapter Calling System Functions
|
|
|
|
C implementations differ substantially. ANSI C reduces but does not
|
|
eliminate the incompatibilities; meanwhile, many users wish to compile
|
|
GNU software with pre-ANSI compilers. This chapter gives
|
|
recommendations for how to use the more or less standard C library
|
|
functions to avoid unnecessary loss of portability.
|
|
|
|
@itemize @bullet
|
|
@item
|
|
Don't use the value of @code{sprintf}. It returns the number of
|
|
characters written on some systems, but not on all systems.
|
|
|
|
@item
|
|
Don't declare system functions explicitly.
|
|
|
|
Almost any declaration for a system function is wrong on some system.
|
|
To minimize conflicts, leave it to the system header files to declare
|
|
system functions. If the headers don't declare a function, let it
|
|
remain undeclared.
|
|
|
|
While it may seem unclean to use a function without declaring it, in
|
|
practice this works fine for most system library functions on the
|
|
systems where this really happens. The problem is only theoretical. By
|
|
contrast, actual declarations have frequently caused actual conflicts.
|
|
|
|
@item
|
|
If you must declare a system function, don't specify the argument types.
|
|
Use an old-style declaration, not an ANSI prototype. The more you
|
|
specify about the function, the more likely a conflict.
|
|
|
|
@item
|
|
In particular, don't unconditionally declare @code{malloc} or
|
|
@code{realloc}.
|
|
|
|
Most GNU programs use those functions just once, in functions
|
|
conventionally named @code{xmalloc} and @code{xrealloc}. These
|
|
functions call @code{malloc} and @code{realloc}, respectively, and
|
|
check the results.
|
|
|
|
Because @code{xmalloc} and @code{xrealloc} are defined in your program,
|
|
you can declare them in other files without any risk of type conflict.
|
|
|
|
On most systems, @code{int} is the same length as a pointer; thus, the
|
|
calls to @code{malloc} and @code{realloc} work fine. For the few
|
|
exceptional systems (mostly 64-bit machines), you can use
|
|
@strong{conditionalized} declarations of @code{malloc} and
|
|
@code{realloc}---or put these declarations in configuration files
|
|
specific to those systems.
|
|
|
|
@item
|
|
The string functions require special treatment. Some Unix systems have
|
|
a header file @file{string.h}; other have @file{strings.h}. Neither
|
|
file name is portable. There are two things you can do: use Autoconf to
|
|
figure out which file to include, or don't include either file.
|
|
|
|
@item
|
|
If you don't include either strings file, you can't get declarations for
|
|
the string functions from the header file in the usual way.
|
|
|
|
That causes less of a problem than you might think. The newer ANSI
|
|
string functions are off-limits anyway because many systems still don't
|
|
support them. The string functions you can use are these:
|
|
|
|
@example
|
|
strcpy strncpy strcat strncat
|
|
strlen strcmp strncmp
|
|
strchr strrchr
|
|
@end example
|
|
|
|
The copy and concatenate functions work fine without a declaration as
|
|
long as you don't use their values. Using their values without a
|
|
declaration fails on systems where the width of a pointer differs from
|
|
the width of @code{int}, and perhaps in other cases. It is trivial to
|
|
avoid using their values, so do that.
|
|
|
|
The compare functions and @code{strlen} work fine without a declaration
|
|
on most systems, possibly all the ones that GNU software runs on.
|
|
You may find it necessary to declare them @strong{conditionally} on a
|
|
few systems.
|
|
|
|
The search functions must be declared to return @code{char *}. Luckily,
|
|
there is no variation in the data type they return. But there is
|
|
variation in their names. Some systems give these functions the names
|
|
@code{index} and @code{rindex}; other systems use the names
|
|
@code{strchr} and @code{strrchr}. Some systems support both pairs of
|
|
names, but neither pair works on all systems.
|
|
|
|
You should pick a single pair of names and use it throughout your
|
|
program. (Nowadays, it is better to choose @code{strchr} and
|
|
@code{strrchr}.) Declare both of those names as functions returning
|
|
@code{char *}. On systems which don't support those names, define them
|
|
as macros in terms of the other pair. For example, here is what to put
|
|
at the beginning of your file (or in a header) if you want to use the
|
|
names @code{strchr} and @code{strrchr} throughout:
|
|
|
|
@example
|
|
#ifndef HAVE_STRCHR
|
|
#define strchr index
|
|
#endif
|
|
#ifndef HAVE_STRRCHR
|
|
#define strrchr rindex
|
|
#endif
|
|
|
|
char *strchr ();
|
|
char *strrchr ();
|
|
@end example
|
|
@end itemize
|
|
|
|
Here we assume that @code{HAVE_STRCHR} and @code{HAVE_STRRCHR} are
|
|
macros defined in systems where the corresponding functions exist.
|
|
One way to get them properly defined is to use Autoconf.
|
|
|
|
@node Semantics
|
|
@chapter Program Behavior for All Programs
|
|
|
|
Avoid arbitrary limits on the length or number of @emph{any} data
|
|
structure, including file names, lines, files, and symbols, by allocating
|
|
all data structures dynamically. In most Unix utilities, ``long lines
|
|
are silently truncated''. This is not acceptable in a GNU utility.
|
|
|
|
Utilities reading files should not drop NUL characters, or any other
|
|
nonprinting characters @emph{including those with codes above 0177}. The
|
|
only sensible exceptions would be utilities specifically intended for
|
|
interface to certain types of printers that can't handle those characters.
|
|
|
|
Check every system call for an error return, unless you know you wish to
|
|
ignore errors. Include the system error text (from @code{perror} or
|
|
equivalent) in @emph{every} error message resulting from a failing
|
|
system call, as well as the name of the file if any and the name of the
|
|
utility. Just ``cannot open foo.c'' or ``stat failed'' is not
|
|
sufficient.
|
|
|
|
Check every call to @code{malloc} or @code{realloc} to see if it
|
|
returned zero. Check @code{realloc} even if you are making the block
|
|
smaller; in a system that rounds block sizes to a power of 2,
|
|
@code{realloc} may get a different block if you ask for less space.
|
|
|
|
In Unix, @code{realloc} can destroy the storage block if it returns
|
|
zero. GNU @code{realloc} does not have this bug: if it fails, the
|
|
original block is unchanged. Feel free to assume the bug is fixed. If
|
|
you wish to run your program on Unix, and wish to avoid lossage in this
|
|
case, you can use the GNU @code{malloc}.
|
|
|
|
You must expect @code{free} to alter the contents of the block that was
|
|
freed. Anything you want to fetch from the block, you must fetch before
|
|
calling @code{free}.
|
|
|
|
If @code{malloc} fails in a noninteractive program, make that a fatal
|
|
error. In an interactive program (one that reads commands from the
|
|
user), it is better to abort the command and return to the command
|
|
reader loop. This allows the user to kill other processes to free up
|
|
virtual memory, and then try the command again.
|
|
|
|
Use @code{getopt_long} to decode arguments, unless the argument syntax
|
|
makes this unreasonable.
|
|
|
|
When static storage is to be written in during program execution, use
|
|
explicit C code to initialize it. Reserve C initialized declarations
|
|
for data that will not be changed.
|
|
|
|
Try to avoid low-level interfaces to obscure Unix data structures (such
|
|
as file directories, utmp, or the layout of kernel memory), since these
|
|
are less likely to work compatibly. If you need to find all the files
|
|
in a directory, use @code{readdir} or some other high-level interface.
|
|
These will be supported compatibly by GNU.
|
|
|
|
By default, the GNU system will provide the signal handling functions of
|
|
@sc{BSD} and of @sc{POSIX}. So GNU software should be written to use
|
|
these.
|
|
|
|
In error checks that detect ``impossible'' conditions, just abort.
|
|
There is usually no point in printing any message. These checks
|
|
indicate the existence of bugs. Whoever wants to fix the bugs will have
|
|
to read the source code and run a debugger. So explain the problem with
|
|
comments in the source. The relevant data will be in variables, which
|
|
are easy to examine with the debugger, so there is no point moving them
|
|
elsewhere.
|
|
|
|
|
|
@node Errors
|
|
@chapter Formatting Error Messages
|
|
|
|
Error messages from compilers should look like this:
|
|
|
|
@example
|
|
@var{source-file-name}:@var{lineno}: @var{message}
|
|
@end example
|
|
|
|
Error messages from other noninteractive programs should look like this:
|
|
|
|
@example
|
|
@var{program}:@var{source-file-name}:@var{lineno}: @var{message}
|
|
@end example
|
|
|
|
@noindent
|
|
when there is an appropriate source file, or like this:
|
|
|
|
@example
|
|
@var{program}: @var{message}
|
|
@end example
|
|
|
|
@noindent
|
|
when there is no relevant source file.
|
|
|
|
In an interactive program (one that is reading commands from a
|
|
terminal), it is better not to include the program name in an error
|
|
message. The place to indicate which program is running is in the
|
|
prompt or with the screen layout. (When the same program runs with
|
|
input from a source other than a terminal, it is not interactive and
|
|
would do best to print error messages using the noninteractive style.)
|
|
|
|
The string @var{message} should not begin with a capital letter when
|
|
it follows a program name and/or file name. Also, it should not end
|
|
with a period.
|
|
|
|
Error messages from interactive programs, and other messages such as
|
|
usage messages, should start with a capital letter. But they should not
|
|
end with a period.
|
|
|
|
|
|
@node Libraries
|
|
@chapter Library Behavior
|
|
|
|
Try to make library functions reentrant. If they need to do dynamic
|
|
storage allocation, at least try to avoid any nonreentrancy aside from
|
|
that of @code{malloc} itself.
|
|
|
|
Here are certain name conventions for libraries, to avoid name
|
|
conflicts.
|
|
|
|
Choose a name prefix for the library, more than two characters long.
|
|
All external function and variable names should start with this
|
|
prefix. In addition, there should only be one of these in any given
|
|
library member. This usually means putting each one in a separate
|
|
source file.
|
|
|
|
An exception can be made when two external symbols are always used
|
|
together, so that no reasonable program could use one without the
|
|
other; then they can both go in the same file.
|
|
|
|
External symbols that are not documented entry points for the user
|
|
should have names beginning with @samp{_}. They should also contain
|
|
the chosen name prefix for the library, to prevent collisions with
|
|
other libraries. These can go in the same files with user entry
|
|
points if you like.
|
|
|
|
Static functions and variables can be used as you like and need not
|
|
fit any naming convention.
|
|
|
|
|
|
@node Portability
|
|
@chapter Portability As It Applies to GNU
|
|
|
|
Much of what is called ``portability'' in the Unix world refers to
|
|
porting to different Unix versions. This is a secondary consideration
|
|
for GNU software, because its primary purpose is to run on top of one
|
|
and only one kernel, the GNU kernel, compiled with one and only one C
|
|
compiler, the GNU C compiler. The amount and kinds of variation among
|
|
GNU systems on different cpu's will be like the variation among Berkeley
|
|
4.3 systems on different cpu's.
|
|
|
|
All users today run GNU software on non-GNU systems. So supporting a
|
|
variety of non-GNU systems is desirable; simply not paramount.
|
|
The easiest way to achieve portability to a reasonable range of systems
|
|
is to use Autoconf. It's unlikely that your program needs to know more
|
|
information about the host machine than Autoconf can provide, simply
|
|
because most of the programs that need such knowledge have already been
|
|
written.
|
|
|
|
It is difficult to be sure exactly what facilities the GNU kernel
|
|
will provide, since it isn't finished yet. Therefore, assume you can
|
|
use anything in 4.3; just avoid using the format of semi-internal data
|
|
bases (e.g., directories) when there is a higher-level alternative
|
|
(@code{readdir}).
|
|
|
|
You can freely assume any reasonably standard facilities in the C
|
|
language, libraries or kernel, because we will find it necessary to
|
|
support these facilities in the full GNU system, whether or not we
|
|
have already done so. The fact that there may exist kernels or C
|
|
compilers that lack these facilities is irrelevant as long as the GNU
|
|
kernel and C compiler support them.
|
|
|
|
It remains necessary to worry about differences among cpu types, such
|
|
as the difference in byte ordering and alignment restrictions. It's
|
|
unlikely that 16-bit machines will ever be supported by GNU, so there
|
|
is no point in spending any time to consider the possibility that an
|
|
int will be less than 32 bits.
|
|
|
|
You can assume that all pointers have the same format, regardless
|
|
of the type they point to, and that this is really an integer.
|
|
There are some weird machines where this isn't true, but they aren't
|
|
important; don't waste time catering to them. Besides, eventually
|
|
we will put function prototypes into all GNU programs, and that will
|
|
probably make your program work even on weird machines.
|
|
|
|
Since some important machines (including the 68000) are big-endian,
|
|
it is important not to assume that the address of an @code{int} object
|
|
is also the address of its least-significant byte. Thus, don't
|
|
make the following mistake:
|
|
|
|
@example
|
|
int c;
|
|
@dots{}
|
|
while ((c = getchar()) != EOF)
|
|
write(file_descriptor, &c, 1);
|
|
@end example
|
|
|
|
You can assume that it is reasonable to use a meg of memory. Don't
|
|
strain to reduce memory usage unless it can get to that level. If
|
|
your program creates complicated data structures, just make them in
|
|
core and give a fatal error if malloc returns zero.
|
|
|
|
If a program works by lines and could be applied to arbitrary
|
|
user-supplied input files, it should keep only a line in memory, because
|
|
this is not very hard and users will want to be able to operate on input
|
|
files that are bigger than will fit in core all at once.
|
|
|
|
|
|
@node User Interfaces
|
|
@chapter Standards for Command Line Interfaces
|
|
|
|
Please don't make the behavior of a utility depend on the name used
|
|
to invoke it. It is useful sometimes to make a link to a utility
|
|
with a different name, and that should not change what it does.
|
|
|
|
Instead, use a run time option or a compilation switch or both
|
|
to select among the alternate behaviors.
|
|
|
|
Likewise, please don't make the behavior of the program depend on the
|
|
type of output device it is used with. Device independence is an
|
|
important principle of the system's design; do not compromise it
|
|
merely to save someone from typing an option now and then.
|
|
|
|
If you think one behavior is most useful when the output is to a
|
|
terminal, and another is most useful when the output is a file or a
|
|
pipe, then it is usually best to make the default behavior the one that
|
|
is useful with output to a terminal, and have an option for the other
|
|
behavior.
|
|
|
|
Compatibility requires certain programs to depend on the type of output
|
|
device. It would be disastrous if @code{ls} or @code{sh} did not do so
|
|
in the way all users expect. In some of these cases, we supplement the
|
|
program with a preferred alternate version that does not depend on the
|
|
output device type. For example, we provide a @code{dir} program much
|
|
like @code{ls} except that its default output format is always
|
|
multi-column format.
|
|
|
|
It is a good idea to follow the @sc{POSIX} guidelines for the
|
|
command-line options of a program. The easiest way to do this is to use
|
|
@code{getopt} to parse them. Note that the GNU version of @code{getopt}
|
|
will normally permit options anywhere among the arguments unless the
|
|
special argument @samp{--} is used. This is not what @sc{POSIX}
|
|
specifies; it is a GNU extension.
|
|
|
|
Please define long-named options that are equivalent to the
|
|
single-letter Unix-style options. We hope to make GNU more user
|
|
friendly this way. This is easy to do with the GNU function
|
|
@code{getopt_long}.
|
|
|
|
One of the advantages of long-named options is that they can be
|
|
consistent from program to program. For example, users should be able
|
|
to expect the ``verbose'' option of any GNU program which has one, to be
|
|
spelled precisely @samp{--verbose}. To achieve this uniformity, look at
|
|
the table of common long-option names when you choose the option names
|
|
for your program. The table appears below.
|
|
|
|
If you use names not already in the table, please send
|
|
@samp{gnu@@prep.ai.mit.edu} a list of them, with their meanings, so we
|
|
can update the table.
|
|
|
|
It is usually a good idea for file names given as ordinary arguments
|
|
to be input files only; any output files would be specified using
|
|
options (preferably @samp{-o}). Even if you allow an output file name
|
|
as an ordinary argument for compatibility, try to provide a suitable
|
|
option as well. This will lead to more consistency among GNU
|
|
utilities, so that there are fewer idiosyncracies for users to
|
|
remember.
|
|
|
|
Programs should support an option @samp{--version} which prints the
|
|
program's version number on standard output and exits successfully, and
|
|
an option @samp{--help} which prints option usage information on
|
|
standard output and exits successfully. These options should inhibit
|
|
the normal function of the command; they should do nothing except print
|
|
the requested information.
|
|
|
|
@c Please leave newlines between items in this table; it's much easier
|
|
@c to update when it isn't completely squashed together and unreadable.
|
|
@c When there is more than one short option for a long option name, put
|
|
@c a semicolon between the lists of the programs that use them, not a
|
|
@c period. --friedman
|
|
|
|
@table @samp
|
|
|
|
@item after-date
|
|
@samp{-N} in @code{tar}.
|
|
|
|
@item all
|
|
@samp{-a} in @code{du}, @code{ls}, @code{nm}, @code{stty}, @code{uname},
|
|
and @code{unexpand}.
|
|
|
|
@item all-text
|
|
@samp{-a} in @code{diff}.
|
|
|
|
@item almost-all
|
|
@samp{-A} in @code{ls}.
|
|
|
|
@item append
|
|
@samp{-a} in @code{etags}, @code{tee}, @code{time};
|
|
@samp{-r} in @code{tar}.
|
|
|
|
@item archive
|
|
@samp{-a} in @code{cp}.
|
|
|
|
@item archive-name
|
|
@samp{-n} in @code{shar}.
|
|
|
|
@item arglength
|
|
@samp{-l} in @code{m4}.
|
|
|
|
@item ascii
|
|
@samp{-a} in @code{diff}.
|
|
|
|
@item assume-new
|
|
@samp{-W} in Make.
|
|
|
|
@item assume-old
|
|
@samp{-o} in Make.
|
|
|
|
@item auto-check
|
|
@samp{-a} in @code{recode}.
|
|
|
|
@item auto-pager
|
|
@samp{-a} in @code{wdiff}.
|
|
|
|
@item auto-reference
|
|
@samp{-A} in @code{ptx}.
|
|
|
|
@item avoid-wraps
|
|
@samp{-n} in @code{wdiff}.
|
|
|
|
@item backward-search
|
|
@samp{-B} in @code{ctags}.
|
|
|
|
@item basename
|
|
@samp{-f} in @code{shar}.
|
|
|
|
@item batch
|
|
Used in GDB.
|
|
|
|
@item baud
|
|
Used in GDB.
|
|
|
|
@item before
|
|
@samp{-b} in @code{tac}.
|
|
|
|
@item binary
|
|
@samp{-b} in @code{cpio} and @code{diff}.
|
|
|
|
@item bits-per-code
|
|
@samp{-b} in @code{shar}.
|
|
|
|
@item block-size
|
|
Used in @code{cpio} and @code{tar}.
|
|
|
|
@item blocks
|
|
@samp{-b} in @code{head} and @code{tail}.
|
|
|
|
@item break-file
|
|
@samp{-b} in @code{ptx}.
|
|
|
|
@item brief
|
|
Used in various programs to make output shorter.
|
|
|
|
@item bytes
|
|
@samp{-c} in @code{head}, @code{split}, and @code{tail}.
|
|
|
|
@item c@t{++}
|
|
@samp{-C} in @code{etags}.
|
|
|
|
@item catenate
|
|
@samp{-A} in @code{tar}.
|
|
|
|
@item cd
|
|
Used in various programs to specify the directory to use.
|
|
|
|
@item changes
|
|
@samp{-c} in @code{chgrp} and @code{chown}.
|
|
|
|
@item classify
|
|
@samp{-F} in @code{ls}.
|
|
|
|
@item colons
|
|
@samp{-c} in @code{recode}.
|
|
|
|
@item command
|
|
@samp{-c} in @code{su};
|
|
@samp{-x} in GDB.
|
|
|
|
@item compare
|
|
@samp{-d} in @code{tar}.
|
|
|
|
@item compress
|
|
@samp{-Z} in @code{tar} and @code{shar}.
|
|
|
|
@item concatenate
|
|
@samp{-A} in @code{tar}.
|
|
|
|
@item confirmation
|
|
@samp{-w} in @code{tar}.
|
|
|
|
@item context
|
|
Used in @code{diff}.
|
|
|
|
@item copyright
|
|
@samp{-C} in @code{ptx}, @code{recode}, and @code{wdiff}.
|
|
|
|
@item core
|
|
Used in GDB.
|
|
|
|
@item count
|
|
@samp{-q} in @code{who}.
|
|
|
|
@item count-links
|
|
@samp{-l} in @code{du}.
|
|
|
|
@item create
|
|
Used in @code{tar} and @code{cpio}.
|
|
|
|
@item cut-mark
|
|
@samp{-c} in @code{shar}.
|
|
|
|
@item cxref
|
|
@samp{-x} in @code{ctags}.
|
|
|
|
@item date
|
|
@samp{-d} in @code{touch}.
|
|
|
|
@item debug
|
|
@samp{-d} in Make and @code{m4};
|
|
@samp{-t} in Bison.
|
|
|
|
@item define
|
|
@samp{-D} in @code{m4}.
|
|
|
|
@item defines
|
|
@samp{-d} in Bison and @code{ctags}.
|
|
|
|
@item delete
|
|
@samp{-D} in @code{tar}.
|
|
|
|
@item dereference
|
|
@samp{-L} in @code{chgrp}, @code{chown}, @code{cpio}, @code{du},
|
|
@code{ls}, and @code{tar}.
|
|
|
|
@item dereference-args
|
|
@samp{-D} in @code{du}.
|
|
|
|
@item diacritics
|
|
@samp{-d} in @code{recode}.
|
|
|
|
@item dictionary-order
|
|
@samp{-d} in @code{look}.
|
|
|
|
@item diff
|
|
@samp{-d} in @code{tar}.
|
|
|
|
@item digits
|
|
@samp{-n} in @code{csplit}.
|
|
|
|
@item directory
|
|
Specify the directory to use, in various programs. In @code{ls}, it
|
|
means to show directories themselves rather than their contents. In
|
|
@code{rm} and @code{ln}, it means to not treat links to directories
|
|
specially.
|
|
|
|
@item discard-all
|
|
@samp{-x} in @code{strip}.
|
|
|
|
@item discard-locals
|
|
@samp{-X} in @code{strip}.
|
|
|
|
@item dry-run
|
|
@samp{-n} in Make.
|
|
|
|
@item ed
|
|
@samp{-e} in @code{diff}.
|
|
|
|
@item elide-empty-files
|
|
@samp{-z} in @code{csplit}.
|
|
|
|
@item end-delete
|
|
@samp{-x} in @code{wdiff}.
|
|
|
|
@item end-insert
|
|
@samp{-z} in @code{wdiff}.
|
|
|
|
@item entire-new-file
|
|
@samp{-N} in @code{diff}.
|
|
|
|
@item environment-overrides
|
|
@samp{-e} in Make.
|
|
|
|
@item eof
|
|
@samp{-e} in @code{xargs}.
|
|
|
|
@item epoch
|
|
Used in GDB.
|
|
|
|
@item error-limit
|
|
Used in Makeinfo.
|
|
|
|
@item error-output
|
|
@samp{-o} in @code{m4}.
|
|
|
|
@item escape
|
|
@samp{-b} in @code{ls}.
|
|
|
|
@item exclude-from
|
|
@samp{-X} in @code{tar}.
|
|
|
|
@item exec
|
|
Used in GDB.
|
|
|
|
@item exit
|
|
@samp{-x} in @code{xargs}.
|
|
|
|
@item exit-0
|
|
@samp{-e} in @code{unshar}.
|
|
|
|
@item expand-tabs
|
|
@samp{-t} in @code{diff}.
|
|
|
|
@item expression
|
|
@samp{-e} in @code{sed}.
|
|
|
|
@item extern-only
|
|
@samp{-g} in @code{nm}.
|
|
|
|
@item extract
|
|
@samp{-i} in @code{cpio};
|
|
@samp{-x} in @code{tar}.
|
|
|
|
@item faces
|
|
@samp{-f} in @code{finger}.
|
|
|
|
@item fast
|
|
@samp{-f} in @code{su}.
|
|
|
|
@item fatal-warnings
|
|
@samp{-E} in @code{m4}.
|
|
|
|
@item file
|
|
@samp{-f} in @code{info}, Make, @code{mt}, and @code{tar};
|
|
@samp{-n} in @code{sed};
|
|
@samp{-r} in @code{touch}.
|
|
|
|
@item file-prefix
|
|
@samp{-b} in Bison.
|
|
|
|
@item file-type
|
|
@samp{-F} in @code{ls}.
|
|
|
|
@item files-from
|
|
@samp{-T} in @code{tar}.
|
|
|
|
@item fill-column
|
|
Used in Makeinfo.
|
|
|
|
@item flag-truncation
|
|
@samp{-F} in @code{ptx}.
|
|
|
|
@item fixed-output-files
|
|
@samp{-y} in Bison.
|
|
|
|
@item follow
|
|
@samp{-f} in @code{tail}.
|
|
|
|
@item footnote-style
|
|
Used in Makeinfo.
|
|
|
|
@item force
|
|
@samp{-f} in @code{cp}, @code{ln}, @code{mv}, and @code{rm}.
|
|
|
|
@item force-prefix
|
|
@samp{-F} in @code{shar}.
|
|
|
|
@item format
|
|
Used in @code{ls}, @code{time}, and @code{ptx}.
|
|
|
|
@item freeze-state
|
|
@samp{-F} in @code{m4}.
|
|
|
|
@item fullname
|
|
Used in GDB.
|
|
|
|
@item gap-size
|
|
@samp{-g} in @code{ptx}.
|
|
|
|
@item get
|
|
@samp{-x} in @code{tar}.
|
|
|
|
@item graphic
|
|
@samp{-i} in @code{ul}.
|
|
|
|
@item graphics
|
|
@samp{-g} in @code{recode}.
|
|
|
|
@item group
|
|
@samp{-g} in @code{install}.
|
|
|
|
@item gzip
|
|
@samp{-z} in @code{tar} and @code{shar}.
|
|
|
|
@item hashsize
|
|
@samp{-H} in @code{m4}.
|
|
|
|
@item header
|
|
@samp{-h} in @code{objdump} and @code{recode}
|
|
|
|
@item heading
|
|
@samp{-H} in @code{who}.
|
|
|
|
@item help
|
|
Used to ask for brief usage information.
|
|
|
|
@item here-delimiter
|
|
@samp{-d} in @code{shar}.
|
|
|
|
@item hide-control-chars
|
|
@samp{-q} in @code{ls}.
|
|
|
|
@item idle
|
|
@samp{-u} in @code{who}.
|
|
|
|
@item ifdef
|
|
@samp{-D} in @code{diff}.
|
|
|
|
@item ignore
|
|
@samp{-I} in @code{ls};
|
|
@samp{-x} in @code{recode}.
|
|
|
|
@item ignore-all-space
|
|
@samp{-w} in @code{diff}.
|
|
|
|
@item ignore-backups
|
|
@samp{-B} in @code{ls}.
|
|
|
|
@item ignore-blank-lines
|
|
@samp{-B} in @code{diff}.
|
|
|
|
@item ignore-case
|
|
@samp{-f} in @code{look} and @code{ptx};
|
|
@samp{-i} in @code{diff} and @code{wdiff}.
|
|
|
|
@item ignore-errors
|
|
@samp{-i} in Make.
|
|
|
|
@item ignore-file
|
|
@samp{-i} in @code{ptx}.
|
|
|
|
@item ignore-indentation
|
|
@samp{-I} in @code{etags}.
|
|
|
|
@item ignore-init-file
|
|
@samp{-f} in Oleo.
|
|
|
|
@item ignore-interrupts
|
|
@samp{-i} in @code{tee}.
|
|
|
|
@item ignore-matching-lines
|
|
@samp{-I} in @code{diff}.
|
|
|
|
@item ignore-space-change
|
|
@samp{-b} in @code{diff}.
|
|
|
|
@item ignore-zeros
|
|
@samp{-i} in @code{tar}.
|
|
|
|
@item include
|
|
@samp{-i} in @code{etags};
|
|
@samp{-I} in @code{m4}.
|
|
|
|
@item include-dir
|
|
@samp{-I} in Make.
|
|
|
|
@item incremental
|
|
@samp{-G} in @code{tar}.
|
|
|
|
@item info
|
|
@samp{-i}, @samp{-l}, and @samp{-m} in Finger.
|
|
|
|
@item initial
|
|
@samp{-i} in @code{expand}.
|
|
|
|
@item initial-tab
|
|
@samp{-T} in @code{diff}.
|
|
|
|
@item inode
|
|
@samp{-i} in @code{ls}.
|
|
|
|
@item interactive
|
|
@samp{-i} in @code{cp}, @code{ln}, @code{mv}, @code{rm};
|
|
@samp{-e} in @code{m4};
|
|
@samp{-p} in @code{xargs};
|
|
@samp{-w} in @code{tar}.
|
|
|
|
@item intermix-type
|
|
@samp{-p} in @code{shar}.
|
|
|
|
@item jobs
|
|
@samp{-j} in Make.
|
|
|
|
@item just-print
|
|
@samp{-n} in Make.
|
|
|
|
@item keep-going
|
|
@samp{-k} in Make.
|
|
|
|
@item keep-files
|
|
@samp{-k} in @code{csplit}.
|
|
|
|
@item kilobytes
|
|
@samp{-k} in @code{du} and @code{ls}.
|
|
|
|
@item language
|
|
@samp{-l} in @code{etags}.
|
|
|
|
@item less-mode
|
|
@samp{-l} in @code{wdiff}.
|
|
|
|
@item level-for-gzip
|
|
@samp{-g} in @code{shar}.
|
|
|
|
@item line-bytes
|
|
@samp{-C} in @code{split}.
|
|
|
|
@item lines
|
|
Used in @code{split}, @code{head}, and @code{tail}.
|
|
|
|
@item link
|
|
@samp{-l} in @code{cpio}.
|
|
|
|
@item list
|
|
@samp{-t} in @code{cpio};
|
|
@samp{-l} in @code{recode}.
|
|
|
|
@item list
|
|
@samp{-t} in @code{tar}.
|
|
|
|
@item literal
|
|
@samp{-N} in @code{ls}.
|
|
|
|
@item load-average
|
|
@samp{-l} in Make.
|
|
|
|
@item login
|
|
Used in @code{su}.
|
|
|
|
@item machine
|
|
No listing of which programs already use this;
|
|
someone should check to
|
|
see if any actually do and tell @code{gnu@@prep.ai.mit.edu}.
|
|
|
|
@item macro-name
|
|
@samp{-M} in @code{ptx}.
|
|
|
|
@item mail
|
|
@samp{-m} in @code{hello} and @code{uname}.
|
|
|
|
@item make-directories
|
|
@samp{-d} in @code{cpio}.
|
|
|
|
@item makefile
|
|
@samp{-f} in Make.
|
|
|
|
@item mapped
|
|
Used in GDB.
|
|
|
|
@item max-args
|
|
@samp{-n} in @code{xargs}.
|
|
|
|
@item max-chars
|
|
@samp{-n} in @code{xargs}.
|
|
|
|
@item max-lines
|
|
@samp{-l} in @code{xargs}.
|
|
|
|
@item max-load
|
|
@samp{-l} in Make.
|
|
|
|
@item max-procs
|
|
@samp{-P} in @code{xargs}.
|
|
|
|
@item mesg
|
|
@samp{-T} in @code{who}.
|
|
|
|
@item message
|
|
@samp{-T} in @code{who}.
|
|
|
|
@item minimal
|
|
@samp{-d} in @code{diff}.
|
|
|
|
@item mixed-uuencode
|
|
@samp{-M} in @code{shar}.
|
|
|
|
@item mode
|
|
@samp{-m} in @code{install}, @code{mkdir}, and @code{mkfifo}.
|
|
|
|
@item modification-time
|
|
@samp{-m} in @code{tar}.
|
|
|
|
@item multi-volume
|
|
@samp{-M} in @code{tar}.
|
|
|
|
@item name-prefix
|
|
@samp{-a} in Bison.
|
|
|
|
@item nesting-limit
|
|
@samp{-L} in @code{m4}.
|
|
|
|
@item net-headers
|
|
@samp{-a} in @code{shar}.
|
|
|
|
@item new-file
|
|
@samp{-W} in Make.
|
|
|
|
@item no-builtin-rules
|
|
@samp{-r} in Make.
|
|
|
|
@item no-character-count
|
|
@samp{-w} in @code{shar}.
|
|
|
|
@item no-check-existing
|
|
@samp{-x} in @code{shar}.
|
|
|
|
@item no-common
|
|
@samp{-3} in @code{wdiff}.
|
|
|
|
@item no-create
|
|
@samp{-c} in @code{touch}.
|
|
|
|
@item no-defines
|
|
@samp{-D} in @code{etags}.
|
|
|
|
@item no-deleted
|
|
@samp{-1} in @code{wdiff}.
|
|
|
|
@item no-dereference
|
|
@samp{-d} in @code{cp}.
|
|
|
|
@item no-inserted
|
|
@samp{-2} in @code{wdiff}.
|
|
|
|
@item no-keep-going
|
|
@samp{-S} in Make.
|
|
|
|
@item no-lines
|
|
@samp{-l} in Bison.
|
|
|
|
@item no-piping
|
|
@samp{-P} in @code{shar}.
|
|
|
|
@item no-prof
|
|
@samp{-e} in @code{gprof}.
|
|
|
|
@item no-regex
|
|
@samp{-R} in @code{etags}.
|
|
|
|
@item no-sort
|
|
@samp{-p} in @code{nm}.
|
|
|
|
@item no-split
|
|
Used in Makeinfo.
|
|
|
|
@item no-static
|
|
@samp{-a} in @code{gprof}.
|
|
|
|
@item no-time
|
|
@samp{-E} in @code{gprof}.
|
|
|
|
@item no-timestamp
|
|
@samp{-m} in @code{shar}.
|
|
|
|
@item no-validate
|
|
Used in Makeinfo.
|
|
|
|
@item no-warn
|
|
Used in various programs to inhibit warnings.
|
|
|
|
@item node
|
|
@samp{-n} in @code{info}.
|
|
|
|
@item nodename
|
|
@samp{-n} in @code{uname}.
|
|
|
|
@item nonmatching
|
|
@samp{-f} in @code{cpio}.
|
|
|
|
@item nstuff
|
|
@samp{-n} in @code{objdump}.
|
|
|
|
@item null
|
|
@samp{-0} in @code{xargs}.
|
|
|
|
@item number
|
|
@samp{-n} in @code{cat}.
|
|
|
|
@item number-nonblank
|
|
@samp{-b} in @code{cat}.
|
|
|
|
@item numeric-sort
|
|
@samp{-n} in @code{nm}.
|
|
|
|
@item numeric-uid-gid
|
|
@samp{-n} in @code{cpio} and @code{ls}.
|
|
|
|
@item nx
|
|
Used in GDB.
|
|
|
|
@item old-archive
|
|
@samp{-o} in @code{tar}.
|
|
|
|
@item old-file
|
|
@samp{-o} in Make.
|
|
|
|
@item one-file-system
|
|
@samp{-l} in @code{tar}, @code{cp}, and @code{du}.
|
|
|
|
@item only-file
|
|
@samp{-o} in @code{ptx}.
|
|
|
|
@item only-prof
|
|
@samp{-f} in @code{gprof}.
|
|
|
|
@item only-time
|
|
@samp{-F} in @code{gprof}.
|
|
|
|
@item output
|
|
In various programs, specify the output file name.
|
|
|
|
@item output-prefix
|
|
@samp{-o} in @code{shar}.
|
|
|
|
@item override
|
|
@samp{-o} in @code{rm}.
|
|
|
|
@item overwrite
|
|
@samp{-c} in @code{unshar}.
|
|
|
|
@item owner
|
|
@samp{-o} in @code{install}.
|
|
|
|
@item paginate
|
|
@samp{-l} in @code{diff}.
|
|
|
|
@item paragraph-indent
|
|
Used in Makeinfo.
|
|
|
|
@item parents
|
|
@samp{-p} in @code{mkdir} and @code{rmdir}.
|
|
|
|
@item pass-all
|
|
@samp{-p} in @code{ul}.
|
|
|
|
@item pass-through
|
|
@samp{-p} in @code{cpio}.
|
|
|
|
@item port
|
|
@samp{-P} in @code{finger}.
|
|
|
|
@item portability
|
|
@samp{-c} in @code{cpio} and @code{tar}.
|
|
|
|
@item prefix-builtins
|
|
@samp{-P} in @code{m4}.
|
|
|
|
@item prefix
|
|
@samp{-f} in @code{csplit}.
|
|
|
|
@item preserve
|
|
Used in @code{tar} and @code{cp}.
|
|
|
|
@item preserve-environment
|
|
@samp{-p} in @code{su}.
|
|
|
|
@item preserve-modification-time
|
|
@samp{-m} in @code{cpio}.
|
|
|
|
@item preserve-order
|
|
@samp{-s} in @code{tar}.
|
|
|
|
@item preserve-permissions
|
|
@samp{-p} in @code{tar}.
|
|
|
|
@item print
|
|
@samp{-l} in @code{diff}.
|
|
|
|
@item print-chars
|
|
@samp{-L} in @code{cmp}.
|
|
|
|
@item print-data-base
|
|
@samp{-p} in Make.
|
|
|
|
@item print-directory
|
|
@samp{-w} in Make.
|
|
|
|
@item print-file-name
|
|
@samp{-o} in @code{nm}.
|
|
|
|
@item print-symdefs
|
|
@samp{-s} in @code{nm}.
|
|
|
|
@item printer
|
|
@samp{-p} in @code{wdiff}.
|
|
|
|
@item prompt
|
|
@samp{-p} in @code{ed}.
|
|
|
|
@item query-user
|
|
@samp{-X} in @code{shar}.
|
|
|
|
@item question
|
|
@samp{-q} in Make.
|
|
|
|
@item quiet
|
|
Used in many programs to inhibit the usual output. @strong{Note:} every
|
|
program accepting @samp{--quiet} should accept @samp{--silent} as a
|
|
synonym.
|
|
|
|
@item quiet-unshar
|
|
@samp{-Q} in @code{shar}
|
|
|
|
@item quote-name
|
|
@samp{-Q} in @code{ls}.
|
|
|
|
@item rcs
|
|
@samp{-n} in @code{diff}.
|
|
|
|
@item read-full-blocks
|
|
@samp{-B} in @code{tar}.
|
|
|
|
@item readnow
|
|
Used in GDB.
|
|
|
|
@item recon
|
|
@samp{-n} in Make.
|
|
|
|
@item record-number
|
|
@samp{-R} in @code{tar}.
|
|
|
|
@item recursive
|
|
Used in @code{chgrp}, @code{chown}, @code{cp}, @code{ls}, @code{diff},
|
|
and @code{rm}.
|
|
|
|
@item reference-limit
|
|
Used in Makeinfo.
|
|
|
|
@item references
|
|
@samp{-r} in @code{ptx}.
|
|
|
|
@item regex
|
|
@samp{-r} in @code{tac} and @code{etags}.
|
|
|
|
@item release
|
|
@samp{-r} in @code{uname}.
|
|
|
|
@item reload-state
|
|
@samp{-R} in @code{m4}.
|
|
|
|
@item relocation
|
|
@samp{-r} in @code{objdump}.
|
|
|
|
@item rename
|
|
@samp{-r} in @code{cpio}.
|
|
|
|
@item replace
|
|
@samp{-i} in @code{xargs}.
|
|
|
|
@item report-identical-files
|
|
@samp{-s} in @code{diff}.
|
|
|
|
@item reset-access-time
|
|
@samp{-a} in @code{cpio}.
|
|
|
|
@item reverse
|
|
@samp{-r} in @code{ls} and @code{nm}.
|
|
|
|
@item reversed-ed
|
|
@samp{-f} in @code{diff}.
|
|
|
|
@item right-side-defs
|
|
@samp{-R} in @code{ptx}.
|
|
|
|
@item same-order
|
|
@samp{-s} in @code{tar}.
|
|
|
|
@item same-permissions
|
|
@samp{-p} in @code{tar}.
|
|
|
|
@item save
|
|
@samp{-g} in @code{stty}.
|
|
|
|
@item se
|
|
Used in GDB.
|
|
|
|
@item sentence-regexp
|
|
@samp{-S} in @code{ptx}.
|
|
|
|
@item separate-dirs
|
|
@samp{-S} in @code{du}.
|
|
|
|
@item separator
|
|
@samp{-s} in @code{tac}.
|
|
|
|
@item sequence
|
|
Used by @code{recode} to chose files or pipes for sequencing passes.
|
|
|
|
@item shell
|
|
@samp{-s} in @code{su}.
|
|
|
|
@item show-all
|
|
@samp{-A} in @code{cat}.
|
|
|
|
@item show-c-function
|
|
@samp{-p} in @code{diff}.
|
|
|
|
@item show-ends
|
|
@samp{-E} in @code{cat}.
|
|
|
|
@item show-function-line
|
|
@samp{-F} in @code{diff}.
|
|
|
|
@item show-tabs
|
|
@samp{-T} in @code{cat}.
|
|
|
|
@item silent
|
|
Used in many programs to inhibit the usual output.
|
|
@strong{Note:} every program accepting
|
|
@samp{--silent} should accept @samp{--quiet} as a synonym.
|
|
|
|
@item size
|
|
@samp{-s} in @code{ls}.
|
|
|
|
@item sort
|
|
Used in @code{ls}.
|
|
|
|
@item sparse
|
|
@samp{-S} in @code{tar}.
|
|
|
|
@item speed-large-files
|
|
@samp{-H} in @code{diff}.
|
|
|
|
@item split-at
|
|
@samp{-E} in @code{unshar}.
|
|
|
|
@item split-size-limit
|
|
@samp{-L} in @code{shar}.
|
|
|
|
@item squeeze-blank
|
|
@samp{-s} in @code{cat}.
|
|
|
|
@item start-delete
|
|
@samp{-w} in @code{wdiff}.
|
|
|
|
@item start-insert
|
|
@samp{-y} in @code{wdiff}.
|
|
|
|
@item starting-file
|
|
Used in @code{tar} and @code{diff} to specify which file within
|
|
a directory to start processing with.
|
|
|
|
@item statistics
|
|
@samp{-s} in @code{wdiff}.
|
|
|
|
@item stdin-file-list
|
|
@samp{-S} in @code{shar}.
|
|
|
|
@item stop
|
|
@samp{-S} in Make.
|
|
|
|
@item strict
|
|
@samp{-s} in @code{recode}.
|
|
|
|
@item strip
|
|
@samp{-s} in @code{install}.
|
|
|
|
@item strip-all
|
|
@samp{-s} in @code{strip}.
|
|
|
|
@item strip-debug
|
|
@samp{-S} in @code{strip}.
|
|
|
|
@item submitter
|
|
@samp{-s} in @code{shar}.
|
|
|
|
@item suffix
|
|
@samp{-S} in @code{cp}, @code{ln}, @code{mv}.
|
|
|
|
@item suffix-format
|
|
@samp{-b} in @code{csplit}.
|
|
|
|
@item sum
|
|
@samp{-s} in @code{gprof}.
|
|
|
|
@item summarize
|
|
@samp{-s} in @code{du}.
|
|
|
|
@item symbolic
|
|
@samp{-s} in @code{ln}.
|
|
|
|
@item symbols
|
|
Used in GDB and @code{objdump}.
|
|
|
|
@item synclines
|
|
@samp{-s} in @code{m4}.
|
|
|
|
@item sysname
|
|
@samp{-s} in @code{uname}.
|
|
|
|
@item tabs
|
|
@samp{-t} in @code{expand} and @code{unexpand}.
|
|
|
|
@item tabsize
|
|
@samp{-T} in @code{ls}.
|
|
|
|
@item terminal
|
|
@samp{-T} in @code{tput} and @code{ul}.
|
|
@samp{-t} in @code{wdiff}.
|
|
|
|
@item text
|
|
@samp{-a} in @code{diff}.
|
|
|
|
@item text-files
|
|
@samp{-T} in @code{shar}.
|
|
|
|
@item time
|
|
Used in @code{ls} and @code{touch}.
|
|
|
|
@item to-stdout
|
|
@samp{-O} in @code{tar}.
|
|
|
|
@item total
|
|
@samp{-c} in @code{du}.
|
|
|
|
@item touch
|
|
@samp{-t} in Make, @code{ranlib}, and @code{recode}.
|
|
|
|
@item trace
|
|
@samp{-t} in @code{m4}.
|
|
|
|
@item traditional
|
|
@samp{-t} in @code{hello};
|
|
@samp{-G} in @code{ed}, @code{m4}, and @code{ptx}.
|
|
|
|
@item tty
|
|
Used in GDB.
|
|
|
|
@item typedefs
|
|
@samp{-t} in @code{ctags}.
|
|
|
|
@item typedefs-and-c++
|
|
@samp{-T} in @code{ctags}.
|
|
|
|
@item typeset-mode
|
|
@samp{-t} in @code{ptx}.
|
|
|
|
@item uncompress
|
|
@samp{-z} in @code{tar}.
|
|
|
|
@item unconditional
|
|
@samp{-u} in @code{cpio}.
|
|
|
|
@item undefine
|
|
@samp{-U} in @code{m4}.
|
|
|
|
@item undefined-only
|
|
@samp{-u} in @code{nm}.
|
|
|
|
@item update
|
|
@samp{-u} in @code{cp}, @code{ctags}, @code{mv}, @code{tar}.
|
|
|
|
@item uuencode
|
|
@samp{-B} in @code{shar}.
|
|
|
|
@item vanilla-operation
|
|
@samp{-V} in @code{shar}.
|
|
|
|
@item verbose
|
|
Print more information about progress. Many programs support this.
|
|
|
|
@item verify
|
|
@samp{-W} in @code{tar}.
|
|
|
|
@item version
|
|
Print the version number.
|
|
|
|
@item version-control
|
|
@samp{-V} in @code{cp}, @code{ln}, @code{mv}.
|
|
|
|
@item vgrind
|
|
@samp{-v} in @code{ctags}.
|
|
|
|
@item volume
|
|
@samp{-V} in @code{tar}.
|
|
|
|
@item what-if
|
|
@samp{-W} in Make.
|
|
|
|
@item whole-size-limit
|
|
@samp{-l} in @code{shar}.
|
|
|
|
@item width
|
|
@samp{-w} in @code{ls} and @code{ptx}.
|
|
|
|
@item word-regexp
|
|
@samp{-W} in @code{ptx}.
|
|
|
|
@item writable
|
|
@samp{-T} in @code{who}.
|
|
|
|
@item zeros
|
|
@samp{-z} in @code{gprof}.
|
|
|
|
@end table
|
|
|
|
@node Documentation
|
|
@chapter Documenting Programs
|
|
|
|
@menu
|
|
* GNU Manuals:: Writing proper manuals.
|
|
* Manual Structure Details:: Specific structure conventions.
|
|
* NEWS File:: NEWS files supplement manuals.
|
|
* Man Pages:: Man pages are secondary.
|
|
* Reading other Manuals:: How far you can go in learning
|
|
from other manuals.
|
|
@end menu
|
|
|
|
@node GNU Manuals
|
|
@section GNU Manuals
|
|
|
|
The preferred way to document part of the GNU system is to write a
|
|
manual in the Texinfo formatting language. See the Texinfo manual,
|
|
either the hardcopy or the version in the Emacs Info subsystem (@kbd{C-h
|
|
i}).
|
|
|
|
The manual should document all of the program's command-line options and
|
|
all of its commands. It should give examples of their use. But don't
|
|
organize the manual as a list of features. Instead, organize it
|
|
logically, by subtopics. Address the goals that a user will have in
|
|
mind, and explain how to accomplish them.
|
|
|
|
In general, a GNU manual should serve both as tutorial and reference.
|
|
It should be set up for convenient access to each topic through Info,
|
|
and for reading straight through (appendixes aside). A GNU manual
|
|
should give a good introduction to a beginner reading through from the
|
|
start, and should also provide all the details that hackers want.
|
|
|
|
That is not as hard as it sounds at first. Arrange each chapter as a
|
|
logical breakdown of its topic, but order the sections, and write their
|
|
text, so that reading the chapter straight through makes sense. Do
|
|
likewise when structuring the book into chapters, and when structuring a
|
|
section into paragraphs. The watchword is, @emph{at each point, address
|
|
the most fundamental and important issue raised by the preceding text.}
|
|
|
|
If necessary, add extra chapters at the beginning of the manual which
|
|
are purely tutorial and cover the basics of the subject. These provide
|
|
the framework for a beginner to understand the rest of the manual. The
|
|
Bison manual provides a good example of how to do this.
|
|
|
|
Don't use Unix man pages as a model for how to write GNU documentation;
|
|
they are a bad example to follow.
|
|
|
|
Please do not use the term ``pathname'' that is used in Unix
|
|
documentation; use ``file name'' (two words) instead. We use the term
|
|
``path'' only for search paths, which are lists of file names.
|
|
|
|
@node Manual Structure Details
|
|
@section Manual Structure Details
|
|
|
|
The title page of the manual should state the version of the program
|
|
which the manual applies to. The Top node of the manual should also
|
|
contain this information. If the manual is changing more frequently
|
|
than or independent of the program, also state a version number for
|
|
the manual in both of these places.
|
|
|
|
The manual should have a node named @samp{@var{program} Invocation} or
|
|
@samp{Invoking @var{program}}, where @var{program} stands for the name
|
|
of the program being described, as you would type it in the shell to run
|
|
the program. This node (together with its subnodes, if any) should
|
|
describe the program's command line arguments and how to run it (the
|
|
sort of information people would look in a man page for). Start with an
|
|
@samp{@@example} containing a template for all the options and arguments
|
|
that the program uses.
|
|
|
|
Alternatively, put a menu item in some menu whose item name fits one of
|
|
the above patterns. This identifies the node which that item points to
|
|
as the node for this purpose, regardless of the node's actual name.
|
|
|
|
There will be automatic features for specifying a program name and
|
|
quickly reading just this part of its manual.
|
|
|
|
If one manual describes several programs, it should have such a node for
|
|
each program described.
|
|
|
|
@node NEWS File
|
|
@section The NEWS File
|
|
|
|
In addition to its manual, the package should have a file named
|
|
@file{NEWS} which contains a list of user-visible changes worth
|
|
mentioning. In each new release, add items to the front of the file and
|
|
identify the version they pertain to. Don't discard old items; leave
|
|
them in the file after the newer items. This way, a user upgrading from
|
|
any previous version can see what is new.
|
|
|
|
If the @file{NEWS} file gets very long, move some of the older items
|
|
into a file named @file{ONEWS} and put a note at the end referring the
|
|
user to that file.
|
|
|
|
@node Man Pages
|
|
@section Man Pages
|
|
|
|
It is ok to supply a man page for the program as well as a Texinfo
|
|
manual if you wish to. But keep in mind that supporting a man page
|
|
requires continual effort, each time the program is changed. Any time
|
|
you spend on the man page is time taken away from more useful things you
|
|
could contribute.
|
|
|
|
Thus, even if a user volunteers to donate a man page, you may find this
|
|
gift costly to accept. Unless you have time on your hands, it may be
|
|
better to refuse the man page unless the same volunteer agrees to take
|
|
full responsibility for maintaining it---so that you can wash your hands
|
|
of it entirely. If the volunteer ceases to do the job, then don't feel
|
|
obliged to pick it up yourself; it may be better to withdraw the man
|
|
page until another volunteer offers to carry on with it.
|
|
|
|
Alternatively, if you expect the discrepancies to be small enough that
|
|
the man page remains useful, put a prominent note near the beginning of
|
|
the man page explaining that you don't maintain it and that the Texinfo
|
|
manual is more authoritative, and describing how to access the Texinfo
|
|
documentation.
|
|
|
|
@node Reading other Manuals
|
|
@section Reading other Manuals
|
|
|
|
There may be non-free books or documentation files that describe the
|
|
program you are documenting.
|
|
|
|
It is ok to use these documents for reference, just as the author of a
|
|
new algebra textbook can read other books on algebra. A large portion
|
|
of any non-fiction book consists of facts, in this case facts about how
|
|
a certain program works, and these facts are necessarily the same for
|
|
everyone who writes about the subject. But be careful not to copy your
|
|
outline structure, wording, tables or examples from preexisting non-free
|
|
documentation. Copying from free documentation may be ok; please check
|
|
with the FSF about the individual case.
|
|
|
|
@node Releases
|
|
@chapter Making Releases
|
|
|
|
Package the distribution of Foo version 69.96 in a gzipped tar file
|
|
named @file{foo-69.96.tar.gz}. It should unpack into a subdirectory
|
|
named @file{foo-69.96}.
|
|
|
|
Building and installing the program should never modify any of the files
|
|
contained in the distribution. This means that all the files that form
|
|
part of the program in any way must be classified into @dfn{source
|
|
files} and @dfn{non-source files}. Source files are written by humans
|
|
and never changed automatically; non-source files are produced from
|
|
source files by programs under the control of the Makefile.
|
|
|
|
Naturally, all the source files must be in the distribution. It is okay
|
|
to include non-source files in the distribution, provided they are
|
|
up-to-date and machine-independent, so that building the distribution
|
|
normally will never modify them. We commonly include non-source files
|
|
produced by Bison, Lex, @TeX{}, and Makeinfo; this helps avoid
|
|
unnecessary dependencies between our distributions, so that users can
|
|
install whichever packages they want to install.
|
|
|
|
Non-source files that might actually be modified by building and
|
|
installing the program should @strong{never} be included in the
|
|
distribution. So if you do distribute non-source files, always make
|
|
sure they are up to date when you make a new distribution.
|
|
|
|
Make sure that the directory into which the distribution unpacks (as
|
|
well as any subdirectories) are all world-writable (octal mode 777).
|
|
This is so that old versions of @code{tar} which preserve the
|
|
ownership and permissions of the files from the tar archive will be
|
|
able to extract all the files even if the user is unprivileged.
|
|
|
|
Make sure that all the files in the distribution are world-readable.
|
|
|
|
Make sure that no file name in the distribution is more than 14
|
|
characters long. Likewise, no file created by building the program
|
|
should have a name longer than 14 characters. The reason for this is
|
|
that some systems adhere to a foolish interpretation of the POSIX
|
|
standard, and refuse to open a longer name, rather than truncating as
|
|
they did in the past.
|
|
|
|
Don't include any symbolic links in the distribution itself. If the tar
|
|
file contains symbolic links, then people cannot even unpack it on
|
|
systems that don't support symbolic links. Also, don't use multiple
|
|
names for one file in different directories, because certain file
|
|
systems cannot handle this and that prevents unpacking the
|
|
distribution.
|
|
|
|
Try to make sure that all the file names will be unique on MS-DOG. A
|
|
name on MS-DOG consists of up to 8 characters, optionally followed by a
|
|
period and up to three characters. MS-DOG will truncate extra
|
|
characters both before and after the period. Thus,
|
|
@file{foobarhacker.c} and @file{foobarhacker.o} are not ambiguous; they
|
|
are truncated to @file{foobarha.c} and @file{foobarha.o}, which are
|
|
distinct.
|
|
|
|
Include in your distribution a copy of the @file{texinfo.tex} you used
|
|
to test print any @file{*.texinfo} files.
|
|
|
|
Likewise, if your program uses small GNU software packages like regex,
|
|
getopt, obstack, or termcap, include them in the distribution file.
|
|
Leaving them out would make the distribution file a little smaller at
|
|
the expense of possible inconvenience to a user who doesn't know what
|
|
other files to get.
|
|
|
|
@contents
|
|
|
|
@bye
|