% language=us runpath=texruns:manuals/lowlevel

% \hfil \hss
% spread

\environment lowlevel-style

\startdocument
  [title=scope,
   color=middleblue]

\startsectionlevel[title=Introduction]

When I visited the file where register allocations are implemented I wondered to
what extent it made sense to limit allocation to global instances only. This
chapter deals with this phenomena.

\stopsectionlevel

\startsectionlevel[title=Registers]

In \TEX\ definitions can be local or global. Most assignments are local within a
group. Registers and definitions can be assigned global by using the \type
{\global} prefix. There are also some properties that are global by design, like
\type {\prevdepth}. A mixed breed are boxes. When you tweak its dimensions you
actually tweak the current box, which can be an outer level. Compare:

\starttyping[option=TEX]
\scratchcounter = 1
here the counter has value 1
\begingroup
    \scratchcounter = 2
    here the counter has value 2
\endgroup
here the counter has value 1
\stoptyping

with:

\starttyping[option=TEX]
\setbox\scratchbox=\hbox{}
here the box has zero width
\begingroup
    \wd\scratchbox=10pt
    here the box is 10pt wide
\endgroup
here the box is 10pt wide
\stoptyping

It all makes sense so a remark like \quotation {Assignments to box dimensions are
always global} are sort of confusing. Just look at this:

\startbuffer
\setbox\scratchbox=\hbox to 20pt{}
here the box is \the\wd\scratchbox\ wide\par
\begingroup
    \setbox\scratchbox=\hbox{}
    here the box is \the\wd\scratchbox\ wide\par
    \begingroup
        \wd\scratchbox=15pt
        here the box is \the\wd\scratchbox\ wide\par
    \endgroup
    here the box is \the\wd\scratchbox\ wide\par
\endgroup
here the box is \the\wd\scratchbox\ wide\par
\stopbuffer

\typebuffer[option=TEX] \startlines \getbuffer \stoplines

If you don't think about it, what happens is what you expect. Now watch the next
variant:

\startbuffer
\setbox\scratchbox=\hbox to 20pt{}
here the box is \the\wd\scratchbox\ wide\par
\begingroup
    \setbox\scratchbox=\hbox{}
    here the box is \the\wd\scratchbox\ wide\par
    \begingroup
        \global\wd\scratchbox=15pt
        here the box is \the\wd\scratchbox\ wide\par
    \endgroup
    here the box is \the\wd\scratchbox\ wide\par
\endgroup
here the box is \the\wd\scratchbox\ wide\par
\stopbuffer

The \type {\global} is only effective for the current box. It is good to realize
that when we talk registers, the box register behaves just like any other
register but the manipulations happen to the current one.

\typebuffer \startlines \getbuffer \stoplines

\startbuffer
\scratchdimen=20pt
here the dimension is \the\scratchdimen\par
\begingroup
    \scratchdimen=0pt
    here the dimension is \the\scratchdimen\par
    \begingroup
        \global\scratchdimen=15pt
        here the dimension is \the\scratchdimen\par
    \endgroup
    here the dimension is \the\scratchdimen\par
\endgroup
here the dimension is \the\scratchdimen\par
\stopbuffer

\typebuffer[option=TEX] \startlines \getbuffer \stoplines

\stopsectionlevel

\startsectionlevel[title=Allocation]

The plain \TEX\ format has set some standards and one of them is that registers
are allocated with \type {\new...} commands. So we can say:

\starttyping[option=TEX]
\newcount\mycounta
\newdimen\mydimena
\stoptyping

These commands take a register from the pool and relate the given name to that
entry. In \CONTEXT\ we have a bunch of predefined scratch registers for general
use, like:

\startbuffer
scratchcounter    : \meaningfull\scratchcounter
scratchcounterone : \meaningfull\scratchcounterone
scratchcountertwo : \meaningfull\scratchcountertwo
scratchdimen      : \meaningfull\scratchdimen
scratchdimenone   : \meaningfull\scratchdimenone
scratchdimentwo   : \meaningfull\scratchdimentwo
\stopbuffer

\typebuffer[option=TEX]

The meaning reveals what these are:

\startlines \tttf \getbuffer \stoplines

You can use the numbers directly but that is a bad idea because they can clash!
In the original \TEX\ engine there are only 256 registers and some are used by
the engine and the core of a macro package itself, so that leaves a little amount
for users. The \ETEX\ extension lifted that limitation and bumped to 32K and
\LUATEX\ upped that to 64K. One could go higher but what makes sense? These
registers are taking part of the fixed memory slots because that makes nested
(grouped) usage efficient and access fast. The number you see above is deduced
from the so called command code (here indicated by \type {\count}) and an index
encoded in the same token. So, \type {\scratchcounter} takes a single token
contrary to the verbose \type {\count257} that takes four tokens where the number
gets parsed every time it is needed. But those are details that a user can
forget.

As mentioned, commands like \type {\newcount \foo} create a global control
sequence \type {\foo} referencing a counter. You can locally redefine that
control sequence unless in \LUAMETATEX\ you have so called overload mode enabled.
You can do local or global assignments to these registers.

\starttyping[option=TEX]
\scratchcounter = 123
\begingroup
    \scratchcounter = 456
    \begingroup
        \global\scratchcounter = 789
    \endgroup
\endgroup
\stoptyping

