indent man page on DigitalUNIX

Man page or keyword search:  
man Server   12896 pages
apropos Keyword Search (all sections)
Output format
DigitalUNIX logo
[printable version]

indent(1)							     indent(1)

NAME
       indent - changes the appearance of a C program by inserting or deleting
       whitespace

SYNOPSIS
       indent [-bad] [-bap] [-bbb] [-bc]  [-bl]	 [-bliN]  [-br]	 [-cN]	[-cdN]
       [-cdb]  [-ce]  [-ciN]  [-cliN]  [-cpN]  [-cs] [-bs] [-dN] [-diN] [-fc1]
       [-fca] [-gnu] [-iN] [-ipN] [-kr] [-lN] [-lp]  [-nbad]  [-nbap]  [-nbbb]
       [-nbc]  [-ncdb]	[-nce]	[-ncs]	[-nfc1]	 [-nfca] [-nip] [-nlp] [-npcs]
       [-npsl] [-nsc] [-nsob] [-nss] [-nv] [-orig] [-npro] [-pcs] [-psl] [-sc]
       [-sob] [-ss] [-st] [-T] [-tsN] [-v] [-version] [file]

OPTIONS
       Here  is	 a  list  of all the options for indent, alphabetized by short
       option.	It is followed by a cross key  alphabetized  by	 long  option.
       Force blank lines after the declarations.

	      Long  option: --blank-lines-after-declarations Force blank lines
	      after procedure bodies.

	      Long option: --blank-lines-after-procedures  Force  blank	 lines
	      after block comments.

	      Long  option:  --blank-lines-after-block-comments	 Force newline
	      after comma in declaration.

	      Long option: --blank-lines-after-commas Put braces on line after
	      if, etc.

	      Long option: --braces-after-if-line Indent braces N spaces.

	      Long option: --brace-indentN Put braces on line with if, etc.

	      Long  option:--braces-on-if-line	Put  comments  to the right of
	      code in column N.

	      Long option: --comment-indentationN Put comments to the right of
	      the declarations in column N.

	      Long  option:  --declaration-comment-columnN  Put comment delim‐
	      iters on blank lines.

	      Long option: --comment-delimiters-on-blank-lines Cuddle else and
	      preceding }.

	      Long option: --cuddle-else Continuation indent of N spaces.

	      Long  option: --continuation-indentationN Case label indent of N
	      spaces.

	      Long option: --case-indentationN Put comments to	the  right  of
	      #else and #endif statements in column N.

	      Long option: --else-endif-columnN Put a space after a cast oper‐
	      ator.

	      Long option: --space-after-cast Put a space between  sizeof  and
	      its argument.

	      Long  option:  --blank-before-sizeof Set indentation of comments
	      not to the right of code to N spaces.

	      Long option: --line-comments-indentationN Put variables in  col‐
	      umn N.

	      Long  option:  --declaration-indentationN Format comments in the
	      first column.

	      Long option: --format-first-column-comments Do not  disable  all
	      formatting of comments.

	      Long  option:  --format-all-comments Use GNU coding style.  This
	      is the default.

	      Long option: --gnu-style Set indentation level to N spaces.

	      Long option: --indent-levelN Indent parameter types in old-style
	      function definitions by N spaces.

	      Long  option:  --parameter-indentationN  Use Kernighan & Ritchie
	      coding style.

	      Long option: --k-and-r-style Set maximum line length to N.

	      Long option: --line-lengthN Line up continued lines at parenthe‐
	      ses.

	      Long  option: --continue-at-parentheses Do not force blank lines
	      after declarations.

	      Long option: --no-blank-lines-after-declarations	Do  not	 force
	      blank lines after procedure bodies.

	      Long  option:  --no-blank-lines-after-procedures	Do  not	 force
	      blank-lines after block comments.

	      Long option: --no-blank-lines-after-block-comments Do not	 force
	      newlines after commas in declarations.

	      Long  option:  --no-blank-lines-after-commas  Do not put comment
	      delimiters on blank lines.

	      Long option: --no-comment-delimiters-on-blank-lines Do not  cud‐
	      dle } and else.

	      Long  option:  --dont-cuddle-else	 Do not put a space after cast
	      operators.

	      Long option: --no-space-after-casts Do not  format  comments  in
	      the first column as normal.

	      Long  option:  --dont-format-first-column-comments Do not format
	      any comments.

	      Long option: --dont-format-comments Zero width  indentation  for
	      parameters.

	      Long option: --no-parameter-indentation Do not line up parenthe‐
	      ses.

	      Long option: --dont-line-up-parentheses Do not put  space	 after
	      the function in function calls.

	      Long  option:  --no-space-after-function-call-names Put the type
	      of a procedure on the same line as its name.

	      Long option: --dont-break-procedure-type Do not put the *	 char‐
	      acter at the left of comments.

	      Long  option: --dont-star-comments Do not swallow optional blank
	      lines.

	      Long option: --leave-optional-blank-lines Do not force  a	 space
	      before the semicolon after certain statements.  Disables -ss.

	      Long  option:  --dont-space-special-semicolon Long option: --no-
	      verbosity Use the original Berkeley coding style.

	      Long option: --original Do not read files.

	      Long option: --ignore-profile Insert a space between the name of
	      the procedure being called and the (.

	      Long  option:  --space-after-procedure-calls  Put	 the type of a
	      procedure on the line before its name.

	      Long option: --procnames-start-lines Put the * character at  the
	      left of comments.

	      Long   option:  --start-left-side-of-comments  Swallow  optional
	      blank lines.

	      Long option: --swallow-optional-blank-lines On one-line for  and
	      while statements, force a blank before the semicolon.

	      Long option: --space-special-semicolon Write to standard output.

	      Long  option:  --standard-output	Tell  indent the name of type‐
	      names.  Set tab size to N spaces.

	      Long option: --tab-sizeN Enable verbose mode.

	      Long option: --verbose Output the version number of indent.

OPTIONS CROSS-REFERENCE
       Here is a list of options alphabetized by long option to help you  find
       the corresponding short option.

	    --blank-lines-after-block-comments		    -bbb
	    --blank-lines-after-commas			    -bc
	    --blank-lines-after-declarations		    -bad
	    --blank-lines-after-procedures		    -bap
	    --braces-after-if-line			    -bl
	    --brace-indent				    -bli
	    --braces-on-if-line				    -br
	    --case-indentation				    -cliN
	    --comment-delimiters-on-blank-lines		    -cdb
	    --comment-indentation			    -cN
	    --continuation-indentation			    -ciN
	    --continue-at-parentheses			    -lp
	    --cuddle-else				    -ce
	    --declaration-comment-column		    -cdN
	    --declaration-indentation			    -diN
	    --dont-break-procedure-type			    -npsl
	    --dont-cuddle-else				    -nce
	    --dont-format-comments			    -nfca
	    --dont-format-first-column-comments		    -nfc1
	    --dont-line-up-parentheses			    -nlp
	    --dont-space-special-semicolon		    -nss
	    --dont-star-comments			    -nsc
	    --else-endif-column				    -cpN
	    --format-all-comments			    -fca
	    --format-first-column-comments		    -fc1
	    --gnu-style					    -gnu
	    --ignore-profile				    -npro
	    --indent-level				    -iN
	    --k-and-r-style				    -kr
	    --leave-optional-blank-lines		    -nsob
	    --line-comments-indentation			    -dN
	    --line-length				    -lN
	    --no-blank-lines-after-block-comments	    -nbbb
	    --no-blank-lines-after-commas		    -nbc
	    --no-blank-lines-after-declarations		    -nbad
	    --no-blank-lines-after-procedures		    -nbap
	    --no-comment-delimiters-on-blank-lines	    -ncdb
	    --no-space-after-casts			    -ncs
	    --no-parameter-indentation			    -nip
	    --no-space-after-function-call-names	    -npcs
	    --no-verbosity				    -nv
	    --original					    -orig
	    --parameter-indentation			    -ipN
	    --procnames-start-lines			    -psl
	    --space-after-cast				    -cs
	    --space-after-procedure-calls		    -pcs
	    --space-special-semicolon			    -ss
	    --standard-output				    -st
	    --start-left-side-of-comments		    -sc
	    --swallow-optional-blank-lines		    -sob
	    --tab-size					    -tsN
	    --verbose					    -v

DESCRIPTION
       This  man page is based on the Info file indent.info, produced by Make‐
       info-1.47 from the input file indent.texinfo.  This is Edition 0.02,  5
       May 1992, of The indent Manual (for indent Version 1.3).

       Copyright (C) 1989, 1992 Free Software Foundation, Inc.

COPYING
       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.

INTRODUCTION
       The  indent  program  can  be used to make code easier to read.	It can
       also convert from one style of writing C to another.

       The indent program understands a substantial amount about the syntax of
       C, but it also attempts to cope with incomplete and misformed syntax.

       In  version 1.2 and more recent versions, the GNU style of indenting is
       the default.

INVOKING INDENT
       As of version 1.3, the format of the indent command is:

       indent [OPTIONS] [INPUT-FILES] indent [OPTIONS] [SINGLE-INPUT-FILE] [-o
       OUTPUT-FILE]

       This  format  is	 different from earlier versions and other versions of
       indent.

       In the first form, one or more input files are  specified.  The	indent
       program	makes  a  backup  copy	of each file, and the original file is
       replaced with its indented version. For an explanation of  how  backups
       are made, see Backup Files.

       In the second form, only one input file is specified.  In this case, or
       when the standard input is used, you may specify an output  file	 after
       the -o option.

       To  cause indent to write to standard output, use the -st option.  This
       is only allowed when there is only one input file, or when the standard
       input is used.

       If  no  input  files  are  named, the standard input is read for input.
       Also, if a filename named - is specified, then the  standard  input  is
       read.

       As  an  example,	 each of the following commands will input the program
       slithy_toves.c and write its indented text to slithy_toves.out:

       indent slithy_toves.c -o slithy_toves.out indent -st  slithy_toves.c  >
       slithy_toves.out cat slithy_toves.c | indent -o slithy_toves.out

       Most  other options to indent control how programs are formatted. As of
       version 1.2, indent also recognizes a long name for each	 option	 name.
       Long  options  are  prefixed  by either -- or +.	 The + prefix is being
       superseded by -- to maintain consistency with the  POSIX	 standard.  In
       most  of	 this  document, the traditional, short names are used for the
       sake of brevity.

       As another example, the	following  command  will  indent  the  program
       test/metabolism.c using the -br and -l85 options, write the output back
       to test/metabolism.c, and write the original contents  of  test/metabo‐
       lism.c to a backup file in the directory test:

       indent -br test/metabolism.c -l85

       Equivalent  invocations	using long option names for this example would
       be:

       indent --braces-on-if-line  --line-length185  test/metabolism.c	indent
       +braces-on-if-line +line-length185 test/metabolism.c

       If  you	find  that you often use indent with the same options, you may
       put those options into a file named indent program will first look  for
       in  the	current directory and use that file if it is found. Otherwise,
       indent will search your home directory for and use that file if	it  is
       found.	This  behavior	is  different  from  that of other versions of
       indent, which load both files if they both exist.

       Command line switches are handled *after* processing  with  one	excep‐
       tion:  Explicitly  specified options always override background options
       (see COMMON STYLES).  You can prevent indent from reading  an  file  by
       specifying the -npro option.

BACKUP FILES
       As  of  version	1.3, GNU indent makes GNU-style backup files, the same
       way GNU Emacs does.  This means	that  either  “simple”	or  “numbered”
       backup filenames may be made.

       Simple  backup  file  names  are generated by appending a suffix to the
       original file name.  The default for the this suffix is the one-charac‐
       ter  string  ~  (tilde).	 Thus,	the  backup file for python.c would be
       python.c~.

       Instead of the default, you may specify any string as a suffix by  set‐
       ting  the  environment  variable SIMPLE_BACKUP_SUFFIX to your preferred
       suffix.

       Numbered	  backup   versions   of   a   file   momewraths   look	  like
       momewraths.c.~23~,  where  23 is the version of this particular backup.
       When making a numbered backup of the file src/momewrath.c,  the	backup
       file will be named src/momewrath.c.~V~, where V is one greater than the
       highest version currently existing in the directory src.

       The type of backup file made is controlled by the value of the environ‐
       ment  variable  VERSION_CONTROL.	 If it is the string simple, then only
       simple backups will be made. If its value is the string numbered,  then
       numbered backups will be made.  If its value is numbered-existing, then
       numbered backups will be made if numbered backups *already  exist*  for
       the  file  being	 indented; otherwise, a simple backup is made. If VER‐
       SION_CONTROL is not set, then indent assumes the behavior of  numbered-
       existing.

       Other  versions	of indent use the suffix in naming backup files.  This
       behavior can be emulated by setting SIMPLE_BACKUP_SUFFIX to

       Note also that other versions of indent make  backups  in  the  current
       directory,  rather  than	 in  the  directory  of the source file as GNU
       indent now does.

COMMON STYLES
       Common styles of C code include the GNU style, the Kernighan &  Ritchie
       style, and the original Berkeley style.	A style may be selected with a
       single “background” option, which specifies a set  of  values  for  all
       other  options.	 However, explicitly specified options always override
       options implied by a background option.

       As of version 1.2, the default style of GNU indent is  the  GNU	style.
       Thus,  it  is  no longer necessary to specify the option -gnu to obtain
       this format, although doing so will not cause an	 error.	  Option  set‐
       tings which correspond to the GNU style are:

       -nbad  -bap  -nbbb -nbc -bl -bli2 -c33 -cd33 -ncdb -nce -cli0 -cp1 -di0
       -nfc1 -nfca -i2 -ip5 -lp -pcs -psl -nsc -nsob -nss -ts8

       The GNU coding style is the style that is preferred by the GNU project.
       It  is the style that the GNU Emacs C mode encourages and which is used
       in the C portions of GNU Emacs. (People interested in writing  programs
       for  Project  GNU  should get a copy of The GNU Coding Standards, which
       also covers semantic and portability issues such as memory  usage,  the
       size of integers, etc.)

       The  Kernighan & Ritchie style is used throughout their well-known book
       The C Programming Language.  It is enabled with	the  -kr  option.  The
       Kernighan & Ritchie style corresponds to the following set of options:

       -nbad  -bap  -nbbb  -nbc	 -br -c33 -cd33 -ncdb -ce -ci4 -cli0 -cp33 -d0
       -di1 -nfc1 -nfca -i4 -ip0 -l75 -lp -npcs -npsl -nsc -nsob -nss -ts8

       Kernighan & Ritchie style does not put comments to the right of code in
       the  same  column  at  all times (nor does it use only one space to the
       right of the code), so for this style  indent  has  arbitrarily	chosen
       column 33.

       The style of the original Berkeley indent may be obtained by specifying
       -orig (or by specifying --original, the long option name).  This	 style
       is equivalent to the following settings: -nbap -nbad -nbbb -bc -br -c33
       -cd33 -cdb -ce -ci4 -cli0 -cp33 -d4 -di16 -fc1 -fca -i4 -ip4  -l75  -lp
       -npcs -psl -sc -nsob -nss -ts8

BLANK LINES
       Various	programming  styles  use  blank lines in different places. The
       indent program has a number of options to insert or delete blank	 lines
       in specific places.

       The  -bad  option causes indent to force a blank line after every block
       of declarations.	 The -nbad option causes  indent  not  to  force  such
       blank lines.

       The  -bap  option  forces  a blank line after every procedure body. The
       -nbap option forces no such blank line.

       The -bbb option forces a blank line before every block comment. A block
       comment	is one which starts in column one when formatting of such com‐
       ments is disabled, or one with - or * immediately following the /*. The
       -nbbb option does not force such blank lines.

       The -sob option causes indent to swallow optional blank lines (that is,
       any optional blank lines present in the input will be removed from  the
       output).	  If  the  -nsob  is specified, any blank lines present in the
       input file will be copied to the output file.

       The -bad option forces a blank line after every block of	 declarations.
       The -nbad option does not add any such blank lines.

       For example, given the input:

	    char *foo;
	    char *bar;
	    /* This separates blocks of declarations.  */
	    int baz;

       The -bad option produces:

	    char *foo;
	    char *bar;

	    /* This separates blocks of declarations.  */
	    int baz;

       The -nbad option produces:

	    char *foo;
	    char *bar;
	    /* This separates blocks of declarations.  */
	    int baz;

       The  -bap  option  forces  a blank line after every procedure body. For
       example, given the input:

	    int
	    foo ()
	    {
	      puts("Hi");
	    }
	    /* The procedure bar is even less interesting.  */
	    char *
	    bar ()
	    {
	      puts("Hello");
	    }

       The -bap option produces:

	    int
	    foo ()
	    {
	      puts ("Hi");
	    }

	    /* The procedure bar is even less interesting.  */
	    char *
	    bar ()
	    {
	      puts ("Hello");
	    }

       The -nbap option produces:

	    int
	    foo ()
	    {
	      puts ("Hi");
	    }
	    /* The procedure bar is even less interesting.  */
	    char *
	    bar ()
	    {
	      puts ("Hello");
	    }

       No blank line will be added after the procedure foo.

COMMENTS
       Comments are no longer formatted by default as of version 1.2. This can
       be  enabled  with the -fca option.  Doing so will cause newlines in the
       comment text to be ignored and the line will be filled up to the length
       of  a line (which can be modified with -l). When formatting is enabled,
       blank lines indicate paragraph breaks.

       The -fc1 option enables the formatting of comments which begin  in  the
       first column.  The -nfc1 option disables the formatting of first column
       comments.  When comment formatting is disabled, overall comment	inden‐
       tation may still be adjusted.

       The indentation of comments which do not appear to the right of code is
       set by the -d option, which specifies the number of spaces to the  left
       of  the	surrounding  code  that	 the comment appears. For example, -d2
       places comments two spaces to the left of the code; -d0 lines  up  com‐
       ments with the code. The -cdb option controls whether the /* and */ are
       placed on blank lines.  With -cdb, comments look like this:

	    /*
	     * this is a comment
	     */

       With -ncdb, comments look like this:

	    /* this is a comment */

       The -cdb option affects only block comments, not comments to the	 right
       of code. The default is -ncdb.

       Comments	 that appear on the same line as code are placed to the right.
       The column in which comments on code start  is  controlled  by  the  -c
       option.	 The  column  in  which	 comments to the right of declarations
       start is controlled by the -cd option. By default, they	start  in  the
       same  column as comments to the right of code, which is column 33.  The
       column number for comments to the right of #else and #endif  statements
       is  controlled  by  the -cp option.  If the code on a line extends past
       the comment column, the comment starts further to the  right,  and  the
       right margin may be automatically extended in extreme cases.

       If  the	-sc  option  is specified, * is placed at the left edge of all
       comments.  For example:

	    /* This is a comment which extends from one line
	     * onto the next line, thus causing us to consider
	     * how it should continue.	*/

       instead of:

	    /* This is a comment which extends from one line
	       onto the next line, thus causing us to consider
	       how it should continue.	*/

STATEMENTS
       The -br or -bl option specifies how to format braces.  The  -br	option
       formats braces like this:

	    if (x > 0) {
	      x--;
	    }

       The -bl option formats them like this:

	    if (x > 0)
	      {
		x--;
	      }

       If  you	use  the  -bl  option,	you  may also want to specify the -bli
       option.	This option specifies the number of spaces by which braces are
       indented.  -bli2, the default, gives the result shown above.  The -bli0
       option results in the following:

	    if (x > 0)
	    {
	      x--;
	    }

       If you are using the -br option, you probably want to also use the  -ce
       option.	This causes the else in an if-then-else construct to cuddle up
       to the immediately preceding }. For example, with -br -ce, you get  the
       following:

	    if (x > 0) {
	      x--;
	    } else { <!-- COMMENT follows -->	    fprintf (stderr, "...some‐
       thing wrong?\n");

	    }

       With -br -nce, that code would appear as follows:

	    if (x > 0) {
	      x--;
	    }
	    else { <!-- COMMENT follows -->	  fprintf  (stderr,  "...some‐
       thing wrong?\n");

	    }

       The  -cli option specifies the number of spaces that case labels should
       be indented to the right of the containing switch statement.

       If a semicolon is on the same line as a for or while statement, the -ss
       option  will  cause  a  space  to  be placed before the semicolon. This
       emphasizes the semicolon, making it clear that the body of the  for  or
       while  statement	 is  an empty statement. The -nss option disables this
       feature.

       The -pcs option causes a space to be placed between  the	 name  of  the
       procedure  being	 called	 and  the  left parenthesis, for example, puts
       ("Hi");. The -npcs option would give puts("Hi");.

       If the -cs option is specified, indent puts a space after a cast opera‐
       tor.

       The -bs option ensures that there is a space between the keyword sizeof
       and its argument.  In some versions, this is known as the  Bill_Shannon
       option.

DECLARATIONS
       By  default, indent will line up identifiers in the column specified by
       the -di option.	For example, -di16 makes things appear as follows:

	   int		foo;
	   char		*bar;

       Using a small value (such as one or two) for the -di option can be used
       to  cause the identifiers to be placed in the first available position.
       For example:

	    int foo;
	    char *bar;

       The value given to the -di option will still affect variables that  are
       put on separate lines from their types; for example, -di2 will lead to:

	   int
	     foo;

       If the -bc option is specified, a newline is forced after each comma in
       a declaration.  For example:

	    int a,
	      b,
	      c;

       With the -nbc option, the preceding declaration would  appear  as  fol‐
       lows:

	    int a, b, c;

       The  -psl  option  causes  the  type of a procedure being defined to be
       placed on the line before the name of the  procedure.   This  style  is
       required	 for  the  etags program to work correctly, as well as some of
       the c-mode functions of Emacs.

       If you are not using the -di1 option to place variables being  declared
       immediately  after  their  type,	 you need to use the -T option to tell
       indent the name of all the typenames in your program that  are  defined
       by  typedef.   The  -T  option can be specified more than once, and all
       names specified are used.  For example, you would use  the  options  -T
       CODE_ADDR -T COLOR if your program contains:

	    typedef unsigned long CODE_ADDR;
	    typedef enum {red, blue, green} COLOR;

INDENTATION
       One  issue  in  the  formatting	of code is how far each line should be
       indented from the left margin.  When the beginning of a statement  such
       as  if or for is encountered, the indentation level is increased by the
       value specified by the -i option. For example, use -i8  to  specify  an
       eight-character indentation for each level. When a statement is contin‐
       ued from a previous line, it is indented by a number of additional spa‐
       ces specified by the -ci option. The -ci option defaults to 0. However,
       if the -lp option is specified and a line has a left  parenthesis  that
       is not closed on that line, then continuation lines will be lined up to
       start at the character position just after the left parenthesis.	  This
       processing  also	 applies  to [ and applies to { when it occurs in ini‐
       tialization lists. For example, a piece of continued code might	appear
       as follows with -nlp -ci3 in effect:

	      p1 = first_procedure (second_procedure (p2, p3),
		 third_procedure (p4, p5));

       With -lp in effect, the code is somewhat clearer:

	      p1 = first_procedure (second_procedure (p2, p3),
				    third_procedure (p4, p5));

       The indent program assumes that tabs are placed at regular intervals of
       both input and output character streams. These intervals are by default
       8  columns  wide,  but  (as  of	version 1.2) may be changed by the -ts
       option. Tabs are treated as the equivalent number of spaces.

       The indentation of type declarations in old-style function  definitions
       is controlled by the -ip parameter.  This is a numeric parameter speci‐
       fying how many spaces that type declarations are to  be	indented.  For
       example, the default -ip5 makes definitions look like this:
	    char *
	    create_world (x, y, scale)
		 int x;
		 int y;
		 float scale;
	    {
	      . . .
	    }

       For  compatibility  with	 other	versions of indent, the option -nip is
       provided, which is equivalent to -ip0.

MISCELLANEOUS OPTIONS
       To find out what version of indent you have,  use  the  command	indent
       -version.  This will report the version number of indent, without doing
       any of the normal processing.

       The -v option can be used to turn on verbose  mode.   When  in  verbose
       mode,  indent  reports  when  it splits one line of input into two more
       lines of output, and gives some size statistics at completion.

COPYRIGHT
       The following copyright notice applies to the indent program. The copy‐
       right and copying permissions for this manual appear near the beginning
       of this document.

       Copyright (c) 1989, 1992 Free Software Foundation

       Copyright (c) 1985 Sun Microsystems, Inc.

       Copyright (c) 1980 The Regents of the University of California.

       Copyright (c) 1976 Board of Trustees of the University of Illinois.

       All rights reserved.

       Redistribution and use in source and binary forms  are  permitted  pro‐
       vided that the above copyright notice and this paragraph are duplicated
       in all such forms and that any  documentation,  advertising  materials,
       and  other  materials  related to such distribution and use acknowledge
       that the software was developed by the University of California, Berke‐
       ley,  the  University  of  Illinois, Urbana, and Sun Microsystems, Inc.
       The name of either University or Sun Microsystems may not  be  used  to
       endorse or promote products derived from this software without specific
       prior written permission. THIS SOFTWARE IS PROVIDED “AS IS” AND WITHOUT
       ANY  EXPRESS  OR IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE
       IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PUR‐
       POSE.

RETURN VALUE
       Unknown

AUTHOR
       The Free Software Foundation.

HISTORY
       Derived from the UCB program “indent”.

FILES
       Holds default options for the indent program.

								     indent(1)
[top]

List of man pages available for DigitalUNIX

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Tweet
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
....................................................................
Vote for polarhome
Free Shell Accounts :: the biggest list on the net