File: groff.info,  Node: Using Escape Sequences,  Next: Delimiters,  Prev: Calling Macros,  Up: Formatter Instructions

5.6.4 Using Escape Sequences
----------------------------

Whereas requests must occur on control lines, escape sequences can occur
intermixed with text and may appear in arguments to requests, macros,
and other escape sequences.  An escape sequence is introduced by the
escape character, a backslash '\' (but see the 'ec' request below).  The
next character selects the escape's function.

   Escape sequences vary in length.  Some take an argument, and of
those, some have different syntactical forms for a one-character,
two-character, or arbitrary-length argument.  Others accept _only_ an
arbitrary-length argument.  In the former scheme, a one-character
argument follows the function character immediately, an opening
parenthesis '(' introduces a two-character argument (no closing
parenthesis is used), and an argument of arbitrary length is enclosed in
brackets '[]'.  In the latter scheme, the user selects a delimiter
character.  A few escape sequences are idiosyncratic, and support both
of the foregoing conventions ('\s'), designate their own termination
sequence ('\?'), consume input until the next newline ('\!', '\"',
'\#'), or support an additional modifier character ('\s' again, and
'\n').  As with requests, use of some escape sequences in source
documents may interact poorly with a macro package you use; consult its
documentation to learn of "safe" sequences or alternative facilities it
provides to achieve the desired result.

   If an escape character is followed by a character that does not
identify a defined operation, the escape character is ignored (producing
a diagnostic of the 'escape' warning category, which is not enabled by
default) and the following character is processed normally.

     $ groff -Tps -ww
     .nr N 12
     .ds co white
     .ds animal elephant
     I have \fI\nN \*(co \*[animal]s,\f[]
     said \P.\&\~Pseudo Pachyderm.
         error-> warning: escape character ignored before 'P'
         => I have 12 white elephants, said P. Pseudo Pachyderm.

   Escape sequence interpolation is of higher precedence than escape
sequence argument interpretation.  This rule affords flexibility in
using escape sequences to construct parameters to other escape
sequences.

     .ds family C\" Courier
     .ds style I\" oblique
     Choice a typeface \f(\*[family]\*[style]wisely.
         => Choose a typeface wisely.

In the above, the syntax form '\f(' accepts only two characters for an
argument; the example works because the subsequent escape sequences are
interpolated before the selection escape sequence argument is processed,
and strings 'family' and 'style' interpolate one character each.(1)
(*note Using Escape Sequences-Footnote-1::)

   The escape character is nearly always interpreted when encountered;
it is therefore desirable to have a way to interpolate it, disable it,
or change it.

 -- Escape sequence: \e
     Interpolate the escape character.

   The '\[rs]' special character escape sequence formats a backslash
glyph.  In macro and string definitions, the input sequences '\\' and
'\E' defer interpretation of escape sequences.  *Note Copy Mode::.

 -- Request: .eo
     Disable the escape mechanism except in copy mode.  Once this
     request is invoked, no input character is recognized as starting an
     escape sequence in interpretation mode.

 -- Request: .ec [o]
     Recognize the ordinary character O as the escape character.  If O
     is absent or invalid, the default escape character '\' is selected.

   Switching escape sequence interpretation off to define a macro and
back on afterward can obviate the need to double the escape character
within the definition.  *Note Writing Macros::.  This technique is not
available if your macro needs to interpolate values at the time it is
_defined_--but many do not.

     .\" simplified `BR` macro from the man(7) macro package
     .eo
     .de BR
     .  ds result \&
     .  while (\n[.$] >= 2) \{\
     .    as result \fB\$1\fR\$2\"
     .    shift 2
     .  \}
     .  if \n[.$] .as result \fB\$1\"
     \*[result]
     .  rm result
     .  ft R
     ..
     .ec

 -- Request: .ecs
 -- Request: .ecr
     The 'ecs' request stores the escape character for recall with
     'ecr'.  'ecr' sets the escape character to '\' if none has been
     saved.

     Use these requests together to temporarily change the escape
     character.

   Using a different escape character, or disabling it, when calling
macros not under your control will likely cause errors, since GNU
'troff' has no mechanism to "intern" macros--that is, to convert a macro
definition into a form independent of its representation.(2)  (*note
Using Escape Sequences-Footnote-2::) When a macro is called, its
contents are interpreted literally.