Museum

Home

Lab Overview

Retrotechnology Articles

Online Manuals

⇒ bfs(C) — OpenDesktop 3.0.0

Media Vault

Software Library

Restoration Projects

Artifacts Sought

Related Articles

csplit(C)

ed(C)

umask(C)


 bfs(C)                          19 June 1992                          bfs(C)


 Name

    bfs - scan big files

 Syntax

    bfs [ - ] name

 Description

    bfs is like ed(C) except that it is read-only and processes much larger
    files.  Files can be up to 1024K bytes and 32K lines, with up to 255
    characters per line.  bfs is usually more efficient than ed for scanning
    a file, since the file is not copied to a buffer.  It is most useful for
    identifying sections of a large file where csplit(C) can be used to
    divide it into more manageable pieces for editing.

    Normally, the size of the file being scanned is printed, in the same way
    as the size of any file written with the w command.  The optional dash
    (-) suppresses printing of sizes.  Input is prompted for with an asterisk
    (*) when ``P'' and Return are typed.  The ``P'' acts as a toggle, so
    prompting can be turned off again by entering another ``P'' and a Return.
    Note that messages are given in response to errors only if prompting is
    turned on.

    All address expressions described under ed are supported.  In addition,
    regular expressions may be surrounded with two symbols other than the
    standard slash (/) and ``?'':  A greater-than sign (>) indicates downward
    search without wraparound, and a less-than sign (<) indicates upward
    search without wraparound.  Note that parentheses and curly braces are
    special and need to be escaped with a backslash (\).  Since bfs uses a
    different regular expression-matching routine from ed, the regular
    expressions accepted are slightly wider in scope (see regex(S)).  Differ-
    ences between ed and bfs are listed below:

    +           A regular expression followed by ``+'' means ``one or more
                times''.  For example, [0-9]+ is equivalent to [0-9][0-9]*.

    \{m\} \{m,\} \{m,u\}
                Integer values enclosed in \{ \} indicate the number of times
                the preceding regular expression is to be applied.  m is the
                minimum number and u is a number, less than 256, which is the
                maximum.  If only m is present (for example, \{m\}), it indi-
                cates the exact number of times the regular expression is to
                be applied.  \{m,\} is analogous to \{m,infinity\}.  The plus
                (+) and star (*) operations are equivalent to \{1,\} and
                \{0,\} respectively.

    ( ... )$n   The value of the enclosed regular expression is to be
                returned.  The value will be stored in the (n+1)th argument
                following the subject argument.  At most ten enclosed regular
                expressions are allowed.  regex makes its assignments uncon-
                ditionally.

    ( ... )     Parentheses are used for grouping.  An operator, for example
                *, +, \{ and \}, can work on a single character or a regular
                expression enclosed in parentheses.  For example,

                \ (a*\ (cb+\ )*\ )$0.

    There is also a slight difference in mark names: only the letters ``a''
    through ``z'' may be used, and all 26 marks are remembered.

    The e, g, v, k, p, q, w, =, !  and null commands operate as described
    under ed except that e does not remember filenames and g and v, when
    given no arguments, return the line after the line you were on.  Commands
    such as ---, +++-, +++=, -12, and +4p are accepted.  Note that 1,10p and
    1,10 will both print the first ten lines.  The f command only prints the
    name of the file being scanned; there is no remembered filename.  The w
    command is independent of output diversion, truncation, or crunching (see
    the xo, xt and xc commands, below).  The following additional commands
    are available:

    xf file   Further commands are taken from the named file.  When an end-
              of-file is reached or an interrupt signal is received, or an
              error occurs, reading resumes with the file containing the xf.
              xf commands may be nested to a depth of 10.

    xo [ file ]
              Further output from the p and null commands is diverted to the
              named file.  If file is missing, output is diverted to the
              standard output.  Note that each diversion causes truncation or
              creation of the file.

    : label   This positions a label in a command file.  The label is ter-
              minated by a newline, and blanks between the ``:'' and the
              start of the label are ignored.  This command may also be used
              to insert comments into a command file, since labels need not
              be referenced.

    ( . , . )xb/regular expression/label
              A jump (either upward or downward) is made to label if the com-
              mand succeeds.  It fails under any of the following conditions:

              1. Either address is not between 1 and ``$''.

              2. The second address is less than the first.

              3. The regular expression does not match at least one line in
                 the specified range, including the first and last lines.

              On success, dot (.) is set to the line matched and a jump is
              made to label. This command is the only one that does not issue
              an error message on bad addresses, so it may be used to test
              whether addresses are bad before other commands are executed.
              Note that the command

                 xb/^/ label

              is an unconditional jump.

              The xb command is allowed only if it is read from somewhere
              other than a terminal.  If it is read from a pipe only a down-
              ward jump is possible.

    xt number Output from the p and null commands is truncated to a maximum
              of number characters.  The initial number is 255.

    xv[ digit ] [ spaces ] [ value ]
              The variable name is the specified digit following the xv.
              xv5100 or xv5 100 both assign the value 100 to the variable 5.
              xv61,100p assigns the value 1,100p to the variable 6.  To
              reference a variable, put a ``%'' in front of the variable
              name.  For example, using the above assignments for variables 5
              and 6:

                 1,%5p
                 1,%5
                 %6

              prints the first 100 lines.

                 g/%5/p

              globally searches for the characters ``100'' and prints each
              line containing a match.  To escape the special meaning of
              ``%'', a ``&'' must precede it.  For example,

                 g/".*[cds]/p

              could be used to match and list lines containing printf charac-
              ters, decimal integers, or strings.

              Another feature of the xv command is that the first line of
              output from a UNIX command can be stored into a variable.  The
              only requirement is that the first character of value be a
              ``!''.  For example,

                 xv5!cat junk
                 !rm junk
                 !echo "%5"
                 xv6!expr %6 + 1

              puts the current line in variable 5, prints it, and increments
              the variable 6 by 1.  To escape the special meaning of ``!'' as
              the first character of value, precede it with a ``\''.  For
              example,

                 xv7date

              stores the value !date into variable 7.

    xbz label
    xbn label   These two commands test the last saved return code from the
                execution of a UNIX command !command) or nonzero value,
                respectively, and jump to the specified label.  The two exam-
                ples below search for the next five lines containing the
                string size:

                   xv55
                   : l
                   /size/
                   xv5!expr %5 - 1
                   !if 0%5 != 0 exit 2
                   xbn l
                   xv45
                   : l
                   /size/
                   xv4!expr %4 - 1
                   !if 0%4 = 0 exit 2
                   xbz l


    xc [ switch ]
                If switch is 1, output from the p and null commands is
                crunched; if switch is 0, it is not.  Without an argument, xc
                reverses switch.  Initially switch is set for no crunching.
                Crunched output has strings of tabs and blanks reduced to one
                blank and blank lines suppressed.

 See also

    csplit(C), ed(C), umask(C).

 Diagnostics

    ``?'' for errors in commands if prompting is turned off.  Self-
    explanatory error messages when prompting is on.


Typewritten Software • bear@typewritten.org • Edmonds, WA 98026