diff options
author | Karl Berry <karl@freefriends.org> | 2006-01-11 23:53:06 +0000 |
---|---|---|
committer | Karl Berry <karl@freefriends.org> | 2006-01-11 23:53:06 +0000 |
commit | 1f4499ce04e16a3dae7c287b445576361cc20769 (patch) | |
tree | ad95653c87d8135183eddbd885d1645f9dc5b547 /Master/texmf-dist/source/latex/expl3/l3int.dtx | |
parent | 4206a1600d2e36ae7c46f99a3c58ae98112ee1ad (diff) |
trunk/Master/texmf-dist/source/latex/expl3
git-svn-id: svn://tug.org/texlive/trunk@270 c570f23f-e606-0410-a88d-b1316a301751
Diffstat (limited to 'Master/texmf-dist/source/latex/expl3/l3int.dtx')
-rw-r--r-- | Master/texmf-dist/source/latex/expl3/l3int.dtx | 755 |
1 files changed, 755 insertions, 0 deletions
diff --git a/Master/texmf-dist/source/latex/expl3/l3int.dtx b/Master/texmf-dist/source/latex/expl3/l3int.dtx new file mode 100644 index 00000000000..d219a9d27bb --- /dev/null +++ b/Master/texmf-dist/source/latex/expl3/l3int.dtx @@ -0,0 +1,755 @@ +% \iffalse +%% File: l3int.dtx Copyright (C) 1990-1998 LaTeX3 project +% +%<*dtx> + \ProvidesFile{l3int.dtx} +%</dtx> +%<package>\NeedsTeXFormat{LaTeX2e} +%<package>\ProvidesPackage{l3int} +%<driver> \ProvidesFile{l3int.drv} +% \fi +% \ProvidesFile{l3int.dtx} + [1998/04/20 v1.0c L3 Experimental Integer module] +% +% \iffalse +%<*driver> +\documentclass{l3doc} + +\begin{document} +\DocInput{l3int.dtx} +\end{document} +%</driver> +% \fi +% +% +% \GetFileInfo{l3int.dtx} +% \title{The \textsf{l3int} package\thanks{This file +% has version number \fileversion, last +% revised \filedate.}\\ +% Counters} +% \author{\Team} +% \date{\filedate} +% \maketitle +% +% \section{Counters} +% +% \LaTeX3 maintains two type of integer registers for internal use. +% One (associated with the name "int") uses the builtin counter +% registers of \TeX{} and is therefore relatively fast and one +% (associated with the name "fint" for fake counter) that implements the +% operations within the \TeX{} macro language and is therefore much +% slower in processing. This type of counter is also far more restricted +% in its range. +% +% The fake counter should be used for variables that are not accessed +% very often since this saves the important fast internal registers +% (\TeX{} has only 255 of those). For example, all allocation routines +% in \LaTeX3 make use of fake counters to remember the values of recent +% allocated register numbers etc. +% +% Since all functions for both types are very similar (they usually +% differ only in the initial "f") we describe them together. But +% remember that you need to use "fint" variables when using "fint" +% functions. +% +% \subsection{Functions} +% +% \begin{function}{% +% \int_new:N | +% \int_new:c | +% \fint_new:N | +% } +% \begin{syntax} +% "\int_new:N" <int> +% "\fint_new:N" <fint> +% \end{syntax} +% Defines <int> to be a new variable of type "int". There is no way to +% define constant counters with these functions. +% \begin{texnote} +% "\int_new:N" is the equivalent to plain \TeX{}'s \tn{newcount}. +% However, the internal register allocation is done differently. +% \end{texnote} +% \end{function} +% +% \begin{function}{% +% \int_incr:N | +% \int_gincr:N | +% \int_gincr:c | +% \fint_incr:N | +% \fint_gincr:N | +% } +% \begin{syntax} +% "\int_incr:N" <int> +% "\fint_incr:N" <fint> +% \end{syntax} +% Increments <int> by one. For global variables the global versions +% should be used. +% \end{function} +% +% \begin{function}{% +% \int_decr:N | +% \int_gdecr:N | +% \int_gdecr:c | +% \fint_decr:N | +% \fint_gdecr:N | +% } +% \begin{syntax} +% "\int_decr:N" <int> +% "\fint_decr:N" <fint> +% \end{syntax} +% Decrements <int> by one. For global variables the global versions +% should be used. +% \end{function} +% +% \begin{function}{% +% \int_set:Nn | +% \int_set:cn | +% \int_gset:Nn | +% \int_gset:cn | +% \fint_set:Nn | +% \fint_gset:Nn | +% } +% \begin{syntax} +% "\int_set:Nn" <int> "{" <integer> "}" +% "\fint_set:Nn" <fint> "{" <integer> "}" +% \end{syntax} +% These functions will set the <int> register to the <integer> value. +% \end{function} +% +% \begin{function}{% +% \fint_set_eq:NN | +% \fint_gset_eq:NN | +% } +% \begin{syntax} +% "\fint_set_eq:NN" <fint1> <fint2> +% \end{syntax} +% Fast form for +% \begin{syntax} +% "\fint_set:No" <fint1> "{\fint_use:N" <fint2> "}" +% \end{syntax} +% when <fint2> is known to be a variable of fake counter. Note that a +% corresponding function for real counters is not implemented since the +% "\int_set:Nn" function does this operation sufficiently when then second +% argument is a <int> instead of "{"<integer>"}" value. +% \end{function} +% +% \begin{function}{% +% \int_add:Nn | +% \int_add:cn | +% \int_gadd:Nn | +% \fint_add:Nn | +% \fint_gadd:Nn | +% } +% \begin{syntax} +% "\int_add:Nn" <int> "{" <integer> "}" +% "\fint_add:Nn" <fint> "{" <integer> "}" +% \end{syntax} +% These functions will add to the <int> register the value <integer>. If +% the second argument is a <int> register too, the surrounding braces +% can be left out. +% +% It not allowed to use a <fint> instead of the <integer>. If a fake +% counter should be used as the second argument one needs to turn the +% <fint> first into an <integer> by applying "\fint_use:N". +% \end{function} +% +% \begin{function}{% +% \int_sub:Nn | +% \int_gsub:Nn | +% \fint_sub:Nn | +% \fint_gsub:Nn | +% } +% \begin{syntax} +% "\int_gsub:Nn" <int> "{" <integer> "}" +% "\fint_gsub:Nn" <fint> "{" <integer> "}" +% \end{syntax} +% These functions will subtract from the <int> register the value +% <integer>. If the second argument is a <int> register too, the +% surrounding braces can be left out. +% +% It is not allowed to use a <fint> instead of the <integer>. If a fake +% counter should be used as the second argument one needs to turn the +% <fint> first into an <integer> by applying "\fint_use:N". +% \end{function} +% +% \begin{function}{% +% \int_use:N | +% \int_use:c | +% \fint_use:N | +% } +% \begin{syntax} +% "\int_use:N" <int> +% "\fint_use:N" <fint> +% \end{syntax} +% This function returns the integer value kept in <int> in a way +% suitable for further processing. Be sure to use "\fint_use:N" if you +% are accessing the value of a fake counter because otherwise your +% result will be to some surprise to you (there is no check). +% \begin{texnote} +% The function "\int_use:N" could be implemented directly as the \TeX{} +% primitive "\tex_the:D" which is also responsible to produce the values for +% other internal quantities. We have chosen to use individual functions +% for counters, dimenions etc.\ to allow checks and to make the code +% more selfexplaining. +% \end{texnote} +% \end{function} +% +% \subsection{Formatting a counter value} +% +% \begin{function}{\int_to_arabic:n | +% \int_to_alph:n | +% \int_to_Alph:n | +% \int_to_roman:n | +% \int_to_Roman:n | +% \int_to_symbol:n | +% } +% \begin{syntax} +% "\int_to_alph:n" "{" <integer> "}" +% "\int_to_alph:n" <int> +% "\int_to_alph:n" "{" "\fint_use:N" <fint> "}" +% \end{syntax} +% If some <integer> or the the current value of a <int> should be +% displayed or typeset in a special ways (e.g., as uppercase roman +% numerals) these function can be used. We need braces if the argument +% is a simple <integer>, they can be omitted in case of a <int>. +% +% To format <fint>s with these functions it is necessary to turn the +% value of the <fint> first into an <integer> by applying "\fint_use:N" +% within the argument braces. +% +% All functions are fully expandable and will therefore produce the +% correct output when used inside of deferred writes, etc. +% \begin{texnote} +% These are more or less the internal \LaTeX2 functions \tn{@arabic}, +% \tn{@alph}, \tn{Alph}, \tn{@roman}, \tn{@Roman}, and \tn{@fnsymbol} +% except that "\int_to_symbol:n" is also allowed outside math mode. +% \end{texnote} +% \end{function} +% +% \subsection{Variable and constants} +% +% \begin{variable}{% +% \c_int_max | +% \c_fint_max | +% } +% Constant that denote the maximum value which can be stored in a <int> +% or <fint> register. +% \end{variable} +% +% \begin{variable}{% +% \c_minus_one | +% \c_zero | +% \c_one | +% \c_two | +% \c_three | +% \c_sixteen | +% \c_twohundred_fifty_five | +% \c_twohundredfiftysix | +% \c_thousand | +% \c_ten_thousand | +% \c_twenty_thousand | +% } +% Set of constants denoting useful values. +% \begin{texnote} +% Most of these constants have been available under \LaTeX2 under names +% like \tn{tw@}, \tn{thr@@} etc. +% \end{texnote} +% \end{variable} +% +% \begin{variable}{% +% \l_tmpa_int | +% \l_tmpb_int | +% \l_tmpc_int | +% \g_tmpa_int | +% \g_tmpb_int | +% } +% Scratch register for immediate use. They are not used by conditionals +% or predicate functions. +% \end{variable} +% +% +% \section{Integer registers} +% +% +% We start by ensuring that the required packages are loaded. +% \begin{macrocode} +%<package&!check>\RequirePackage{l3basics}\par +%<package&check>\RequirePackage{l3chk}\par +%<*package> +% \end{macrocode} +% +% Functions that support \LaTeX's user accessible counters should be +% added here, too. But first the internal counters. +% +% \begin{macro}{\int_incr:N} +% \begin{macro}{\int_decr:N} +% \begin{macro}{\int_gincr:N} +% \begin{macro}{\int_gdecr:N} +% Incrementing and decrementing of integer registers is done with +% the following functions. +% \begin{macrocode} +\def_new:Npn \int_incr:N #1{\tex_advance:D#1\c_one +%<*check> + \chk_local_or_pref_global:N #1 +%</check> +} +\def_new:Npn \int_decr:N #1{\tex_advance:D#1\c_minus_one +%<*check> + \chk_local_or_pref_global:N #1 +%</check> +} +\def_new:Npn \int_gincr:N { +% \end{macrocode} +% We make sure that a local variable is not updated globally by +% changing the internal test (i.e.\ |\chk_local_or_pref_global:N|) before +% making the assignment. This is done by |\pref_global_chk:| which also +% issues the necessary |\pref_global:D|. This is not very efficient, but +% this code will be only included for debugging purposes. Using +% |\pref_global:D| in front of the local function is better in the +% production versions. +% \begin{macrocode} +%<*check> + \pref_global_chk: +%</check> +%<-check> \pref_global:D + \int_incr:N} +\def_new:Npn \int_gdecr:N { +%<*check> + \pref_global_chk: +%</check> +%<-check> \pref_global:D + \int_decr:N} +% \end{macrocode} +% With the |\int_add:Nn| functions we can shorten the above code. +% If this makes it too slow \ldots +% \begin{macrocode} +\def:Npn \int_incr:N #1{\int_add:Nn#1\c_one} +\def:Npn \int_decr:N #1{\int_add:Nn#1\c_minus_one} +\def:Npn \int_gincr:N #1{\int_gadd:Nn#1\c_one} +\def:Npn \int_gdecr:N #1{\int_gadd:Nn#1\c_minus_one} +% \end{macrocode} +% \end{macro} +% \end{macro} +% \end{macro} +% \end{macro} +% +% +% \begin{macro}{\int_new:N} +% \begin{macro}{\int_new:c} +% Allocation of a new internal counter is already done above. Here we define +% the next likely variant. +% \begin{macrocode} +\def_new:Npn \int_new:N {} % but since we don't distribute +\let:NN \int_new:N \newcount % allocation better nick the LaTeX one ... +\def_new:Npn \int_new:c {\exp_args:Nc \int_new:N} +% \end{macrocode} +% \end{macro} +% \end{macro} +% +% +% \begin{macro}{\int_set:Nn} +% \begin{macro}{\int_set:cn} +% \begin{macro}{\int_gset:Nn} +% \begin{macro}{\int_gset:cn} +% Setting counters is again something that I would like to make +% uniform at the moment to get a better overview. +% \begin{macrocode} +\def_new:Npn \int_set:Nn #1#2{#1#2\scan_stop: +%<*check> +\chk_local_or_pref_global:N #1 +%</check> +} +\def_new:Npn \int_gset:Nn { +%<*check> + \pref_global_chk: +%</check> +%<-check> \pref_global:D + \int_set:Nn } +\def_new:Npn \int_set:cn {\exp_args:Nc \int_set:Nn } +\def_new:Npn \int_gset:cn {\exp_args:Nc \int_gset:Nn } +% \end{macrocode} +% \end{macro} +% \end{macro} +% \end{macro} +% \end{macro} +% +% +% \begin{macro}{\int_add:Nn} +% \begin{macro}{\int_add:cn} +% \begin{macro}{\int_gadd:Nn} +% \begin{macro}{\int_sub:Nn} +% \begin{macro}{\int_gsub:Nn} +% Adding and substracting to and from a counter \ldots +% We should think of using these functions +% \begin{macrocode} +\def_new:Npn \int_add:Nn #1#2{ + \tex_advance:D#1#2\scan_stop: +%<*check> + \chk_local_or_pref_global:N #1 +%</check> +} +\def_new:Npn\int_add:cn{\exp_args:Nc\int_add:Nn} +\def_new:Npn \int_sub:Nn #1#2{ + \tex_advance:D#1-#2\scan_stop: +%<*check> +\chk_local_or_pref_global:N #1 +%</check> +} +\def_new:Npn \int_gadd:Nn { +%<*check> + \pref_global_chk: +%</check> +%<-check> \pref_global:D + \int_add:Nn } +\def_new:Npn \int_gsub:Nn { +%<*check> + \pref_global_chk: +%</check> +%<-check> \pref_global:D + \int_sub:Nn } +% \end{macrocode} +% \end{macro} +% \end{macro} +% \end{macro} +% \end{macro} +% \end{macro} +% +% +% \begin{macro}{\int_use:N} +% \begin{macro}{\int_use:c} +% Here is how counters are accessed: +% \begin{macrocode} +\let_new:NN \int_use:N \tex_the:D +\def_new:Npn \int_use:c #1{\int_use:N \cs:w#1\cs_end:} +% \end{macrocode} +% \end{macro} +% \end{macro} + +% +% \begin{macro}{\int_gincr:c} +% \begin{macro}{\int_gdecr:c} +% We also need \ldots +% \begin{macrocode} +\def_new:Npn \int_gincr:c {\exp_args:Nc \int_gincr:N} +\def_new:Npn \int_gdecr:c {\exp_args:Nc \int_gdecr:N} +% \end{macrocode} +% \end{macro} +% \end{macro} +% +% +% \begin{macro}{\l_tmpa_int} +% \begin{macro}{\l_tmpb_int} +% \begin{macro}{\l_tmpc_int} +% \begin{macro}{\g_tmpa_int} +% \begin{macro}{\g_tmpb_int} +% We provide two local and two global scratch counters, maybe we +% need more or less. Instead of using the allocation routines we +% partly allocate them by hand. +% \begin{macrocode} +\chk_new_cs:N \l_tmpa_int +% \end{macrocode} +% If it turns out that we don't need local counters then this +% register should be used for global counter. We might also think of +% using the |\l_last_alloc_fint| as a scratch register. +% \begin{macrocode} +\tex_countdef:D\l_tmpa_int 255 +\int_new:N \l_tmpb_int +\int_new:N \l_tmpc_int +\int_new:N \g_tmpa_int +\int_new:N \g_tmpb_int +% \end{macrocode} +% \end{macro} +% \end{macro} +% \end{macro} +% \end{macro} +% \end{macro} +% +% \begin{macro}{\c_minus_one} +% \begin{macro}{\c_zero} +% \begin{macro}{\c_one} +% \begin{macro}{\c_two} +% \begin{macro}{\c_three} +% \begin{macro}{\c_four} +% \begin{macro}{\c_sixteen} +% \begin{macro}{\c_thirty_two} +% \begin{macro}{\c_twohundred_fifty_five} +% \begin{macro}{\c_twohundred_fifty_six} +% \begin{macro}{\c_thousand} +% \begin{macro}{\c_ten_thousand} +% \begin{macro}{\c_ten_thousand_one} +% \begin{macro}{\c_ten_thousand_two} +% \begin{macro}{\c_ten_thousand_three} +% \begin{macro}{\c_ten_thousand_four} +% \begin{macro}{\c_twenty_thousand} +% \begin{macro}{\c_int_max} +% And the usual constants, others are still missing. Please, make +% every constant a real constant at least for the moment. We can +% easily convert things in the end when we have found what +% constants are used in critical places and what not. +% \begin{macrocode} +\tex_chardef:D \c_zero = 0 \scan_stop: +\tex_chardef:D \c_one = 1 \scan_stop: +\tex_chardef:D \c_two = 2 \scan_stop: +\tex_chardef:D \c_three = 3 \scan_stop: +\tex_chardef:D \c_four = 4 \scan_stop: +\tex_chardef:D \c_sixteen = 16 \scan_stop: +\tex_chardef:D \c_thirty_two = 32 \scan_stop: +\tex_chardef:D \c_twohundred_fifty_five = 255 \scan_stop: +\tex_mathchardef:D \c_twohundred_fifty_six = 256 \scan_stop: +\tex_mathchardef:D \c_thousand = 1000 \scan_stop: +\tex_mathchardef:D \c_ten_thousand = 10000 \scan_stop: +\tex_mathchardef:D \c_ten_thousand_one = 10001 \scan_stop: +\tex_mathchardef:D \c_ten_thousand_two = 10002 \scan_stop: +\tex_mathchardef:D \c_ten_thousand_three = 10003 \scan_stop: +\tex_mathchardef:D \c_ten_thousand_four = 10004 \scan_stop: +\tex_mathchardef:D \c_twenty_thousand = 20000 \scan_stop: +% already defined ... +%\int_new:N \c_minus_one +% \c_minus_one = -1 +% \end{macrocode} +% The |\c_int_max| will be defined internally as the largest +% dimen. +% \begin{macrocode} +%\int_new:N \c_int_max +% \c_int_max = 2147483647 +% \end{macrocode} +% \end{macro} +% \end{macro} +% \end{macro} +% \end{macro} +% \end{macro} +% \end{macro} +% \end{macro} +% \end{macro} +% \end{macro} +% \end{macro} +% \end{macro} +% \end{macro} +% \end{macro} +% \end{macro} +% \end{macro} +% \end{macro} +% \end{macro} +% \end{macro} +% +% +% Show token usage: +% \begin{macrocode} +%</package> +%<*showmemory> +\showMemUsage +%</showmemory> +% \end{macrocode} +% +% +% \section{Fake registers} +% +% Fake registers are registers which implement \m{counter}s, +% \m{dimen}s, etc.\ which aren't used often and therefore don't need +% to run efficiently. One possible way of using them is to prepare certain +% registers this way, but |\let:NN| the mutator functions to real +% \m{counter}s as long as we have a sufficient number available. Now +% if we are making real large formats (by adding Pic\TeX, for example) +% we can turn them easily into fake registers and everything will work +% as before (only a bit slower). +% +% +% I haven't implemented anything besides counters so far, but \m{dimen} +% and \m{skip} present no principal problem and should probably be +% added. +% +% \subsection{Fake counters} +% +% \begin{macro}{\fint_new:N} +% A fake counter is internally a \m{muskip} register. A count value +% \m{x} is saved as \m{x}|mu| (more exactly as \m{x}|.0mu|) in this +% register. This means that fake counter values are far more +% restricted then usual counters, the largest value is 16383, +% i.e.\ the |pt| part of \TeX{}'s largest \m{dimen}. This could be +% changed by using more complicated conversion routines, but it +% might be all right in usual applications. +% +% Of course, we should make sure that we don't reach the borders, +% otherwise the user will be faced by the surprising message that +% some dimension got to large. (Not done yet). +% \begin{macrocode} +%<*package> +\let_new:NN \fint_new:N \newmuskip % nicked from LaTeX +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\fint_use:N} +% \begin{macro}{\fint_use_aux:w} +% To use the value of a fake counter we have to get rid of |.0mu| in +% an expandable way, since we want to allow constructions like +% \begin{verbatim} +% \if_num:w\fint_use:N \l_test_fint > 55\scan_stop: ... +%\end{verbatim} +% The simplest way I came up with (not much thinking behind) was +% using parameter matching. +% \begin{macrocode} +\def_new:Npn \fint_use:N {\exp_after:NN\fint_use_aux:w\the_internal:D} +% \end{macrocode} +% In the |\fint_use_aux:w| function we remove the |.0mu| and pass the +% the result back into the input stream. The only thing we +% have to think of, is that both |mu| have category code 12 when +% they are returned by |\the_internal:D|. +% \begin{macrocode} +\tex_lccode:D`\!=`\m \tex_lccode:D`\?=`\u +\tex_lowercase:D{\def_new:Npn \fint_use_aux:w #1.0!?{#1}} +\tex_lccode:D`\!=0\scan_stop: \tex_lccode:D`\?=0\scan_stop: +% \end{macrocode} +% \end{macro} +% \end{macro} +% +% +% \begin{macro}{\fint_set:Nn} +% \begin{macro}{\fint_gset:Nn} +% The way both routines are set up, the second argument might be +% either a \m{normal integer}, or an internal register. +% \begin{macrocode} +\def_new:Npn \fint_set:Nn #1#2{#1#2~mu\scan_stop: +%<*check> + \chk_local_or_pref_global:N #1 +%</check> +} +\def_new:Npn \fint_gset:Nn{ +%<*check> + \pref_global_chk: +%</check> +%<-check> \pref_global:D + \fint_set:Nn} +% \end{macrocode} +% \end{macro} +% \end{macro} +% +% +% \begin{macro}{\fint_set_eq:NN} +% \begin{macro}{\fint_gset_eq:NN} +% We can easily set two fake counters equal to each other, but if +% fake counters and real counters are used, we have to use the +% slower |set| functions. +% \begin{macrocode} +\def_new:Npn \fint_set_eq:NN #1#2{#1#2 +%<*check> + \chk_local_or_pref_global:N #1\chk_var_or_const:N #2 +%</check> +} +\def_new:Npn \fint_gset_eq:NN { +%<*check> + \pref_global_chk: +%</check> +%<-check> \pref_global:D + \fint_set_eq:NN} +% \end{macrocode} +% \end{macro} +% \end{macro} +% +% \begin{macro}{\fint_add:Nn} +% \begin{macro}{\fint_gadd:Nn} +% \begin{macro}{\fint_sub:Nn} +% \begin{macro}{\fint_gsub:Nn} +% Adding and substracting; we make use of the fact that internally +% \TeX{} always use the same primitives to advance a register. +% \begin{macrocode} +\def_new:Npn \fint_add:Nn #1#2{\int_add:Nn#1{#2mu}} +\def_new:Npn \fint_gadd:Nn { +%<*check> + \pref_global_chk: +%</check> +%<-check> \pref_global:D + \fint_add:Nn} +\def_new:Npn \fint_sub:Nn #1#2{\int_sub:Nn#1{#2mu}} +\def_new:Npn \fint_gsub:Nn { +%<*check> + \pref_global_chk: +%</check> +%<-check> \pref_global:D + \fint_sub:Nn} +% \end{macrocode} +% \end{macro} +% \end{macro} +% \end{macro} +% \end{macro} +% +% \begin{macro}{\fint_incr:N} +% \begin{macro}{\fint_gincr:N} +% \begin{macro}{\fint_decr:N} +% \begin{macro}{\fint_gdecr:N} +% Incrementing and decrementing the fake counters: +% \begin{macrocode} +\def_new:Npn \fint_incr:N #1{\advance:D#1\c_one mu\scan_stop: +%<*check> + \chk_local_or_pref_global:N #1 +%</check> +} +\def_new:Npn \fint_decr:N #1{\advance:D#1\c_minus_one mu\scan_stop: +%<*check> + \chk_local_or_pref_global:N #1 +%</check> +} +\def_new:Npn \fint_gincr:N { +%<*check> + \pref_global_chk: +%</check> +%<-check> \pref_global:D + \fint_incr:N} +\def_new:Npn \fint_gdecr:N { +%<*check> + \pref_global_chk: +%</check> +%<-check> \pref_global:D + \fint_decr:N} +% \end{macrocode} +% This can be achieved with less tokens but extra expansions: +% \begin{macrocode} +\def:Npn \fint_incr:N #1{\fint_add:Nn#1\c_one} +\def:Npn \fint_decr:N #1{\fint_add:Nn#1\c_minus_one} +% \end{macrocode} +% \end{macro} +% \end{macro} +% \end{macro} +% \end{macro} +% +% \begin{macro}{\c_fint_max} +% A constant, denoting the largest possible value for fake counters. +% \begin{macrocode} +\tex_mathchardef:D\c_fint_max=16383 \scan_stop: +% \end{macrocode} +% \end{macro} +% +% +% \subsection{Fake skip registers} +% +% One has to convert simply from the \m{x}|pt| |plus| \m{y}|pt| |minus| +% \m{z}|pt| representation produced by |\the_internal:D|, to the +% corresponding |mu| representation. Complications arise from the +% possibility that |plus| and/or |minus| is not present,\footnote{This +% can be catched by adding a suitable constant and removing the +% corresponding constant in the other representation.} and by the +% possibility that the stretch or shrink component is a |fil| unit. +% +% \subsection{Fake dimen registers} +% +% I suppose this could be viewed as a subcase of the skip registers. +% See later section for a fake fake version for the moment. +% +% +% \subsection{Allocation routines} +% +% Counters are rare goods in \TeX{} and we are near the limit, if +% for example \LaTeX{} and Pic\TeX{} are merged. Therefore we should +% be careful not to throw away counter registers unnecessarily. One +% place for instance, where we can save some of them are the +% allocation routines. Instead of using counters we maintain the +% number of the last allocated register in a fake counter. +% +% +% \begin{macrocode} +%</package> +%<*showmemory> +\showMemUsage +%</showmemory> +% \end{macrocode} + |