% Please include a precise test case in each bug report,
% including a complete document with which we can reproduce the problem.
%
-% Texinfo macros (with @macro) are *not* supported by texinfo.tex. You
-% have to run makeinfo -E to expand macros first; the texi2dvi script
-% does this.
-%
% To process a Texinfo manual with TeX, it's most reliable to use the
% texi2dvi shell script that comes with the distribution. For simple
% manuals, you can get away with:
\def\menu{\doignore{menu}}
\def\direntry{\doignore{direntry}}
-% Also ignore @macro ... @end macro. The user must run texi2dvi,
-% which runs makeinfo to do macro expansion. Ignore @unmacro, too.
-\def\macro{\doignore{macro}}
-\def\macrocsname{macro}
-\let\unmacro = \comment
-
-
% @dircategory CATEGORY -- specify a category of the dir file
% which this file should belong to. Ignore this in TeX.
\let\dircategory = \comment
% @c @end ifinfo
% and the @end ifinfo will be properly ignored.
% (We've just changed @ to catcode 12.)
- %
- % But we can't do this if #1 is `macro', since that actually contains a c.
- % Happily, none of the other conditionals have the letter `c' in their names!
- \def\temp{#1}%
- \ifx\temp\macrocsname \else
- \catcode`\c = 14
- \fi
+ \catcode`\c = 14
%
% And now expand that command.
\doignoretext
% @bye.
\outer\def\bye{\pagealignmacro\tracingstats=1\ptexend}
-% \def\macro#1{\begingroup\ignoresections\catcode`\#=6\def\macrotemp{#1}\parsearg\macroxxx}
-% \def\macroxxx#1#2 \end macro{%
-% \expandafter\gdef\macrotemp#1{#2}%
-% \endgroup}
-
-%\def\linemacro#1{\begingroup\ignoresections\catcode`\#=6\def\macrotemp{#1}\parsearg\linemacroxxx}
-%\def\linemacroxxx#1#2 \end linemacro{%
-%\let\parsearg=\relax
-%\edef\macrotempx{\csname M\butfirst\expandafter\string\macrotemp\endcsname}%
-%\expandafter\xdef\macrotemp{\parsearg\macrotempx}%
-%\expandafter\gdef\macrotempx#1{#2}%
-%\endgroup}
-
-%\def\butfirst#1{}
-
-
\message{fonts,}
% Font-change commands.
\message{macros,}
% @macro.
-% The basic scheme is as follows:
-% We read the first line and split it up into macro name and parameter
-% list. We then walk the parameter list defining control sequences
-% named \MAC@<macro name><parameter name>. Each expands to another
-% control sequence named \MAC@<macro name>.<parameter number>. Those
-% control sequences will be defined at macro runtime to be the
-% parameter expansion text.
-%
-% The body is then read in as a single argument in a context where \
-% is an active character, and the cs \MACb.<macro name> is defined as
-% the macro body. The active character \ takes one argument delimited
-% by another \, and uses it to index the table of macro arguments
-% described above.
-%
-% Finally, we define a control sequence \<macro name> which calls one
-% of the six (!) macro execution commands. These six commands
-% correspond to recursive and nonrecursive macros with no, one, and
-% many arguments. They all take one argument, <macro name>, set up
-% the environment appropriately, and call the real macro.
-%
-% \macsave@<macro name> holds the old definition of \<macro name>.
-\newcount\paramno
-\newtoks\macname
+% To do this right we need a feature of e-TeX, \scantokens,
+% which we arrange to emulate with a temporary file in ordinary TeX.
+\ifx\eTeXversion\undefined
+ \newwrite\macscribble
+ \def\scantokens#1{%
+% \toks0={#1}%
+ \immediate\openout\macscribble=\jobname.tmp
+ \immediate\write\macscribble{#1}%\the\toks0}%
+ \immediate\closeout\macscribble
+ \input \jobname.tmp
+}
+\fi
+
+\newcount\paramno % Count of parameters
+\newtoks\macname % Macro name
+\newif\ifrecursive % Is it recursive?
-% This does \let #1 = #2, except with \csnames.
+% Utility: does \let #1 = #2, except with \csnames.
\def\cslet#1#2{%
-\expandafter\expandafter\expandafter
-\let
+\expandafter\expandafter
+\expandafter\let
\expandafter\expandafter
\csname#1\endcsname
\csname#2\endcsname}
-% We have to play lots of games with the catcodes. Initially { and }
-% are made `other' so that \splitarg (below) can use them as argument
-% delimiters. Then - is made a letter so that \iimacro can recognize
-% @allow-recursion.
-\def\macro{\bgroup\catcode`\{=\other\catcode`\}=\other\parsearg\imacro}
-\def\imacro#1{\egroup % started in \macro
- \splitarg{#1}% now \macname is the macname and \toks0 the arglist
- \paramno=0%
- \edef\tmp{\the\toks0}%
- \ifx\tmp\empty % no arguments
+% Macro bodies are absorbed as an argument in a context where
+% all characters are catcode 10, 11 or 12, except \ which is active
+% (as in normal texinfo). It is necessary to change the definition of \.
+
+\def\macrobodyctxt{%
+ \catcode`\~=12
+ \catcode`\^=12
+ \catcode`\_=12
+ \catcode`\|=12
+ \catcode`\<=12
+ \catcode`\>=12
+ \catcode`\+=12
+ \catcode`\{=12
+ \catcode`\}=12
+ \catcode`\@=12
+ \catcode`\^^M=10
+ \usembodybackslash}
+
+% \mbodybackslash is the definition of \ in @macro bodies.
+% It maps \foo\ => \csname macarg.foo\endcsname => #N
+% where N is the macro parameter number.
+% We define \csname macarg.\endcsname to be \realbackslash, so
+% \\ in macro replacement text gets you a backslash.
+
+{\catcode`@=0 \catcode`\\=\active
+ @gdef@usembodybackslash{@let\=@mbodybackslash}
+ @gdef@mbodybackslash#1\{@csname macarg.#1@endcsname}
+}
+\expandafter\def\csname macarg.\endcsname{\realbackslash}
+
+% The catcode games are necessary because @macro may or may not
+% have a brace-surrounded list of arguments, and we need to do
+% different stuff in each case. Making {, } \other is the only
+% way to prevent their being deleted by the tokenizer.
+\def\macro{\recursivefalse
+ \bgroup\catcode`\{=\other\catcode`\}=\other\parsearg\macroxxx}
+\def\rmacro{\recursivetrue
+ \bgroup\catcode`\{=\other\catcode`\}=\other\parsearg\macroxxx}
+
+\def\macroxxx#1{\egroup % started in \macro
+ \getargs{#1}% now \macname is the macname and \toks0 the arglist
+ \edef\temp{\the\toks0}%
+ \ifx\temp\empty % no arguments
+ \paramno=0%
\else
\expandafter\parsemargdef \the\toks0;%
\fi
- \bgroup\catcode`\-=11\global\futurelet\nxt\iimacro}
-
-% \imacro has noted whether the macro takes one, two, or many
-% arguments (in \paramno). \iimacro figures out whether it's
-% recursive, and then uses the argument count and the recursivity to
-% select one of the six macro execution sequences. Then we save the
-% original definition of @foo in \macsave@foo, and define @foo to call
-% the selected execution sequence. \edef conveniently just expands
-% the token registers, not the deep structure.
-\def\iimacro{%
- \egroup % started in \imacro
- \ifx\nxt\allowrecur
- \let\next\parserbody
- \toks0=\expandafter{\csname dormacro\ifcase\paramno na\or oa\fi\endcsname}%
+ \expandafter\ifx \csname macsave.\the\macname\endcsname \relax
+ \cslet{macsave.\the\macname}{\the\macname}%
\else
- \let\next\parsebody
- \toks0=\expandafter{\csname domacro\ifcase\paramno na\or oa\fi\endcsname}%
+ \message{Warning: redefining \the\macname}%
\fi
- \expandafter\ifx \csname macsave@\the\macname\endcsname \relax
- \cslet{macsave@\the\macname}{\the\macname}%
+ \begingroup \macrobodyctxt
+ \ifrecursive \expandafter\parsermacbody
+ \else \expandafter\parsemacbody
+ \fi}
+
+\def\unmacro{\parsearg\unmacroxxx}
+\def\unmacroxxx#1{
+ \expandafter\ifx \csname macsave.\the\macname\endcsname \relax
+ \errmessage{Macro \the\macname\ not defined.}%
\else
- \errmessage{warning: redefining macro \the\macname}%
+ \cslet{#1}{macsave.#1}%
+ \expandafter\let \csname macsave.\the\macname\endcsname \undefined
\fi
- \expandafter\edef\csname\the\macname\endcsname{\the\toks0{\the\macname}}%
-\next}
-
-% @allow-recursion is noticed and handled by \iimacro. It should
-% never actually be executed. It has two names so we don't need
-% strange catcodes while defining \iimacro.
-\def\allowrecur{\errmessage{Internal error: \noexpand\allowrecur executed}}
-{\catcode`\-=11\global\let\allow-recursion\allowrecur}
-
-% unmacro just restores the old meaning; the MAC@<macname> macros
-% remain defined. (Memory leak!) \norecurse is defined below, near
-% the execution commands.
-\def\unmacro{\parsearg\iunmacro}
-\def\iunmacro#1{\macname={#1} \norecurse}
-
-% We need {} to be ordinary inside these commands. [] are temporary
+}
+
+% Parse the optional {params} list. Set up \paramno and \paramlist
+% so \defmacro knows what to do. Define \macarg.blah for each blah
+% in the params list, to be ##N where N is the position in that list.
+% That gets used by \mbodybackslash (above).
+
+% This code has to take great care with `macro parameter char #'. The
+% eight hashes in a row on the macarg.#1 line collapse to four in the
+% definition of \macarg.blah, to two when \parsemacbody expands the
+% macro replacement text, and to one when \defmacro writes the macro
+% definiton. The games with \twohash are to postpone expansion till
+% the very end, when \parsemargdefyyy crunches \paramlist into
+% something that can be splatted into a \expandafter\def\blah line (in
+% \defmacro).
+\def\parsemargdef#1;{\paramno=0\def\paramlist{}\parsemargdefxxx#1,;,}
+\def\parsemargdefxxx#1,{%
+ \let\twohash\relax
+ \if#1;\let\next=\parsemargdefyyy
+ \else \let\next=\parsemargdefxxx
+ \advance\paramno by 1%
+ \expandafter\edef\csname macarg.#1\endcsname{########\the\paramno}%
+ \edef\paramlist{\paramlist\twohash\twohash\the\paramno,}%
+ \fi\next}
+\def\parsemargdefyyy{\let\twohash##\relax \edef\paramlist{\paramlist}}
+
+% These two commands read recursive and nonrecursive macro bodies.
+% (They're different since rec and nonrec macros end differently.)
+
+\long\def\parsemacbody#1@end macro%
+{\xdef\temp{#1} \endgroup\defmacro}%
+\long\def\parsermacbody#1@end macro%
+{\xdef\temp{#1} \endgroup\defmacro}%
+
+
+% This defines the macro itself. There are six cases: recursive and
+% nonrecursive macros of zero, one, and many arguments.
+% Much magic with \expandafter here.
+\def\defmacro{%
+ \ifrecursive
+ \ifcase\paramno
+ % 0
+ \expandafter\edef\csname\the\macname\endcsname{%
+ \noexpand\scantokens{\temp}}%
+ \or % 1
+ \expandafter\edef\csname\the\macname\endcsname{%
+ \noexpand\braceorline\csname\the\macname xxx\endcsname}%
+ \expandafter\edef\csname\the\macname xxx\endcsname##1{%
+ \noexpand\scantokens{\temp}}%
+ \else % many
+ \expandafter\edef\csname\the\macname\endcsname##1{%
+ \csname\the\macname xxx\endcsname ##1,}%
+ \expandafter\expandafter
+ \expandafter\edef
+ \expandafter\expandafter
+ \csname\the\macname xxx\endcsname
+ \paramlist{\noexpand\scantokens{\temp}}%
+ \fi
+ \else
+ \ifcase\paramno
+ % 0
+ \expandafter\edef\csname\the\macname\endcsname{%
+ \noexpand\norecurse{\the\macname}%
+ \noexpand\scantokens{\temp}\egroup}%
+ \or % 1
+ \expandafter\edef\csname\the\macname\endcsname{%
+ \noexpand\braceorline\csname\the\macname xxx\endcsname}%
+ \expandafter\edef\csname\the\macname xxx\endcsname##1{%
+ \noexpand\norecurse{\the\macname}
+ \noexpand\scantokens{\temp}\egroup}%
+ \else % many
+ \expandafter\edef\csname\the\macname\endcsname##1{%
+ \csname\the\macname xxx\endcsname ##1,}%
+ \expandafter\expandafter
+ \expandafter\edef
+ \expandafter\expandafter
+ \csname\the\macname xxx\endcsname
+ \paramlist{%
+ \noexpand\norecurse{\the\macname}
+ \noexpand\scantokens{\temp}\egroup}%
+ \fi
+ \fi}
+
+\def\norecurse#1{\bgroup\cslet{#1}{macsave.#1}}
+
+% \braceorline decides whether the next nonwhitespace character is a
+% {. If so it reads up to the closing }, if not, it reads the whole
+% line. Whatever was read is then fed to the next control sequence
+% as an argument (by \parsebrace or \parsearg)
+\def\braceorline{\bgroup
+\catcode`\{=\other\catcode`\}=\other \futurelet\nxt\braceorlinexxx}
+\def\braceorlinexxx{%
+ \ifx\nxt\brace
+ \expandafter\parsebrace
+ \else
+ \egroup \expandafter\parsearg
+ \fi}
+
+% We need {} to be \other inside these commands. [] are temporary
% grouping symbols.
\begingroup
\catcode`\{=\other \catcode`\}=\other
% @macro can be called with or without a brace-surrounded macro
% argument list. These three sequences extract the macro name and arg
-% list in hopefully all cases. *Note, anything on the line after the
-% first pair of braces will be thrown out.
-\gdef\splitarg#1[\isplitarg|#1 {}|]
-\gdef\isplitarg|#1 {#2}#3|[%
+% list in hopefully all cases. Note that anything on the line after the
+% first pair of braces will be thrown out (Makeinfo puts it into the
+% macro body).
+\gdef\getargs#1[\getargsxxx|#1 {}|]
+\gdef\getargsxxx|#1 {#2}#3|[%
\toks0=[#2]%
\edef\tmp[\the\toks0]%
\ifx\tmp\empty
- \isplitargnospaces|#1{}|%
+ \getargsnospaces|#1{}|%
\else
\macname=[#1]%
\fi]
-\gdef\isplitargnospaces|#1{#2}#3|[\macname=[#1] \toks0=[#2]]
+\gdef\getargsnospaces|#1{#2}#3|[\macname=[#1]\toks0=[#2]]
% \parsebrace gets around the situation produced by \braceorline
-% (below) where the { has the wrong catcode because of \futurelet.
+% (above) where the { has the wrong catcode because of \futurelet.
% The \egroup matches a \bgroup in \braceorline.
\gdef\parsebrace#1{#2}[\egroup\let\next=#1\next[#2]]
-\global\let\brace={ % used by \braceorline, below
+\global\let\brace={ % used by \braceorline
\endgroup
-% Argument parsing.
-% These routines iterate over a comma-separated list defining
-% tokens that map macro formal to actual parameters.
-% \parsemargdef sets the formal -> positional correspondence at macro
-% definition time; \parsemarg sets positional -> actual at runtime.
-%
-% The definitions are not symmetric because the callers have the
-% argument list in different places (token register and #arg)
-\def\parsemargdef#1;{\paramno=0\iparsemargdef#1,;,}
-\def\iparsemargdef#1,{%
- \if#1;\let\next=\relax
- \else \let\next=\iparsemargdef
- \advance\paramno by 1%
- \expandafter\edef\csname MAC@\the\macname#1\endcsname
- {\csname MAC@\the\macname.\the\paramno\endcsname}%
- \fi\next}
-
-\def\parsemarg#1{\paramno=1\iparsemarg#1,;,}
-\def\iparsemarg#1,{%
- \if#1;\let\next=\relax
- \else \let\next=\iparsemarg
- \expandafter\def\csname MAC@\the\macname.\the\paramno\endcsname{#1}%
- \advance\paramno by 1%
- \fi\next}
-
-% Argument substitution.
-% \ is active when the body is read and tokenized; it converts its
-% argument to a macro-argument name and expands it. We use | as a
-% temporary escape character.
-{
-\catcode`\|=0 |catcode`|\=|active
-|gdef\#1\{|csname MAC@|the|macname#1|endcsname}
-}
-
-% These sequences read and save the macro body. \parserbody absorbs
-% the @allow-recursion in its argument, and then falls through to
-% \parsebody.
-\def\parsebody{\begingroup\catcode`\\=\active\iparsebody}
-\def\parserbody#1{\parsebody}
-
-% \iparsebody reads the entire macro in as an argument. \ was made
-% active by \parsebody while the reading occurs.
-\long\def\iparsebody#1 \end macro% The space eats the final CR.
-{\endgroup % started in \parsebody
-\expandafter\def\csname MACb.\the\macname \endcsname{#1}}
-
-% These six sequences execute recursive and nonrecursive macros of no,
-% one, and many arguments. We need to distinguish one arg from many
-% args because a one-argument macro invoked with no arguments gets the
-% rest of the line as its argument.
-%
-% Please note that all macros are executed inside a group, so any
-% changes made by a macro (@set, etc.) won't stick.
-\def\dormacrona#1{\begingroup\macname={#1}\idomacro{}}
-\def\dormacrooa#1{\begingroup\macname={#1}\braceorline}
-\def\dormacro#1{\begingroup\macname={#1}\idomacro}
-
-\def\domacrona#1{\begingroup\macname={#1}\norecurse\idomacro{}}
-\def\domacrooa#1{\begingroup\macname={#1}\norecurse\braceorline}
-\def\domacro#1{\begingroup\macname={#1}\norecurse\idomacro}
-
-% some helpers:
-\def\norecurse{\cslet{\the\macname}{macsave@\the\macname}}
-\def\idomacro#1{\parsemarg{#1}\csname MACb.\the\macname\endcsname\endgroup}
-
-% \braceorline decides whether the next nonwhitespace character is a
-% {. If so it reads up to the closing }, if not, it reads the whole
-% line. Whatever was read is then fed to \idomacro. \parsebrace is
-% defined above, near \splitarg, in a strange catcode environment;
-% this is necessary because \futurelet freezes the catcode of the
-% peeked-at character.
-\def\braceorline{\bgroup
-\catcode`\{=\other\catcode`\}=\other \futurelet\nxt\ibraceorline}
-\def\ibraceorline{%
-\ifx\nxt\brace
- \expandafter\parsebrace
- \else
- \egroup \expandafter\parsearg
- \fi \idomacro}
-
-
\message{cross references,}
\newwrite\auxfile
projects / platform / upstream / make.git / commitdiff