Re: simple doc point

[Eric Blake]

[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