[adding help-texinfo, for a rendering question]
On Tue, Jun 07, 2022 at 02:00:17PM -0500, Bern wrote:
> in the very beginning of the 'info m4' is the example of a macro definition.
>
> Within that text is the alert there be no space between the macro name and
> the opening L-paren.
>
> Yet the example itself does have such an errant space.
>
> see attached screenshot
Pasting the text of that screenshot inline (well, grabbing the text
contents of my 'info m4' terminal, which covers the same as your
screenshot)...
> As each of the predefined macros in ‘m4’ is described, a prototype
> call of the macro will be shown, giving descriptive names to the
> arguments, e.g.,
>
> -- Composite: example (STRING, [COUNT = ‘1’], [ARGUMENT]...)
> This is a sample prototype. There is not really a macro named
> ‘example’, but this documents that if there were, it would be a
> Composite macro, rather than a Builtin. It requires at least one
> argument, STRING. Remember that in ‘m4’, there must not be a space
> between the macro name and the opening parenthesis, unless it was
> intended to call the macro without any arguments. The brackets
Thanks for the report. The m4 documentation is written in texinfo, and
the texinfo manual documents the @deffn directive as:
@deffn CATEGORY NAME ARGUMENTS...
where the source in doc/m4.texi uses:
@deffn Composite example(@var{string}, @dvar{count, 1}, @
@ovar{argument}@dots{})
And it looks like back in 2006 (commit dddcc3d9), when I updated the
manual to use @deffn instead of @example for prototypes (for better
typesetting and indexing purposes), I intentionally separated NAME
from ARGUMENTS, assuming that texinfo was insistent on the separation.
On a whim, just now I tried removing the space between NAME and
ARGUMENTS in the .texi file, to see if the resulting info file still
makes sense. In 'info', it does. But in html, it is worse;
previously, things would render something like:
Builtin: <b>define</b> <i>(name, [expansion])</i>
now it renders something like:
Builtin: <b>define<i>(name,</i></b> <i>[expansion])</i>
which is unacceptable (why is the name argument bolded, when the
expansion argument is not).
Maybe a texinfo expert would be able to help me come up with something
that does what we want, of producing typesetting that bolds the macro
name, but omits the space between the macro and the '(' of the
arguments, while still getting all of the other benefits of @deffn?
Here's the mechanical patch I was testing with:
$ sed -i '/\(^@deffn[^(]*\) (/ s//\1(/' doc/m4.texi
diff --git i/doc/m4.texi w/doc/m4.texi
index 5591493c..bfcb28fc 100644
--- i/doc/m4.texi
+++ w/doc/m4.texi
@@ -504,7 +504,7 @@ Manual
call of the macro will be shown, giving descriptive names to the
arguments, e.g.,
-@deffn Composite example (@var{string}, @dvar{count, 1}, @
+@deffn Composite example(@var{string}, @dvar{count, 1}, @
@ovar{argument}@dots{})
This is a sample prototype. There is not really a macro named
@code{example}, but this documents that if there were, it would be a
@@ -1800,7 +1800,7 @@ Define
The normal way to define or redefine macros is to use the builtin
@code{define}:
-@deffn Builtin define (@var{name}, @ovar{expansion})
+@deffn Builtin define(@var{name}, @ovar{expansion})
Defines @var{name} to expand to @var{expansion}. If
@var{expansion} is not given, it is taken to be empty.
@@ -1855,8 +1855,8 @@ Define
Arrays and associative arrays can be simulated by using non-standard
macro names.
-@deffn Composite array (@var{index})
-@deffnx Composite array_set (@var{index}, @ovar{value})
+@deffn Composite array(@var{index})
+@deffnx Composite array_set(@var{index}, @ovar{value})
Provide access to entries within an array. @code{array} reads the entry
at location @var{index}, and @code{array_set} assigns @var{value} to
location @var{index}.
@@ -1891,7 +1891,7 @@ Arguments
appear in the expansion. Here is an example of a macro with
two arguments.
-@deffn Composite exch (@var{arg1}, @var{arg2})
+@deffn Composite exch(@var{arg1}, @var{arg2})
Expands to @var{arg2} followed by @var{arg1}, effectively exchanging
their order.
@end deffn
@@ -2011,7 +2011,7 @@ Pseudo Arguments
The number of actual arguments in a macro call is denoted by @code{$#}
in the expansion text.
-@deffn Composite nargs (@dots{})
+@deffn Composite nargs(@dots{})
Expands to a count of the number of arguments supplied.
@end deffn
@@ -2190,7 +2190,7 @@ Undefine
@cindex undefining macros
A macro definition can be removed with @code{undefine}:
-@deffn Builtin undefine (@var{name}@dots{})
+@deffn Builtin undefine(@var{name}@dots{})
For each argument, remove the macro @var{name}. The macro names must
necessarily be quoted, since they will be expanded otherwise.
@@ -2240,7 +2240,7 @@ Defn
It is possible to rename an already defined macro. To do this, you need
the builtin @code{defn}:
-@deffn Builtin defn (@var{name}@dots{})
+@deffn Builtin defn(@var{name}@dots{})
Expands to the @emph{quoted definition} of each @var{name}. If an
argument is not a defined macro, the expansion for that argument is
empty.
@@ -2402,8 +2402,8 @@ Pushdef
previous definition at a later time. This is done with the builtins
@code{pushdef} and @code{popdef}:
-@deffn Builtin pushdef (@var{name}, @ovar{expansion})
-@deffnx Builtin popdef (@var{name}@dots{})
+@deffn Builtin pushdef(@var{name}, @ovar{expansion})
+@deffnx Builtin popdef(@var{name}@dots{})
Analogous to @code{define} and @code{undefine}.
These macros work in a stack-like fashion. A macro is temporarily
@@ -2496,7 +2496,7 @@ Indir
@cindex GNU extensions
Any macro can be called indirectly with @code{indir}:
-@deffn Builtin indir (@var{name}, @ovar{args@dots{}})
+@deffn Builtin indir(@var{name}, @ovar{args@dots{}})
Results in a call to the macro @var{name}, which is passed the
rest of the arguments @var{args}. If @var{name} is not defined, an
error message is printed, and the expansion is void.
@@ -2571,7 +2571,7 @@ Builtin
@cindex GNU extensions
Builtin macros can be called indirectly with @code{builtin}:
-@deffn Builtin builtin (@var{name}, @ovar{args@dots{}})
+@deffn Builtin builtin(@var{name}, @ovar{args@dots{}})
Results in a call to the builtin @var{name}, which is passed the
rest of the arguments @var{args}. If @var{name} does not name a
builtin, an error message is printed, and the expansion is void.
@@ -2710,7 +2710,7 @@ Ifdef
There are two different builtin conditionals in @code{m4}. The first is
@code{ifdef}:
-@deffn Builtin ifdef (@var{name}, @var{string-1}, @ovar{string-2})
+@deffn Builtin ifdef(@var{name}, @var{string-1}, @ovar{string-2})
If @var{name} is defined as a macro, @code{ifdef} expands to
@var{string-1}, otherwise to @var{string-2}. If @var{string-2} is
omitted, it is taken to be the empty string (according to the normal
@@ -2741,10 +2741,10 @@ Ifelse
used as a way to introduce a long comment, as an if-else construct, or
as a multibranch, depending on the number of arguments supplied:
-@deffn Builtin ifelse (@var{comment})
-@deffnx Builtin ifelse (@var{string-1}, @var{string-2}, @var{equal}, @
+@deffn Builtin ifelse(@var{comment})
+@deffnx Builtin ifelse(@var{string-1}, @var{string-2}, @var{equal}, @
@ovar{not-equal})
-@deffnx Builtin ifelse (@var{string-1}, @var{string-2}, @var{equal-1}, @
+@deffnx Builtin ifelse(@var{string-1}, @var{string-2}, @var{equal-1}, @
@var{string-3}, @var{string-4}, @var{equal-2}, @dots{}, @ovar{not-equal})
Used with only one argument, the @code{ifelse} simply discards it and
produces no output.
@@ -2913,7 +2913,7 @@ Shift
There is a builtin macro, @code{shift}, which can, among other things,
be used for iterating through the actual arguments to a macro:
-@deffn Builtin shift (@var{arg1}, @dots{})
+@deffn Builtin shift(@var{arg1}, @dots{})
Takes any number of arguments, and expands to all its arguments except
@var{arg1}, separated by commas, with each argument quoted.
@@ -2933,7 +2933,7 @@ Shift
@cindex reversing arguments
@cindex arguments, reversing
-@deffn Composite reverse (@dots{})
+@deffn Composite reverse(@dots{})
Takes any number of arguments, and reverses their order.
@end deffn
@@ -2958,7 +2958,7 @@ Shift
@cindex short-circuiting conditional
@cindex conditional, short-circuiting
-@deffn Composite cond (@var{test-1}, @var{string-1}, @var{equal-1}, @
+@deffn Composite cond(@var{test-1}, @var{string-1}, @var{equal-1}, @
@ovar{test-2}, @ovar{string-2}, @ovar{equal-2}, @dots{}, @ovar{not-equal})
Similar to @code{ifelse}, where an equal comparison between the first
two strings results in the third, otherwise the first three arguments
@@ -3016,8 +3016,8 @@ Shift
Another common task that requires iteration is joining a list of
arguments into a single string.
-@deffn Composite join (@ovar{separator}, @ovar{args@dots{}})
-@deffnx Composite joinall (@ovar{separator}, @ovar{args@dots{}})
+@deffn Composite join(@ovar{separator}, @ovar{args@dots{}})
+@deffnx Composite joinall(@ovar{separator}, @ovar{args@dots{}})
Generate a single-quoted string, consisting of each @var{arg} separated
by @var{separator}. While @code{joinall} always outputs a
@var{separator} between arguments, @code{join} avoids the
@@ -3120,9 +3120,9 @@ Shift
Sometimes, a recursive algorithm requires adding quotes to each element,
or treating multiple arguments as a single element:
-@deffn Composite quote (@dots{})
-@deffnx Composite dquote (@dots{})
-@deffnx Composite dquote_elt (@dots{})
+@deffn Composite quote(@dots{})
+@deffnx Composite dquote(@dots{})
+@deffnx Composite dquote_elt(@dots{})
Takes any number of arguments, and adds quoting. With @code{quote},
only one level of quoting is added, effectively removing whitespace
after commas and turning multiple arguments into a single string. With
@@ -3194,7 +3194,7 @@ Shift
relying on the GNU extension of multi-digit arguments
(@pxref{Arguments}).
-@deffn Composite argn (@var{n}, @dots{})
+@deffn Composite argn(@var{n}, @dots{})
Expands to argument @var{n} out of the remaining arguments. @var{n}
must be a positive number. Usually invoked as
@samp{argn(`@var{n}',$@@)}.
@@ -3222,7 +3222,7 @@ Forloop
@cindex counting loops
Here is an example of a loop macro that implements a simple for loop.
-@deffn Composite forloop (@var{iterator}, @var{start}, @var{end}, @var{text})
+@deffn Composite forloop(@var{iterator}, @var{start}, @var{end}, @var{text})
Takes the name in @var{iterator}, which must be a valid macro name, and
successively assign it each integer value from @var{start} to @var{end},
inclusive. For each assignment to @var{iterator}, append @var{text} to
@@ -3301,8 +3301,8 @@ Foreach
@cindex iterating over lists
Here is an example of a loop macro that implements list iteration.
-@deffn Composite foreach (@var{iterator}, @var{paren-list}, @var{text})
-@deffnx Composite foreachq (@var{iterator}, @var{quote-list}, @var{text})
+@deffn Composite foreach(@var{iterator}, @var{paren-list}, @var{text})
+@deffnx Composite foreachq(@var{iterator}, @var{quote-list}, @var{text})
Takes the name in @var{iterator}, which must be a valid macro name, and
successively assign it each value from @var{paren-list} or
@var{quote-list}. In @code{foreach}, @var{paren-list} is a
@@ -3478,8 +3478,8 @@ Stacks
stack is important, but sometimes, it is desirable to manipulate the
entire definition stack.
-@deffn Composite stack_foreach (@var{macro}, @var{action})
-@deffnx Composite stack_foreach_lifo (@var{macro}, @var{action})
+@deffn Composite stack_foreach(@var{macro}, @var{action})
+@deffnx Composite stack_foreach_lifo(@var{macro}, @var{action})
For each of the @code{pushdef} definitions associated with @var{macro},
invoke the macro @var{action} with a single argument of that definition.
@code{stack_foreach} visits the oldest definition first, while
@@ -3561,7 +3561,7 @@ Composition
@cindex macro, blind
@cindex blind macro
-@deffn Composite define_blind (@var{name}, @ovar{value})
+@deffn Composite define_blind(@var{name}, @ovar{value})
Defines @var{name} as a blind macro, such that @var{name} will expand to
@var{value} only when given explicit arguments. @var{value} should not
be the result of @code{defn} (@pxref{Defn}). This macro is only
@@ -3624,7 +3624,7 @@ Composition
factoring a macro that takes multiple arguments for use in a context
that provides exactly one argument.
-@deffn Composite curry (@var{macro}, @dots{})
+@deffn Composite curry(@var{macro}, @dots{})
Expand to a macro call that takes exactly one argument, then appends
that argument to the original arguments and invokes @var{macro} with the
resulting list of arguments.
@@ -3687,8 +3687,8 @@ Composition
Putting the last few concepts together, it is possible to copy or rename
an entire stack of macro definitions.
-@deffn Composite copy (@var{source}, @var{dest})
-@deffnx Composite rename (@var{source}, @var{dest})
+@deffn Composite copy(@var{source}, @var{dest})
+@deffnx Composite rename(@var{source}, @var{dest})
Ensure that @var{dest} is undefined, then define it to the same stack of
definitions currently in @var{source}. @code{copy} leaves @var{source}
unchanged, while @code{rename} undefines @var{source}. There are only a
@@ -3751,7 +3751,7 @@ Dumpdef
If you want to see what a name expands into, you can use the builtin
@code{dumpdef}:
-@deffn Builtin dumpdef (@ovar{names@dots{}})
+@deffn Builtin dumpdef(@ovar{names@dots{}})
Accepts any number of arguments. If called without any arguments,
it displays the definitions of all known names, otherwise it displays
the definitions of the @var{names} given. The output is printed to the
@@ -3803,8 +3803,8 @@ Trace
It is possible to trace macro calls and expansions through the builtins
@code{traceon} and @code{traceoff}:
-@deffn Builtin traceon (@ovar{names@dots{}})
-@deffnx Builtin traceoff (@ovar{names@dots{}})
+@deffn Builtin traceon(@ovar{names@dots{}})
+@deffnx Builtin traceoff(@ovar{names@dots{}})
When called without any arguments, @code{traceon} and @code{traceoff}
will turn tracing on and off, respectively, for all currently defined
macros.
@@ -4030,7 +4030,7 @@ Debug Levels
There is a builtin macro @code{debugmode}, which allows on-the-fly control of
the debugging output format:
-@deffn Builtin debugmode (@ovar{flags})
+@deffn Builtin debugmode(@ovar{flags})
The argument @var{flags} should be a subset of the letters listed above.
As special cases, if the argument starts with a @samp{+}, the flags are
added to the current debug flags, and if it starts with a @samp{-}, they
@@ -4113,7 +4113,7 @@ Debug Output
@option{--debugfile} option to @code{m4} (@pxref{Debugging options, ,
Invoking m4}), or with the builtin macro @code{debugfile}:
-@deffn Builtin debugfile (@ovar{file})
+@deffn Builtin debugfile(@ovar{file})
Sends all further debug and trace output to @var{file}, opened in append
mode. If @var{file} is the empty string, debug and trace output are
discarded. If @code{debugfile} is called without any arguments, debug
@@ -4227,7 +4227,7 @@ Changequote
The default quote delimiters can be changed with the builtin
@code{changequote}:
-@deffn Builtin changequote (@dvar{start, `}, @dvar{end, '})
+@deffn Builtin changequote(@dvar{start, `}, @dvar{end, '})
This sets @var{start} as the new begin-quote delimiter and @var{end} as
the new end-quote delimiter. If both arguments are missing, the default
quotes (@code{`} and @code{'}) are used. If @var{start} is void, then
@@ -4472,7 +4472,7 @@ Changecom
The default comment delimiters can be changed with the builtin
macro @code{changecom}:
-@deffn Builtin changecom (@ovar{start}, @dvar{end, @key{NL}})
+@deffn Builtin changecom(@ovar{start}, @dvar{end, @key{NL}})
This sets @var{start} as the new begin-comment delimiter and @var{end}
as the new end-comment delimiter. If both arguments are missing, or
@var{start} is void, then comments are disabled. Otherwise, if
@@ -4640,7 +4640,7 @@ Changeword
Using @code{changeword}, you can change this regular expression:
-@deffn {Optional builtin} changeword (@var{regex})
+@deffn {Optional builtin} changeword(@var{regex})
Changes the regular expression for recognizing macro names to be
@var{regex}. If @var{regex} is empty, use
@samp{[_a-zA-Z][_a-zA-Z0-9]*}. @var{regex} must obey the constraint
@@ -4849,7 +4849,7 @@ M4wrap
To save input text, use the builtin @code{m4wrap}:
-@deffn Builtin m4wrap (@var{string}, @dots{})
+@deffn Builtin m4wrap(@var{string}, @dots{})
Stores @var{string} in a safe place, to be reread when end of input is
reached. As a GNU extension, additional arguments are
concatenated with a space to the @var{string}.
@@ -4998,8 +4998,8 @@ Include
There are two builtin macros in @code{m4} for including files:
-@deffn Builtin include (@var{file})
-@deffnx Builtin sinclude (@var{file})
+@deffn Builtin include(@var{file})
+@deffnx Builtin sinclude(@var{file})
Both macros cause the file named @var{file} to be read by
@code{m4}. When the end of the file is reached, input is resumed from
the previous input file.
@@ -5295,7 +5295,7 @@ Divert
@cindex files, diverting output to
Output is diverted using @code{divert}:
-@deffn Builtin divert (@dvar{number, 0})
+@deffn Builtin divert(@dvar{number, 0})
The current diversion is changed to @var{number}. If @var{number} is left
out or empty, it is assumed to be zero. If @var{number} cannot be
parsed, the diversion is unchanged.
@@ -5389,7 +5389,7 @@ Undivert
Diverted text can be undiverted explicitly using the builtin
@code{undivert}:
-@deffn Builtin undivert (@ovar{diversions@dots{}})
+@deffn Builtin undivert(@ovar{diversions@dots{}})
Undiverts the numeric @var{diversions} given by the arguments, in the
order given. If no arguments are supplied, all diversions are
undiverted, in numerical order.
@@ -5577,7 +5577,7 @@ Cleardivert
Clearing selected diversions can be done with the following macro:
-@deffn Composite cleardivert (@ovar{diversions@dots{}})
+@deffn Composite cleardivert(@ovar{diversions@dots{}})
Discard the contents of each of the listed numeric @var{diversions}.
@end deffn
@@ -5615,7 +5615,7 @@ Len
@cindex strings, length of
The length of a string can be calculated by @code{len}:
-@deffn Builtin len (@var{string})
+@deffn Builtin len(@var{string})
Expands to the length of @var{string}, as a decimal number.
The macro @code{len} is recognized only with parameters.
@@ -5634,7 +5634,7 @@ Index macro
@cindex substrings, locating
Searching for substrings is done with @code{index}:
-@deffn Builtin index (@var{string}, @var{substring})
+@deffn Builtin index(@var{string}, @var{substring})
Expands to the index of the first occurrence of @var{substring} in
@var{string}. The first character in @var{string} has index 0. If
@var{substring} does not occur in @var{string}, @code{index} expands to
@@ -5692,7 +5692,7 @@ Regexp
Searching for regular expressions is done with the builtin
@code{regexp}:
-@deffn Builtin regexp (@var{string}, @var{regexp}, @ovar{replacement})
+@deffn Builtin regexp(@var{string}, @var{regexp}, @ovar{replacement})
Searches for @var{regexp} in @var{string}. The syntax for regular
expressions is the same as in GNU Emacs, which is similar to
BRE, Basic Regular Expressions in POSIX.
@@ -5772,7 +5772,7 @@ Substr
@cindex substrings, extracting
Substrings are extracted with @code{substr}:
-@deffn Builtin substr (@var{string}, @var{from}, @ovar{length})
+@deffn Builtin substr(@var{string}, @var{from}, @ovar{length})
Expands to the substring of @var{string}, which starts at index
@var{from}, and extends for @var{length} characters, or to the end of
@var{string}, if @var{length} is omitted. The starting index of a string
@@ -5808,7 +5808,7 @@ Translit
@cindex characters, translating
Character translation is done with @code{translit}:
-@deffn Builtin translit (@var{string}, @var{chars}, @ovar{replacement})
+@deffn Builtin translit(@var{string}, @var{chars}, @ovar{replacement})
Expands to @var{string}, with each character that occurs in
@var{chars} translated into the character from @var{replacement} with
the same index.
@@ -5917,7 +5917,7 @@ Patsubst
@cindex GNU extensions
Global substitution in a string is done by @code{patsubst}:
-@deffn Builtin patsubst (@var{string}, @var{regexp}, @ovar{replacement})
+@deffn Builtin patsubst(@var{string}, @var{regexp}, @ovar{replacement})
Searches @var{string} for matches of @var{regexp}, and substitutes
@var{replacement} for each match. The syntax for regular expressions
is the same as in GNU Emacs (@pxref{Regexp}).
@@ -5964,9 +5964,9 @@ Patsubst
words or whole sentences, by substituting calls of the macros
@code{upcase} and @code{downcase} into the strings.
-@deffn Composite upcase (@var{text})
-@deffnx Composite downcase (@var{text})
-@deffnx Composite capitalize (@var{text})
+@deffn Composite upcase(@var{text})
+@deffnx Composite downcase(@var{text})
+@deffnx Composite capitalize(@var{text})
Expand to @var{text}, but with capitalization changed: @code{upcase}
changes all letters to upper case, @code{downcase} changes all letters
to lower case, and @code{capitalize} changes the first character of each
@@ -6051,7 +6051,7 @@ Format
@cindex GNU extensions
Formatted output can be made with @code{format}:
-@deffn Builtin format (@var{format-string}, @dots{})
+@deffn Builtin format(@var{format-string}, @dots{})
Works much like the C function @code{printf}. The first argument
@var{format-string} can contain @samp{%} specifications which are
satisfied by additional arguments, and the expansion of @code{format} is
@@ -6172,8 +6172,8 @@ Incr
Increment and decrement of integers are supported using the builtins
@code{incr} and @code{decr}:
-@deffn Builtin incr (@var{number})
-@deffnx Builtin decr (@var{number})
+@deffn Builtin incr(@var{number})
+@deffnx Builtin decr(@var{number})
Expand to the numerical value of @var{number}, incremented
or decremented, respectively, by one. Except for the empty string, the
expansion is empty if @var{number} could not be parsed.
@@ -6203,7 +6203,7 @@ Eval
@cindex expressions, evaluation of integer
Integer expressions are evaluated with @code{eval}:
-@deffn Builtin eval (@var{expression}, @dvar{radix, 10}, @ovar{width})
+@deffn Builtin eval(@var{expression}, @dvar{radix, 10}, @ovar{width})
Expands to the value of @var{expression}. The expansion is empty
if a problem is encountered while parsing the arguments. If specified,
@var{radix} and @var{width} control the format of the output.
@@ -6566,7 +6566,7 @@ Syscmd
Any shell command can be executed, using @code{syscmd}:
-@deffn Builtin syscmd (@var{shell-command})
+@deffn Builtin syscmd(@var{shell-command})
Executes @var{shell-command} as a shell command.
The expansion of @code{syscmd} is void, @emph{not} the output from
@@ -6645,7 +6645,7 @@ Esyscmd
If you want @code{m4} to read the output of a shell command, use
@code{esyscmd}:
-@deffn Builtin esyscmd (@var{shell-command})
+@deffn Builtin esyscmd(@var{shell-command})
Expands to the standard output of the shell command
@var{shell-command}.
@@ -6785,8 +6785,8 @@ Mkstemp
temporary file, for output or for some other purpose. There is a
builtin macro, @code{mkstemp}, for making a temporary file:
-@deffn Builtin mkstemp (@var{template})
-@deffnx Builtin maketemp (@var{template})
+@deffn Builtin mkstemp(@var{template})
+@deffnx Builtin maketemp(@var{template})
Expands to the quoted name of a new, empty file, made from the string
@var{template}, which should end with the string @samp{XXXXXX}. The six
@samp{X} characters are then replaced with random characters matching
@@ -6933,7 +6933,7 @@ Errprint
@cindex standard error, output to
You can print error messages using @code{errprint}:
-@deffn Builtin errprint (@var{message}, @dots{})
+@deffn Builtin errprint(@var{message}, @dots{})
Prints @var{message} and the rest of the arguments to standard error,
separated by spaces. Standard error is used, regardless of the
@option{--debugfile} option (@pxref{Debugging options, , Invoking m4}).
@@ -7070,7 +7070,7 @@ M4exit
If you need to exit from @code{m4} before the entire input has been
read, you can use @code{m4exit}:
-@deffn Builtin m4exit (@dvar{code, 0})
+@deffn Builtin m4exit(@dvar{code, 0})
Causes @code{m4} to exit, with exit status @var{code}. If @var{code} is
left out, the exit status is zero. If @var{code} cannot be parsed, or
is outside the range of 0 to 255, the exit status is one. No further
@@ -7088,7 +7088,7 @@ M4exit
A common use of this is to abort processing:
-@deffn Composite fatal_error (@var{message})
+@deffn Composite fatal_error(@var{message})
Abort processing with an error message and non-zero status. Prefix
@var{message} with details about where the error occurred, and print the
resulting string to standard error.
@@ -8335,9 +8335,9 @@ Improved copy
two-argument @code{pushdef} call sequence needed, so that we are no
longer passing a builtin token through a text macro.
-@deffn Composite stack_foreach_sep (@var{macro}, @var{pre}, @var{post}, @
+@deffn Composite stack_foreach_sep(@var{macro}, @var{pre}, @var{post}, @
@var{sep})
-@deffnx Composite stack_foreach_sep_lifo (@var{macro}, @var{pre}, @
+@deffnx Composite stack_foreach_sep_lifo(@var{macro}, @var{pre}, @
@var{post}, @var{sep})
For each of the @code{pushdef} definitions associated with @var{macro},
expand the sequence @samp{@var{pre}`'definition`'@var{post}}.
--
Eric Blake, Principal Software Engineer
Red Hat, Inc. +1-919-301-3266
Virtualization: qemu.org | libvirt.org
