precattl.sty

\ProvidesExplPackage{precattl}{2022/07/07}{0.0.0}{Prepare special catcodes from token list}


% ======== this part is inlined from execinside.sty. It's a bit messy yes, maybe will fix when the 2 LaTeX3 bugs on \peek_analysis_map_inline are fixed
% 

\cs_generate_variant:Nn \EI_append:n {x}
\cs_generate_variant:Nn \int_compare:nNnTF {VNnTF}
\cs_generate_variant:Nn \tl_set:Nn {Nx}
\cs_generate_variant:Nn \int_compare:nNnT {VNnT}
\cs_generate_variant:Nn \cs_if_exist_use:NT {cT}

% ======== define handler functions.
% a few things it can do:
% • \tl_build_gput_right:Nn  to \_EIresult (content being put there must be wrapped in \unexpanded i.e. x-expand to the desired result

\cs_set_protected:Npn \EI_append_raw:n #1 {
	\tl_build_gput_right:Nn \_EIresult {#1}
}

\cs_set_protected:Npn \EI_append:n #1 {
	\EI_append_raw:n {\exp_not:n {#1}}
}

\int_new:N \_EIbalance_level
\int_new:N \_EIcollecting_balanced

% handler can call this to collect following tokens in the input stream as argument.
% #1: the function to pass argument in.  (arguments are passed as brace-hack-included)
% #2: number of arguments
\cs_set_protected:Npn \EI_collect_arg:Nn #1 #2 {
	\int_set:Nn \_EIcollecting_balanced {#2}
	\int_zero:N \_EIbalance_level
	\tl_build_gbegin:N \_EIbalanced_content
	\tl_build_gput_right:Nn \_EIbalanced_content {\noexpand #1}
}

\cs_set_protected:Npn \EIhandler_EIexpand {
	\EI_collect_arg:Nn \EI_append:x {1}
}

\cs_set_protected:Npn \EIhandler_EIexecute {
	\EI_collect_arg:Nn \use:n {1}
}

\cs_set_protected:Npn \execinsideprepare:n #1 {
	\tl_build_gbegin:N \_EIresult
	\int_zero:N \_EIcollecting_balanced

	\tl_analysis_map_inline:nn {#1} {
		% reminder: ##1: token, ##2: char code (int), ##3: cat code (hex digit)

		\int_compare:nNnTF \_EIcollecting_balanced > 0 {
			% collecting content.

			\tl_build_gput_right:Nn \_EIbalanced_content {##1}
			\int_case:nn {"##3} {
				{1} { \int_incr:N \_EIbalance_level }
				{2} { \int_decr:N \_EIbalance_level }
			}

			% we check this every time instead of only after egroup tokens...
			% so that if there's exactly one token to be collected it's still correctly passed through
			% disadvantage: function might get a space
			\int_compare:nNnT \_EIbalance_level = 0 {
				% done, call handler function and revert to normal mode.

				\int_decr:N \_EIcollecting_balanced
				\int_compare:nNnT \_EIcollecting_balanced = 0 {
					\tl_build_gend:N \_EIbalanced_content
					\tl_set:Nx \_EIbalanced_content {\_EIbalanced_content}
					%\pretty:V \_EIbalanced_content
					\_EIbalanced_content  % ← the handler function is embedded in here
					%\pretty:n {done}
				}
			}
		} {
			\let \_EIprocessed \c_false_bool

			% check for \EIexecute etc. and handle accordingly.
			\int_compare:nNnT {##2} = {-1} {
				\cs_if_exist_use:cT {
					EIhandler_ \expandafter \cs_to_str:N ##1
				} {
					\let \_EIprocessed \c_true_bool
				}
			}

			% if not, just append to result.
			\bool_if:NF \_EIprocessed {
				\tl_build_gput_right:Nn \_EIresult {##1}
			}
		}
	}

	\tl_build_gend:N \_EIresult
	\tl_set:Nx \_EIresult {\_EIresult}
}

\cs_set_protected:Npn \execinside:n #1 {
	\execinsideprepare:n {#1}
	\_EIresult
}
\let\execinside\execinside:n  % normal-catcode alias

\cs_set_protected:Npn \execinside_set:Nn #1 #2 {
	\execinsideprepare:n {#2}
	\let #1 \_EIresult
}
\let\execinsideSet\execinside_set:Nn

\cs_set_protected:Npn \execinside_gset:Nn #1 #2 {
	\execinsideprepare:n {#2}
	\global \let #1 \_EIresult
}
\let\execinsideGset\execinside_gset:Nn


%% ======== temporary patch for expl3 bug https://github.com/latex3/latex3/issues/1109
%% okay maybe no need, still use old \tl_analysis implementation
%
%% #1: some explicit char with char 32 and cat X
%% #2: the original explicit char
%\cs_new_protected:Npn \__broken_tl_peek_analysis_char:nN #1#2
%  {
%    \cs_set_protected:Npn \__tl_tmp:w ##1 #1 ##2 ##3 \scan_stop:
%      { \exp_args:No \l__tl_peek_code_tl { \int_value:w `#2 } ##2 }
%    \exp_after:wN \__tl_tmp:w \c__tl_peek_catcodes_tl \scan_stop:
%  }
%
%% only patch in this particular condition.
%\ifx \__tl_peek_analysis_char:nN \__broken_tl_peek_analysis_char:nN
%	\cs_set_protected:Npn \__tl_peek_analysis_char:nN #1#2
%	{
%		\pretty:n  {#1, #2}
%		\token_if_parameter:NTF #1 {
%			\exp_args:No \l__tl_peek_code_tl { \int_value:w `#2 } 6
%		} {
%			\cs_set_protected:Npn \__tl_tmp:w ##1 #1 ##2 ##3 \scan_stop:
%			{ \exp_args:No \l__tl_peek_code_tl { \int_value:w `#2 } ##2 }
%			\exp_after:wN \__tl_tmp:w \c__tl_peek_catcodes_tl \scan_stop:
%		}
%	}
%\fi

% ========


\cs_generate_variant:Nn \exp_args:NN {Nc}
\cs_generate_variant:Nn \EI_append:n {x}
\cs_generate_variant:Nn \exp_args:Nn {No}
\cs_generate_variant:Nn \EI_append:n {o}
\cs_generate_variant:Nn \tl_put_right:Nn {Nx}
\cs_generate_variant:Nn \use:nn {nV}
\cs_generate_variant:Nn \execinside_set:Nn {NV}
	

\def \_prctl_append_space #1 {
	\begingroup
	\lccode `\ =#1
	\lowercase{
		\endgroup \EI_append:n {~}
	}
}
\def \_prctl_append_begin #1 {
	\begingroup
	\lccode `\{=#1
	\lowercase{\endgroup \EI_append_raw:n { \iftrue { \else } \fi }}
}
\def \_prctl_append_end #1 {
	\begingroup
	\lccode `\}=#1
	\lowercase{\endgroup \EI_append_raw:n { \iffalse { \else } \fi }}
}
	
%\def \_prctl_do_special_cC #1 { \exp_args:Nc \EI_append:n {#1} }
\def \_prctl_do_special_cC #1 { \EI_append_raw:n {\exp_not:c {#1}} }  % do this to handle \outer tokens. but in the x-expansion step below need to wrap in a group level to avoid defining control sequences as \relax.

\def \_prctl_do_special_cB #1 { \str_map_inline:nn {#1} { \_prctl_append_begin {`##1} } }
\def \_prctl_do_special_cE #1 { \str_map_inline:nn {#1} { \_prctl_append_end {`##1} } }
\def \_prctl_do_special_cM #1 { \str_map_inline:nn {#1} { \EI_append:x {\char_generate:nn {`##1} {3}} } }
\def \_prctl_do_special_cT #1 { \str_map_inline:nn {#1} { \EI_append:x {\char_generate:nn {`##1} {4}} } }
\def \_prctl_do_special_cP #1 { \str_map_inline:nn {#1} { \exp_args:No \EI_append:o {\char_generate:nn {`##1} {6}} } }
\def \_prctl_do_special_cU #1 { \str_map_inline:nn {#1} { \EI_append:x {\char_generate:nn {`##1} {7}} } }
\def \_prctl_do_special_cD #1 { \str_map_inline:nn {#1} { \EI_append:x {\char_generate:nn {`##1} {8}} } }
\def \_prctl_do_special_cS #1 { \str_map_inline:nn {#1} { \_prctl_append_space {`##1} } }
\def \_prctl_do_special_cL #1 { \str_map_inline:nn {#1} { \EI_append:x {\char_generate:nn {`##1} {11}} } }
\def \_prctl_do_special_cO #1 { \str_map_inline:nn {#1} { \EI_append:x {\char_generate:nn {`##1} {12}} } }
\def \_prctl_do_special_cStr #1 { \EI_append:n {#1} }

\def \_prctl_do_special_cA #1 { \str_map_inline:nn {#1} {
	%\exp_args:No \EI_append:o {\char_generate:nn {`##1} {13}}
	\EI_append_raw:n {\expandafter \expandafter \expandafter \noexpand \char_generate:nn {`##1} {13}}  % handle outer token  -- doesn't work in pdftex because \char_generate implementation not support
} }


\cs_new_protected:Npn \_prctl_do_special #1 #2 {
	% given #1 e.g. \cO, #2 e.g. {abc}, append <abc> in detokenized catcode to EI.
	\begingroup
		\escapechar=-1

		% let \_prctl_tmp be the concatenation of \string of all tokens within #2.
		\def \_prctl_tmp {}
		\tl_analysis_map_inline:nn {#2} {
			\tl_put_right:Nx \_prctl_tmp {\expandafter \string ##1}
		}

		% then pass it to the specific handler.
		\exp_args:NNV
	\endgroup
	#1 \_prctl_tmp
}


\def \_prctl_do_special_cC_outer { \_prctl_do_special\_prctl_do_special_cC }
\def \_prctl_do_special_cB_outer { \_prctl_do_special\_prctl_do_special_cB }
\def \_prctl_do_special_cE_outer { \_prctl_do_special\_prctl_do_special_cE }
\def \_prctl_do_special_cM_outer { \_prctl_do_special\_prctl_do_special_cM }
\def \_prctl_do_special_cT_outer { \_prctl_do_special\_prctl_do_special_cT }
\def \_prctl_do_special_cP_outer { \_prctl_do_special\_prctl_do_special_cP }
\def \_prctl_do_special_cU_outer { \_prctl_do_special\_prctl_do_special_cU }
\def \_prctl_do_special_cD_outer { \_prctl_do_special\_prctl_do_special_cD }
\def \_prctl_do_special_cS_outer { \_prctl_do_special\_prctl_do_special_cS }
\def \_prctl_do_special_cL_outer { \_prctl_do_special\_prctl_do_special_cL }
\def \_prctl_do_special_cO_outer { \_prctl_do_special\_prctl_do_special_cO }
\def \_prctl_do_special_cStr_outer { \_prctl_do_special\_prctl_do_special_cStr }
\def \_prctl_do_special_cA_outer { \_prctl_do_special\_prctl_do_special_cA }

% special tokens
\begingroup

% ======== frozen relax
\def \_prctl_tmp_help #1 {
	\gdef \_prctl_do_frozen_relax { \EI_append:n {#1} }
	% #1 here will be substituted by the frozen relax
}
\expandafter \_prctl_tmp_help \ifnum0=0\fi

% ======== endwrite


\gdef \_prctl_initialize_endwrite {
	\begingroup
		\l_tmpa_int=\interactionmode
		\batchmode % in newer version of pdftex it's no longer possible to get the endwrite token, we just suppress the error

		\def \_prctl_weird{\expandafter\_prctl_weirda\string}
		\def \_prctl_weirda
				##1  %  the stringified }
		{\expandafter\_prctl_weirdb\noexpand}
		\def \_prctl_weirdb ##1 { \iffalse{\fi  } ##1 \xdef \_prctl_insert_endwrite { \noexpand \noexpand \noexpand ##1 } }
		\immediate\write-1{\_prctl_weird}  % this writes a blank line to the log file (when this is first called...)

		\interactionmode=\l_tmpa_int
	\endgroup
	\cs_if_exist:NTF \_prctl_insert_endwrite {
		\gdef \_prctl_do_endwrite {\EI_append_raw:n \_prctl_insert_endwrite}
	} {
		\msg_new:nnn {precattl} {no-endwrite} {
			Endwrite~token~is~not~available.~TeX~process~will~eventually~exit~with~error~code~1.}
		\msg_warning:nn {precattl} {no-endwrite}
		\gdef \_prctl_do_endwrite {}
	}
	\gdef \_prctl_initialize_endwrite {}
}

\gdef \_prctl_do_endwrite {
	\_prctl_initialize_endwrite  % on the first time this is called, we create the endwrite token if possible
	\_prctl_do_endwrite
}



% ======== endtemplate tokens
\def \_prctl_weird #1 {
	\xdef \_prctl_insert_outer_endtemplate {\noexpand \noexpand \noexpand #1}
	\expandafter \_prctl_weirdb #1
	#1
}
\def \_prctl_weirdb #1 {
	\xdef \_prctl_do_inner_endtemplate { \EI_append_raw:n { #1 } }
}

\vbox_set:Nn \l_tmpa_box {
	\halign{
		#\cr
		\relax \expandafter \_prctl_weird \noexpand\cr
	}
}

\gdef \_prctl_do_outer_endtemplate {\EI_append_raw:n \_prctl_insert_outer_endtemplate}


\endgroup






\cs_new_protected:Npn \precattl_prepare:n #1 {
	%\bench start~prepare.
	\begingroup
		\let \EIhandler_EIexpand \undefined
		\let \EIhandler_EIexecute \undefined
		\def \EIhandler_cC { \EI_collect_arg:Nn \_prctl_do_special_cC_outer 1 }
		\def \EIhandler_cB { \EI_collect_arg:Nn \_prctl_do_special_cB_outer 1 }
		\def \EIhandler_cE { \EI_collect_arg:Nn \_prctl_do_special_cE_outer 1 }
		\def \EIhandler_cM { \EI_collect_arg:Nn \_prctl_do_special_cM_outer 1 }
		\def \EIhandler_cT { \EI_collect_arg:Nn \_prctl_do_special_cT_outer 1 }
		\def \EIhandler_cP { \EI_collect_arg:Nn \_prctl_do_special_cP_outer 1 }
		\def \EIhandler_cU { \EI_collect_arg:Nn \_prctl_do_special_cU_outer 1 }
		\def \EIhandler_cD { \EI_collect_arg:Nn \_prctl_do_special_cD_outer 1 }
		\def \EIhandler_cS { \EI_collect_arg:Nn \_prctl_do_special_cS_outer 1 }
		\def \EIhandler_cL { \EI_collect_arg:Nn \_prctl_do_special_cL_outer 1 }
		\def \EIhandler_cO { \EI_collect_arg:Nn \_prctl_do_special_cO_outer 1 }
		\def \EIhandler_cStr { \EI_collect_arg:Nn \_prctl_do_special_cStr_outer 1 }
		\def \EIhandler_cA { \EI_collect_arg:Nn \_prctl_do_special_cA_outer 1 }
		\let \EIhandler_cFrozenRelax \_prctl_do_frozen_relax
		\let \EIhandler_cEndwrite \_prctl_do_endwrite
		\let \EIhandler_cOuterEndtemplate \_prctl_do_outer_endtemplate
		\let \EIhandler_cInnerEndtemplate \_prctl_do_inner_endtemplate
		\execinside_gset:Nn \_prctl_valueg {#1}
	\endgroup
	%\bench done~prepare.
}

\cs_new_protected:Npn \precattl_set:Nn #1 #2 {
	\precattl_prepare:n {#2}
	\tl_set_eq:NN #1 \_prctl_valueg
}






\use_none:n{{{ % ======== unused code, will do something with it once peek_analysis_map_inline:n bug is fixed

\cs_new_protected:Npn \__resume_peek: {
	\peek_analysis_map_inline:n {
		\__process {##1} {##2} {##3}
	}
}

\def \__help:NN #1 #2 {
	\def #1 { \peek_analysis_map_break:n { \_prctl_do_special #2 } }
}
\cs_generate_variant:Nn \__help:NN {cc}
\str_map_inline:nn {CBEMTPUDSLOA} {
	\__help:cc {__special c #1} {__special c #1 _continue: }
}

\def \__help:NN #1 #2 {
	\def #1 { \peek_analysis_map_break:n { #2 } }
}

\str_map_inline:nn {BEMTPUDSLOA} {
	\__help:cc {__special c #1} {__special c #1 _continue: }
}


\def \__help:n #1 {
	\def \__specialcFrozenRelax {
		\tl_build_gput_right:Nn \__result { #1 }
	}
	% #1 here will be substituted by the frozen relax
}
\expandafter \__help:n \ifnum0=0\fi
\let \__help:n \undefined



% ======== define \__specialcB_continue:, etc.

\def \__help:Nn #1 #2 {
	\def #1 ##1 {
		\tl_analysis_map_inline:nn {##1} {
			\str_map_inline:xn {\expandafter\string####1} {
				\tl_build_gput_right:Nn \__result {
					\char_generate:nn {`########1} {#2}
				}
			}
		}
		\__resume_peek:
	}
}
\__help:Nn \__specialcB_continue: {1}
\__help:Nn \__specialcE_continue: {2}
\__help:Nn \__specialcM_continue: {3}
\__help:Nn \__specialcT_continue: {4}
\__help:Nn \__specialcU_continue: {7}
\__help:Nn \__specialcD_continue: {8}
\__help:Nn \__specialcS_continue: {10}
\__help:Nn \__specialcL_continue: {11}
\__help:Nn \__specialcO_continue: {12}


\def \__specialcC_continue: #1 {
	\begingroup
		\exp_args:NNo \tl_build_gput_right:Nn \__result {\expandafter \noexpand \csname #1 \endcsname}
	\endgroup
	\__resume_peek:
}
\def \__specialcA_continue: #1 {
	\tl_analysis_map_inline:nn {#1} {
		\str_map_inline:xn {\expandafter\string##1} {
			\tl_build_gput_right:Nn \__result {
				\expandafter \expandafter \expandafter \noexpand \char_generate:nn {`####1} {13}
			}
		}
	}
	\__resume_peek:
}
\def \__specialcP_continue: #1 {
	\tl_analysis_map_inline:nn {#1} {
		\str_map_inline:xn {\expandafter\string##1} {
			\tl_build_gput_right:Nn \__result {
				######## \char_generate:nn {`####1} {6}
				%## \char_generate:nn {`#1} {6}
			}
		}
	}
	\__resume_peek:
}

% ========

\cs_new_protected:Npn \__process #1 #2 #3 {
	\token_if_eq_meaning:NNTF #3 0 {

		%\ifcsname __special \expandafter \cs_to_str:N #1 \endcsname
		%	\csname __special \expandafter \cs_to_str:N #1 \expandafter \endcsname
		%\else
		%	\tl_build_gput_right:Nn \__result {#1}
		%\fi

		\ifcsname __special \expandafter \cs_to_str:N #1 \endcsname
			\expandafter \use_i:nn
		\else
			\expandafter \use_ii:nn
		\fi
		{\csname __special \expandafter \cs_to_str:N #1 \endcsname}
		{\tl_build_gput_right:Nn \__result {#1}}
	}
	{
		\tl_build_gput_right:Nn \__result {#1}
	}
}



\def \_prctl_tmp_help #1 {
	\def \_prctl_do_frozen_relax { \EI_append:n {#1} }
	% #1 here will be substituted by the frozen relax
}
\expandafter \_prctl_tmp_help \ifnum0=0\fi
\let \_prctl_tmp_help \undefined


\def \precattl_setx:Nn #1 #2 {
	\begingroup
	\escapechar=-1~
	\tl_build_gbegin:N \__result
	\cs_set_protected:Npn \__special__stop {
		\tl_build_gend:N \__result
		\endgroup
		\tl_set:Nx #1 {\__result}
		\peek_analysis_map_break:
	}
	\__resume_peek:
	#2
	\__stop
}

}}}


\let\precattlSet\precattl_set:Nn

\cs_new_protected:Npn \precattl_exec:n #1 {
	\precattl_prepare:n {#1}
	\_prctl_valueg
}
\let\precattlExec\precattl_exec:n


\NewDocumentEnvironment{precattlenv}{b}{
	\_prctl_env_helper:n {#1}
}{}

\cs_new_protected:Npn \_prctl_env_helper:n #1 \end #2 {
	\end {#2} \precattl_exec:n {#1}
}