summaryrefslogtreecommitdiff
path: root/Master/texmf-dist/source/latex/expl3/l3int.dtx
diff options
context:
space:
mode:
authorKarl Berry <karl@freefriends.org>2006-01-11 23:53:06 +0000
committerKarl Berry <karl@freefriends.org>2006-01-11 23:53:06 +0000
commit1f4499ce04e16a3dae7c287b445576361cc20769 (patch)
treead95653c87d8135183eddbd885d1645f9dc5b547 /Master/texmf-dist/source/latex/expl3/l3int.dtx
parent4206a1600d2e36ae7c46f99a3c58ae98112ee1ad (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.dtx755
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}
+