%D \module
%D   [       file=buff-ver, % was core-ver
%D        version=2000.05.09,
%D          title=\CONTEXT\ Buffer Macros,
%D       subtitle=Verbatim,
%D         author=Hans Hagen,
%D           date=\currentdate,
%D      copyright={PRAGMA / Hans Hagen \& Ton Otten}]
%C
%C This module is part of the \CONTEXT\ macro||package and is
%C therefore copyrighted by \PRAGMA. See mreadme.pdf for
%C details.

\writestatus{loading}{ConTeXt Buffer Macros / Verbatim}

\registerctxluafile{buff-ver}{1.001}

\unprotect

\definesystemattribute[verbatimline][public]

\appendtoksonce \attribute\verbatimlineattribute \attributeunsetvalue \to \everyforgetall

%D Initializations.

\newtoks\everyinitializeverbatim

\appendtoks
    \the\everyresettypesetting
    \resetfontfeature
    \resetcharacterspacing
\to \everyinitializeverbatim

\def\setverbatimspaceskip % to be checked: must happen after font switch
  {\spaceskip\fontcharwd\font`x\relax
   \xspaceskip\spaceskip}

\unexpanded\def\specialcontrolspace{\hskip\zeropoint\fastcontrolspace\hskip\zeropoint}

\setvalue{\??tp:\c!lines:\v!yes       }{\obeybreakpoints}
\setvalue{\??tp:\c!lines:\v!hyphenated}{\obeyhyphens}

\setvalue{\??tp:\c!space:\v!on        }{\let\obeyedspace\specialcontrolspace}
\setvalue{\??tp:\c!space:\v!stretch   }{\let\obeyedspace\specialstretchedspace}
\setvalue{\??tp:\c!space:\v!normal    }{}
\setvalue{\??tp:\c!space:\v!fixed     }{\let\obeyedspace\specialfixedspace}

\setvalue{\??tp:\c!blank:\v!standard  }{\ctxparskip}
\setvalue{\??tp:\c!blank:\v!small     }{\smallskipamount}
\setvalue{\??tp:\c!blank:\v!medium    }{\medskipamount}
\setvalue{\??tp:\c!blank:\v!big       }{\bigskipamount}
\setvalue{\??tp:\c!blank:\v!halfline  }{.5\baselineskip}
\setvalue{\??tp:\c!blank:\v!line      }{\baselineskip}
\setvalue{\??tp:\c!blank:\v!none      }{\zeropoint}

\def\secondstageinitializetype
  {\let\obeyedspace\specialobeyedspace
   \csname\??tp:\c!space:\typeparameter\c!space\endcsname
   \relax\the\everyinitializeverbatim\relax}

\def\secondstageinitializetyping
  {\let\obeyedspace\specialobeyedspace
   \csname\??tp:\c!space:\typingparameter\c!space\endcsname
   \csname\??tp:\c!lines:\typingparameter\c!lines\endcsname
   \relax\the\everyinitializeverbatim\relax}

\def\firststageinitializetype
  {\let\obeylines\ignorelines
   \ignorehyphens % default
   \dosettypeattributes\c!style\c!color
   \setcatcodetable\vrbcatcodes}

\let\doverbatimsetlinemargin\relax

\def\dodoverbatimsetlinemargin
  {\getpagestatus
   \ifrightpage
     \hskip\typingparameter\c!oddmargin\relax
   \else
     \hskip\typingparameter\c!evenmargin\relax
   \fi}

\def\docheckverbatimmargins
  {\scratchskip\typingparameter\c!oddmargin\relax
   \ifzeropt\scratchskip
   \else
     \let\doverbatimsetlinemargin\dodoverbatimsetlinemargin
   \fi
   \scratchskip\typingparameter\c!evenmargin\relax
   \ifzeropt\scratchskip
   \else
     \let\doverbatimsetlinemargin\dodoverbatimsetlinemargin
   \fi
   \ifx\doverbatimsetlinemargin\relax
     \doadaptleftskip{\typingparameter\c!margin}%
   \fi}

\def\firststageinitializetyping
  {\switchtobodyfont[\typingparameter\c!bodyfont]%
   \docheckverbatimmargins
   \dosettypingattributes\c!style\c!color
   \doifsomething{\typingparameter\c!align}{\setupalign[\typingparameter\c!align]}%
   \ignorehyphens} % default

%D \macros
%D   {definetype,setuptype}
%D
%D Specific inline verbatim commands can be defined with the
%D following command.

\installcommandhandler{\??ty}{type}{\??ty}

\appendtoks
    \normalexpanded{\dodefinetype{\currenttype}}%
\to \everydefinetype

\unexpanded\def\dodefinetype#1%
  {\setuvalue{#1}{\dotype{#1}}}

\appendtoks
   \doinitializevisualizer{\typeparameter\c!option}%
\to \everysetuptype

%D \macros
%D   {definetyping,setuptyping}
%D
%D For most users the standard \type{\start}||\type{\stop}||pair
%D will suffice, but for documentation purposes the next
%D definition command can be of use:
%D
%D \starttyping
%D \definetyping[extratyping][margin=3em]
%D
%D \startextratyping
%D these extra ones are indented by 1 em
%D \stopextratyping
%D \stoptyping
%D
%D The definitions default to the standard typing values.

\installcommandhandler{\??tp}{typing}{\??tp}

\appendtoks
    \normalexpanded{\dodefinetyping{\currenttyping}}%
\to \everydefinetyping

\unexpanded\def\dodefinetyping#1%
  {\setvalue{\e!start#1}{\dostarttyping{#1}}%
   \setvalue{\e!stop #1}{\dostoptyping {#1}}}

\appendtoks
   \doinitializevisualizer{\typingparameter\c!option}% we can check at the tex end
\to \everysetuptyping

\def\doinitializevisualizer#1%
  {\ifproductionrun\ctxlua{visualizers.load("#1")}\fi}

% \definetype[typeTEX][option=tex]
%
% \typeTEX|\example---oeps|. this---ligates---again.
% \typeTEX{\example---oeps}. this---ligates---again.
% \type   {\example---oeps}. this---ligates---again.

%D \startbuffer
%D \setuptyping[TEX][escape=yes]
%D
%D \startTEX
%D /BTEX\em sometex/ETEX
%D /BTEX\em sometex/ETEX \after
%D \before /BTEX\em sometex/ETEX
%D \before /BTEX\em sometex/ETEX \after
%D \before /BTEX\em sometex/ETEX \inbetween /BTEX\em sometex/ETEX \after
%D \before \after
%D \stopTEX
%D \stopbuffer
%D
%D \typebuffer \start \getbuffer \stop
%D
%D \startbuffer
%D \setuptyping[TEX][escape={[[,]]}]
%D
%D \startTEX
%D [[\em sometex]]
%D [[\em sometex]] \after
%D \before [[\em sometex]]
%D \before [[\em sometex]] \after
%D \before [[\em sometex]] \inbetween [[\em sometex]] \after
%D \before \after
%D \stopTEX
%D \stopbuffer
%D
%D \typebuffer \start \getbuffer \stop
%D
%D \startbuffer
%D \setuptyping[TEX][escape=//]
%D
%D \startTEX
%D //\em sometex
%D \before //\em sometex
%D \stopTEX
%D
%D \typebuffer \start \getbuffer \stop

%D Verbatim command are very sensitive to argument processing,
%D which is a direct result of the \CATCODES\ being fixed at
%D reading time.
%D
%D Typesetting inline verbatim can be accomplished by
%D \type{\type}, which in this sentence was typeset by saying
%D just \type{\type{\type}}, which in turn was typeset by
%D \unknown. Using the normal grouping characters \type{{}} is
%D the most natural way of using this command.
%D
%D A second, more or less redundant, alternative is delimiting
%D the argument with an own character. This method was
%D implemented in the context of a publication in the \MAPS,
%D where this way of delimiting is recognized by \LATEX\ users.
%D
%D The third, more original alternative, is the one using
%D \type{<<} and \type{>>} as delimiters. This alternative can
%D be used in situations where slanted typeseting is needed.

\def\lesscharacter {<}
\def\morecharacter {>}
\let\texescape     \textbackslash
\let\leftargument  \textbraceleft
\let\rightargument \textbraceright

%D \macros
%D   {type}
%D
%D We define \type{\type} as a protected command. This command
%D has several invocations: grouped, wirt boundary characters,
%D and with font switches.
%D
%D \starttyping
%D normal: \par \type{xx<<..xx..<<xx <<xx>> >>..>>xx} \par \type<<....>> \par \type<<..<<xx>>..>> \par
%D normal: \par \type{xx<..xx..<xx <slanted> >..>xx} \par \type{<....>} \par \type{<..<xx>..>}
%D \setuptype[option=slanted]
%D slanted: \par \type{xx<<..sl..<<xx <<sl>> xx>>..sl..>>xx} \par \type<<..xx..>> \par \type<<..<<sl>>..>> \par
%D slanted: \par \type{xx<<..sl..<xx <sl> xx>..sl..>>xx} \par \type<<..xx..>> \par \type<<..<sl>..>> \par
%D \setuptype[option=none]
%D none: \par \type{xx<<..xx..<<xx <<xx>> >>..>>xx} \par \type<<....>> \par \type<<..<<xx>>..>> \par
%D \stoptyping
%D
%D When writing the manual to \CONTEXT\ and documenting this
%D source we needed to typeset \type{<<} and \type{>>}. Because
%D we wanted to do this in the natural way, we've adapted the
%D original definition a bit. This implementation went through
%D several live cycles. The final implementation looks a bit
%D further and treats the lone \type{<<} and \type{>>} a bit
%D different. The \type {\null} prevents ligatures, which
%D unfortunately turn up in Lucida fonts.
%D
%D The following lines show what happens when we set
%D \type {option=commands}.
%D
%D \startbuffer
%D \starttyping
%D test//test test/BTEX \footnote{test test test}/ETEX test
%D test//test test/BTEX \footnote{test test test}/ETEX  test
%D test test test/BTEX \bf(nota bene)/ETEX test
%D test test test /BTEX \bf(nota bene)/ETEX  test
%D \stoptyping
%D \stopbuffer
%D
%D % \bgroup\setuptyping[option=commands]\getbuffer\egroup
%D
%D this was keyed in as:
%D
%D \typebuffer

% beware, the command is supposed to do something like
% \framed and not manipulate content i.e. it gets no
% argument but something b/egrouped instead
%
% so, if we only had left and right it woul dbe:
%
% \def\doleftoftype {\typeparameter\c!left\bgroup}  % we need the grouping in order
% \def\dorightoftype{\egroup\typeparameter\c!right} % to get the normal font
%
% but with command:

\def\doleftoftype {\typeparameter\c!left\typeparameter\c!command\bgroup}
\def\dorightoftype{\egroup\typeparameter\c!right}

\unexpanded\def\type{\dotype\empty}
\unexpanded\def\typ {\dotyp \empty}

\def\dotype#1%
  {\dontleavehmode
   \bgroup
   \edef\currenttype{#1}%
   \doifnextoptionalelse\redotype\dodotype}

\def\redotype[#1]%
  {\getparameters[\??ty\currenttype][#1]%
   \dodotype}

\def\dodotype
  {\doleftoftype
   \futurelet\next\dodotypeone}

\def\dotyp#1%
  {\dontleavehmode
   \bgroup
   \edef\currenttype{#1}%
   \lettypeparameter\v!lines\v!hyphenated
   \let\specialobeyedspace\specialstretchedspace
   \doifnextoptionalelse\redotype\dodotype}

\def\dodotypeone
  {\ifx\next\bgroup
     \@EA\dodotypeA
   \else
     \@EA\dodotypetwo
   \fi}

\def\dodotypetwo
  {\catcode`<=\othercatcode % old precaution
   \catcode`>=\othercatcode % old precaution
   \futurelet\next\dodotypethree}

\def\dodotypethree
  {\if\next<%
     \@EA\dodotypeB
   \else
     \@EA\dodotypeC
   \fi}

\def\dodotypeA
  {\firststageinitializetype
   \setcatcodetable\tpacatcodes
   \dodotypenormal}

\def\dodotypeB#1%
  {\firststageinitializetype
   \setcatcodetable\tpbcatcodes
   \dodotypenested}

\def\dodotypeC#1%
  {\firststageinitializetype
   \setcatcodetable\vrbcatcodes
   \def\next##1#1{\dodotypenormal{##1}}%
   \next}

\def\dodotypenormal#1%
  {\secondstageinitializetype
   \dostarttagged\t!verbatim\currenttype
   \ctxcommand{typestring {
     data   = \!!bs\detokenize{#1}\!!es,
     tab    = "\typeparameter\c!tab",
     method = "\typeparameter\c!option",
     nature = "inline",
    }}%
   \dostoptagged
   \dorightoftype
   \egroup}

\def\dodotypenested#1%
  {\secondstageinitializetype
   \dostarttagged\t!verbatim\currenttype
   \ctxcommand{typestring {
     data   = \!!bs\detokenize{#1}\!!es,
     tab    = "\typeparameter\c!tab",
     method = "nested", % we force a special visualizer
     option = "\typeparameter\c!option", % extra visualizer (maybe: nested,\typeparameter\c!option)
     nature = "inline",
   }}%
   \dostoptagged
   \dorightoftype
   \egroup
   \gobbleoneargument} % grab last >

%D \macros
%D   {obeyhyphens,obeybreakpoints}
%D
%D Although it's not clear from the macros, one character
%D trait of this macros, which are build on top of the support
%D module, is that they don't hyphenate. We therefore offer
%D the alternative \type{\typ}. The current implementation
%D works all right, but a decent hyphenation support of
%D \type{\tt} text will be implemented soon.

\def\specialfixedspace    {\kern\interwordspace\relax}
\def\specialobeyedspace   {\hskip\interwordspace\relax} % better than spaceskip
\def\specialstretchedspace{\hskip.5\interwordspace\!!plus.125\interwordstretch\relax} % more but not less
\def\specialcontrolspace  {\hskip\zeropoint\hbox{\normalcontrolspace}\hskip\zeropoint\relax}

\def\obeyhyphens
  {\let\obeyedspace \specialobeyedspace % maybe \specialstretchedspace
   \let\controlspace\specialcontrolspace
   \spaceskip.25em\relax} % hm a bit of stretch !

\def\obeybreakpoints
  {\ignorehyphens
   \veryraggedright}

\def\ignorehyphens
  {\language\minusone % extra bonus, the \null should do the job too
   \let\obeyedspace \specialobeyedspace
   \let\controlspace\specialcontrolspace
   \spaceskip.5em\relax}

%D \macros
%D   {tex,arg,mat,dis}
%D
%D Sometimes, for instance when we pass verbatim text as an
%D argument, the fixed \CATCODES\ interfere with our wishes. An
%D experimental implementation of character by character
%D processing of verbatim text did overcome this limitation,
%D but we've decided not to use that slow and sometimes
%D troublesome solution. Instead we stick to some 'old'
%D \CONTEXT\ macros for typesetting typical \TEX\ characters.

\def\setgroupedtype
  {\firststageinitializetype
   \catcode\leftbraceasciicode \begingroupcatcode
   \catcode\rightbraceasciicode\endgroupcatcode}

\unexpanded\def\tex{\groupedcommand{\setgroupedtype\texescape}{\relax}}
\unexpanded\def\arg{\groupedcommand{\setgroupedtype\leftargument}{\rightargument}}
\unexpanded\def\mat{\groupedcommand{\setgroupedtype\$}{\$}}
\unexpanded\def\dis{\groupedcommand{\setgroupedtype\$\$}{\$\$}}

\let\normaltexttex\tex
\let\normaltextarg\arg
\let\normaltextmat\mat
\let\normaltextdis\dis

\def\astype{\groupedcommand{\dosettypeattributes\c!style\c!color}{}}

%D The basic display verbatim commands are defined in an
%D indirect way. As we will see, they are a specific case of a
%D more general mechanism.

\let\beginofverbatimlines\relax
\let\endofverbatimlines  \relax

\def\dostarttyping#1% tricky non standard lookahead
  {\bgroup
   \edef\currenttyping{#1}%
   \obeylines
   \futurelet\nexttoken\dodostarttyping}

\def\dodostarttyping
  {\ifx\nexttoken[%
     \expandafter\dododostarttyping
   \else
     \expandafter\nododostarttyping
   \fi}

\def\nododostarttyping
  {\dododostarttyping[]}

\def\dododostarttyping[#1]%
  {\typingparameter\c!before
   \startpacked[\v!blank]
   \doifassignmentelse{#1}
     {\setuptyping[\currenttyping][#1]}
     {\doifinset\v!continue{#1}{\setuptyping[\currenttyping][\c!continue=\v!yes]}}%
   \dosetuptypelinenumbering
   \firststageinitializetyping
   \normalexpanded{\dotypeblockverbatim{\e!start\currenttyping}{\e!stop\currenttyping}}}

\unexpanded\def\dotypeblockverbatim#1#2%
  {\dowithbuffer{_typing_}{#1}{#2}{}{\dodotypeblockverbatim{#1}{#2}}}

\def\dodotypeblockverbatim#1#2%
  {\secondstageinitializetyping
   \dostarttagged\t!verbatimblock\currenttyping
   \beginofverbatimlines
   \dostarttagged\t!verbatimlines\empty
   \ctxcommand{typebuffer {
     name   = "_typing_",
     strip  = "\typingparameter\c!strip",
     range  = "\typingparameter\c!range",
     tab    = "\typingparameter\c!tab",
     method = "\typingparameter\c!option",
     escape = \!!bs\typingparameter\c!escape\!!es,
     nature = "display",
   }}%
   \dostoptagged
   \endofverbatimlines
   \dostoptagged
   \csname#2\endcsname}

\def\dostoptyping#1% hm, currenttyping
  {\stoppacked
   \typingparameter\c!after
   \normalexpanded{\egroup\checknextindentation[\typingparameter\c!indentnext]}%
   \dorechecknextindentation}

%D Line numbering for files is combined with filtering, while
%D display verbatim has the ability to continue.
%D
%D \starttyping
%D \typefile[numbering=file,start=10,stop=12]{test.tex}
%D
%D \definetyping[code][numbering=line]
%D
%D \starttext
%D \startcode
%D ...
%D ...
%D \stopcode
%D
%D \startcode[start=continue]
%D ...
%D ...
%D \stopcode
%D
%D \startcode[start=10]
%D ...
%D \stopcode
%D \stoptyping

%D Ranges:
%D
%D \starttyping
%D % label:start:one
%D
%D \def\MyMacro
%D   {just an example}
%D
%D % label:stop:one
%D
%D \starttext
%D
%D % \typefile[file][range={3,6}] {whatever.tex}
%D % \typefile[file][range={3,+2}]{whatever.tex}
%D
%D \typefile[file][range={label:start:one,label:stop:one}]{whatever.tex}
%D
%D \stoptext
%D \stoptyping

%D \macros
%D   {typefile}
%D
%D Typesetting files verbatim (for the moment) only supports
%D colorization of \TEX\ sources as valid option. The other
%D setup values are inherited from display verbatim.
%D The implementation of \type{\typefile} is straightforward:

% [category] [settings] {name} % for historic reasons, all filenames are {}

\def\typefile
  {\dodoubleempty\dotypefile}

\def\dotypefile[#1][#2]#3%
  {\bgroup
   \ifsecondargument
     \setuptyping[#1][#2]%
     \dododotypefile{#1}{#3}%
   \else\iffirstargument
     \doifassignmentelse{#1}
       {\setuptyping[\v!file][#1]
        \dododotypefile\v!file{#3}}
       {\dododotypefile{#1}{#3}}%
   \else
     \dododotypefile\v!file{#3}%
   \fi\fi
   \egroup}

\def\dododotypefile#1#2%
  {\doifelsetypingfile{#2}
     {\dodododotypefile{#1}\readfilename}
     {\showmessage\m!verbatims1{#2}}}

\def\doifelsetypingfile#1% sets \readfilename (we will make this proper mkiv i.e. less messy)
  {\doiflocfileelse{#1}
     {\firstoftwoarguments}
     {\doifinputfileelse{#1}
        {\def\readfilename{#1}\firstoftwoarguments} % messy, looks wrong too
        {\secondoftwoarguments}}}

\def\dodododotypefile#1#2% category name
  {\edef\currenttyping{#1}%
   \typingparameter\c!before
   \startpacked[\v!blank]
   \dosetuptypelinenumbering
   \firststageinitializetyping
   \secondstageinitializetyping
   \dostarttagged\t!verbatimblock\currenttyping
   \beginofverbatimlines
   \dostarttagged\t!verbatimlines\empty
   \ctxcommand{typefile {
      name   = "#2",
      strip  = "\typingparameter\c!strip",
      range  = "\typingparameter\c!range",
      regime = "\currentregime",
      tab    = "\typingparameter\c!tab",
      method = "\typingparameter\c!option",
      nature = "display",
    }}%
   \dostoptagged
   \endofverbatimlines
   \dostoptagged
   \stoppacked
   \typingparameter\c!after}

%D Line numbering:

\newconditional\verbatimnumberinglines

\def\beginofverbatimlinenumbering
  {\startlinenumbering
     [\currenttyping]%
     [\c!continue=\typingparameter\c!continue,
        \c!method=\v!type,
         \c!start=\typingparameter\c!start,
          \c!stop=\typingparameter\c!stop, % ?
          \c!step=\typingparameter\c!step]}

\def\endofverbatimlinenumbering
  {\stoplinenumbering}

\def\dosetuptypelinenumbering
  {\ifdefined\startlinenumbering
     \edef\currenttypingnumbering{\typingparameter\c!numbering}%
     \ifx\currenttypingnumbering\v!file
       \setuplinenumbering[\currenttyping][\c!method=\v!file]%
       \settrue\verbatimnumberinglines
     \else\ifx\currenttypingnumbering\v!line
       \settrue\verbatimnumberinglines
     \else
       \setfalse\verbatimnumberinglines
     \fi\fi
     \ifconditional\verbatimnumberinglines
       \let\beginofverbatimlines\beginofverbatimlinenumbering
       \let\endofverbatimlines  \endofverbatimlinenumbering
     \fi
   \fi}

%D \macros
%D   {filename}
%D
%D Typesetting filenames in monospaced fonts is possible with
%D
%D \starttyping
%D \filename{here/there/filename.suffix}
%D \stoptyping
%D
%D The definition is not that spectacular.

\unexpanded\def\filename#1{{\tttf\hyphenatedfilename{#1}}}

%D \macros
%D   {verbatim}
%d
%D And a bonus macro, an unexpanded detokenize:

\unexpanded\def\verbatim#1{\detokenize{#1}}

%D The setups for display verbatim and file verbatim are
%D shared. One can adapt the extra defined typing environments,
%D but they also default to the values below. Watch the
%D alternative escape character.

\setuptyping
  [       \c!before=\blank,
           \c!after=\blank,
       %\c!bodyfont=,
         %\c!color=,
           \c!space=\v!off,
            \c!page=\v!no,
             \c!tab=\v!yes, % what is this: \s!ascii ?
          \c!option=\v!none,
            \c!text=\v!no,
           \c!style=\tttf,
      \c!indentnext=\v!yes,
          \c!margin=\!!zeropoint,
      \c!evenmargin=\!!zeropoint,
       \c!oddmargin=\!!zeropoint,
           \c!blank=\v!line,
         %\c!escape=, % yes | no | {START,STOP} | default when yes: {BTEX,ETEX}
       \c!numbering=\v!no,
          %\c!lines=,
          %\c!range=,
           \c!start=1,
           %\c!stop=,
            \c!step=1,
       %\c!continue=,
           \c!strip=\v!no] %auto or number

\definetyping[\v!typing]

\setuptyping[\v!file]  [\s!parent=\??tp\v!typing] % we don't want \start..\stop overload
\setuptyping[\v!buffer][\s!parent=\??tp\v!file]   % we don't want \start..\stop overload

%D The setups for inline verbatim default to:

\setuptype
  [ \c!space=\v!off,
   %\c!color=,
    \c!style=\tt\tf, % \tttf gives problems with {\tx \type...}
  %\c!option=\v!normal,
     \c!page=\v!no,
      \c!tab=\v!yes]

%D Buffers

% [name] [settings] | [name] | [settings]

\unexpanded\def\typebuffer
  {\dodoubleempty\dotypebuffer}

\unexpanded\def\dotypedefinedbuffer
  {\dotripleempty\dodotypedefinedbuffer}

\appendtoks
    \setuevalue{\e!type\currentbuffer}%
      {\noexpand\dotypedefinedbuffer
         [\v!buffer]%
         [def-\number\nofdefinedbuffers]}%
\to \everydefinebuffer

\def\dotypebuffer[#1][#2]%
  {\bgroup
   \ifsecondargument
     \setuptyping[\v!buffer][#2]%
     \processcommalist[#1]{\dododotypebuffer\v!buffer}% [name] [settings]
   \else\iffirstargument
     \doifassignmentelse{#1}
       {\setuptyping[\v!buffer][#1]%
        \dododotypebuffer\v!buffer\empty}% [settings]
       {\processcommalist[#1]{\dododotypebuffer\v!buffer}}% [name]
   \else
     \dododotypebuffer\v!buffer\empty% []
   \fi\fi
   \egroup}

\def\dodotypedefinedbuffer[#1][#2][#3]% category name settings
  {\bgroup
   \ifthirdargument
     \setuptyping[#1][#3]%
   \fi
   \dododotypebuffer{#1}{#2}%
   \egroup}

\def\dododotypebuffer#1#2% category name
  {\edef\currenttyping{#1}%
   \typingparameter\c!before
   \startpacked[\v!blank]
   \dosetuptypelinenumbering
   \firststageinitializetyping
   \secondstageinitializetyping
   \beginofverbatimlines
   \dostarttagged\t!verbatimblock{#1}%
   \ctxcommand{typebuffer {
     name   = "#2",
     strip  = "\typingparameter\c!strip",
     range  = "\typingparameter\c!range",
     regime = "\currentregime",
     tab    = "\typingparameter\c!tab",
     method = "\typingparameter\c!option",
     escape = \!!bs\typingparameter\c!escape\!!es,
     nature = "display",
   }}%
   \dostoptagged
   \endofverbatimlines
   \stoppacked
   \typingparameter\c!after}

% process buffers .. settings

\unexpanded\def\processbuffer
  {\dodoubleempty\doprocessbuffer}

\def\doprocessbuffer[#1][#2]%
  {\bgroup
   \ifsecondargument
     \setuptyping[\v!buffer][#2]%
     \processcommalist[#1]{\dodoprocessbuffer\v!buffer}% [name] [settings]
   \else\iffirstargument
     \doifassignmentelse{#1}
       {\setuptyping[\v!buffer][#1]%
        \dodoprocessbuffer\v!buffer\empty}% [settings]
       {\processcommalist[#1]{\dodoprocessbuffer\v!buffer}}% [name]
   \else
     \dodoprocessbuffer\v!buffer\empty% []
   \fi\fi
   \egroup}

% get     : before/after of buffer
% typing  : before/after of typing
% process : no before/after (special case anyway)

\def\dodoprocessbuffer#1#2%
  {\edef\currenttyping{#1}%
   \ctxcommand{processbuffer {
     name   = "#2",
     strip  = "\typingparameter\c!strip",
     tab    = "\typingparameter\c!tab",
     method = "\typingparameter\c!option",
     nature = "direct",
   }}}

% line numbering, keep broken lines together

\newcount\nofverbatimlines

\def\doverbatimbeginofline
  {\ifconditional\verbatimnumberinglines
     \global\advance\nofverbatimlines\plusone
     \attribute\verbatimlineattribute\nofverbatimlines
   \fi
   \noindent
   \doverbatimsetlinemargin
   \the\everyline\strut
   \dostarttagged\t!verbatimline\empty}

\def\doverbatimendofline
  {\dostoptagged
   \obeyedline % still needed?
   \par
   \ifconditional\verbatimnumberinglines
     \attribute\verbatimlineattribute\attributeunsetvalue
   \fi}

\def\doverbatimemptyline
  {\dostoptagged
   \ifconditional\verbatimnumberinglines
     \par\strut\par % this will be an option where we use a signal instead of a strut
   \else
     \blank[\typingparameter\c!blank]%
   \fi
    \dostarttagged\t!verbatimlines\empty}

% hooks:

\def\doinlineverbatimstart      {}
\def\doinlineverbatimstop       {}
\def\doinlineverbatimbeginline  {}
\def\doinlineverbatimnewline    {\obeyedspace}
\def\doinlineverbatimemptyline  {\obeyedspace}

\def\dodisplayverbatimstart     {\doverbatimbeginofline}
\def\dodisplayverbatimstop      {\doverbatimendofline}
\def\dodisplayverbatimbeginline {\doverbatimbeginofline}
\def\dodisplayverbatimnewline   {\doverbatimendofline\par}
\def\dodisplayverbatimemptyline {\doverbatimemptyline}

\def\doverbatimspace            {\obeyedspace}

\loadmarkfile{buff-imp-default}    % preloaded as otherwise spurious spaces inline due to loading
\loadmarkfile{buff-imp-nested}     % preloaded as otherwise spurious spaces inline due to loading
\loadmarkfile{buff-imp-escaped}    % for completeness

\protect \endinput