And in both cases count register 257 is set. When an assignment is global,
all current values to that register get the same value. Normally this is all
quite transparent: you get what you ask for. However the drawback is that
as a user you cannot know what variables are already defined, which means
that this will fail (that is: it will issue a message):

\starttyping[option=TEX]
\newcount\scratchcounter
\stoptyping

as will the second line in:

\starttyping[option=TEX]
\newcount\myscratchcounter
\newcount\myscratchcounter
\stoptyping

In \CONTEXT\ the scratch registers are visible but there are lots of internally
used ones are protected from the user by more obscure names. So what if you want
to use your own register names without \CONTEXT\ barking to you about not being
able to define it. This is why in \LMTX\ (and maybe some day in \MKIV) we now
have local definitions:

\startbuffer
\begingroup
  \newlocaldimen\mydimena     \mydimena1\onepoint
  \newlocaldimen\mydimenb     \mydimenb2\onepoint
  (\the\mydimena,\the\mydimenb)
  \begingroup
    \newlocaldimen\mydimena   \mydimena3\onepoint
    \newlocaldimen\mydimenb   \mydimenb4\onepoint
    \newlocaldimen\mydimenc   \mydimenc5\onepoint
    (\the\mydimena,\the\mydimenb,\the\mydimenc)
    \begingroup
      \newlocaldimen\mydimena \mydimena6\onepoint
      \newlocaldimen\mydimenb \mydimenb7\onepoint
      (\the\mydimena,\the\mydimenb)
    \endgroup
    \newlocaldimen\mydimend   \mydimend8\onepoint
    (\the\mydimena,\the\mydimenb,\the\mydimenc,\the\mydimend)
  \endgroup
  (\the\mydimena,\the\mydimenb)
\endgroup
\stopbuffer

\typebuffer[option=TEX]

The allocated registers get zero values but you can of course set them to any
value that fits their nature:

\startlines \getbuffer \stoplines

\startbuffer
\begingroup
  \setnewlocaldimen\mydimena     1\onepoint
  \setnewlocaldimen\mydimenb     2\onepoint
  (\the\mydimena,\the\mydimenb)
  \begingroup
    \setnewlocaldimen\mydimena   3\onepoint
    \setnewlocaldimen\mydimenb   4\onepoint
    \setnewlocaldimen\mydimenc   5\onepoint
    (\the\mydimena,\the\mydimenb,\the\mydimenc)
    \begingroup
      \setnewlocaldimen\mydimena 6\onepoint
      \setnewlocaldimen\mydimenb 7\onepoint
      (\the\mydimena,\the\mydimenb)
    \endgroup
    \setnewlocaldimen\mydimend   8\onepoint
    (\the\mydimena,\the\mydimenb,\the\mydimenc,\the\mydimend)
  \endgroup
  (\the\mydimena,\the\mydimenb)
\endgroup
\stopbuffer

You can also use the next variant where you also pass the initial value:

\typebuffer[option=TEX]

So, again we get:

\startlines \getbuffer \stoplines

When used in the body of the macro there is of course a little overhead
involved in the repetitive allocation but normally that can be neglected.

\stopsectionlevel

\startsectionlevel[title=Files]

When adding these new allocators I also wondered about the read and write
allocators. We don't use them in \CONTEXT\ but maybe users like them, so let's
give an example and see what more demands they have:

\starttyping[option=TEX]
\integerdef\StartHere\numexpr\inputlineno+2\relax
\starthiding
SOME LINE 1
SOME LINE 2
SOME LINE 3
SOME LINE 4
\stophiding
\integerdef\StopHere\numexpr\inputlineno-2\relax
\stoptyping

% We need to be in the file!

\integerdef\StartHere\numexpr\inputlineno+2\relax
\starthiding
SOME LINE 1
SOME LINE 2
SOME LINE 3
SOME LINE 4
\stophiding
\integerdef\StopHere\numexpr\inputlineno-2\relax

\startbuffer
\begingroup
  \newlocalread\myreada
  \immediate\openin\myreada {lowlevel-scope.tex}
  \dostepwiserecurse{\StopHere}{\StartHere}{-1}{
    \readline\myreada line #1 to \scratchstring #1 : \scratchstring \par
  }
  \blank
  \dostepwiserecurse{\StartHere}{\StopHere}{1}{
    \read    \myreada line #1 to \scratchstring #1 : \scratchstring \par
  }
  \immediate\closein\myreada
\endgroup
\stopbuffer

\typebuffer[option=TEX]

Here, instead of hard coded line numbers we used the stored values. The
optional \type {line} keyword is a \LMTX\ speciality.

\startlines \getbuffer \stoplines

Actually an application can be found in a small (demonstration) module:

\startbuffer
\usemodule[system-readers]
\stopbuffer

\typebuffer[option=TEX] \getbuffer

This provides the code for doing this:

\starttyping[option=TEX]
\startmarkedlines[test]
SOME LINE 1
SOME LINE 2
SOME LINE 3
\stopmarkedlines

\begingroup
  \newlocalread\myreada
  \immediate\openin\myreada {\markedfilename{test}}
  \dostepwiserecurse{\lastmarkedline{test}}{\firstmarkedline{test}}{-1}{
    \readline\myreada line #1 to \scratchstring #1 : \scratchstring \par
  }
  \immediate\closein\myreada
\endgroup
\stoptyping

As you see in these examples, we an locally define a read channel without
getting a message about it already being defined.

\stopsectionlevel

\stopdocument


