%%% -*- coding: utf-8 -*-
%%% ----------------------------------------------------------------------------
%%% Codehigh : Highlight codes and demos with l3regex and lpeg
%%% Author : Jianrui Lyu <tolvjr@163.com>
%%% Repository: https://github.com/lvjr/codehigh
%%% License : The LaTeX Project Public License 1.3c
%%% ----------------------------------------------------------------------------
%%% -------------------------------------------------------
%%> \section{Variables and Functions}
%%% -------------------------------------------------------
\NeedsTeXFormat{LaTeX2e}
\RequirePackage{expl3}
\ProvidesExplPackage{codehigh}{2023-02-11}{2023A}
{Highlight codes and demos with l3regex and lpeg}
%\RequirePackage{xparse}
%\RequirePackage{l3benchmark}
\RequirePackage{catchfile}
\RequirePackage{xcolor}
\RequirePackage{ninecolors}
\RequirePackage{varwidth}
\RequirePackage{iftex}
\legacy_if:nT {LuaTeX} {\RequirePackage{luatexbase}}
\int_new:N \l__codehigh_a_int
\int_new:N \l__codehigh_b_int
\tl_new:N \l__codehigh_a_tl
\tl_new:N \l__codehigh_b_tl
\tl_new:N \l__codehigh_c_tl
\tl_new:N \l__codehigh_d_tl
\tl_new:N \l__codehigh_m_tl
\cs_generate_variant:Nn \regex_set:Nn {cn}
\cs_generate_variant:Nn \seq_set_split:Nnn {NVV}
\cs_generate_variant:Nn \str_remove_once:Nn {NV}
\cs_generate_variant:Nn \tl_log:n {e}
\cs_generate_variant:Nn \tl_set:Nn {Ne}
\cs_generate_variant:Nn \tl_set_rescan:Nnn {NnV}
\prg_generate_conditional_variant:Nnn \str_if_eq:nn {en} {T, TF}
\prg_generate_conditional_variant:Nnn \regex_extract_once:NnN {NVN, cVN} {T, TF}
\prg_generate_conditional_variant:Nnn \regex_split:NnN {cVN} {T, TF}
\group_begin:
\obeylines
\tl_gset:Nn \g__codehigh_eol_tl {^^M}
\tl_gset:Nn \g__codehigh_eol_eol_tl {^^M^^M}
\group_end:
%%% -------------------------------------------------------
%%> \section{Set CodeHigh Options}
%%% -------------------------------------------------------
\bool_new:N \l__codehigh_lite_bool
\bool_new:N \l__codehigh_long_bool
\bool_new:N \l__codehigh_demo_bool
\NewDocumentCommand \CodeHigh {O{} m}
{
\keys_set:nn {codehigh} {#2}
}
\keys_define:nn {codehigh}
{
lite .bool_set:N = \l__codehigh_lite_bool,
long .bool_set:N = \l__codehigh_long_bool,
demo .bool_set:N = \l__codehigh_demo_bool,
}
%%% -------------------------------------------------------
%%> \section{Environments and Commands}
%%% -------------------------------------------------------
%% Since every codehigh environment has an optional argument,
%% we need to make ^^M active first to keep the leading spaces in the first line
\NewDocumentCommand \NewCodeHighEnv {mm}
{
\exp_args:Nc \NewDocumentCommand {#1} {}
{
%% it is \^^M but not `\^^M
\char_set_catcode_active:N \^^M
\__codehigh_begin:nw {#2}
}
\exp_args:Nc \NewDocumentCommand {end#1} {}
{
\__codehigh_end:
}
}
%% Now we need to replace each ^^M with a space character
\NewDocumentCommand \__codehigh_begin:nw {mO{}}
{
\char_set_catcode_end_line:N \^^M
\tl_set:Nn \l_tmpa_tl {#1,#2}
\__codehigh_replace_endlines:N \l_tmpa_tl
\keys_set:nV {codehigh} \l_tmpa_tl
\tl_set:Ne \__codehigh_collect_end_tl
{
\c_backslash_str end \c_left_brace_str \@currenvir \c_right_brace_str
}
\exp_last_unbraced:NNNNo
\cs_set:Npn \__codehigh_collect:w ##1 \__codehigh_collect_end_tl
{
\__codehigh_store:n {##1}
\exp_args:No \end \@currenvir
}
\group_begin:
\__codehigh_do_specials:
\__codehigh_collect:w
}
\cs_new_protected:Npn \__codehigh_end:
{
\group_end:
\__codehigh_typeset:
}
\group_begin:
\char_set_catcode_active:N \^^M
\cs_new_protected:Npn \__codehigh_replace_endlines:N #1
{
\tl_replace_all:Nnn #1 {^^M} {~}
}
\group_end:
\cs_new_protected:Npn \__codehigh_do_specials:
{
\cs_set_eq:NN \do \char_set_catcode_other:N
\dospecials
\obeylines
\obeyspaces
}
\tl_new:N \g__codehigh_code_tl
\cs_new_protected:Npn \__codehigh_store:n #1
{
\tl_gset:Nn \g__codehigh_code_tl { #1 }
\__codehigh_tracing:nn {code} {\__codehigh_log:N \g__codehigh_code_tl}
}
\cs_new_protected:Npn \__codehigh_typeset:
{
\bool_if:NTF \l__codehigh_demo_bool
{\__codehigh_typeset_demo:} {\__codehigh_typeset_code:}
}
\NewCodeHighEnv {codehigh} {}
\NewCodeHighEnv {demohigh} {demo}
\tl_new:N \l__codehigh_input_tl
\seq_new:N \l__codehigh_input_seq
\NewDocumentCommand \NewCodeHighInput {mm}
{
\NewDocumentCommand #1 {O{}m}
{
\group_begin:
\keys_set:nn {codehigh} {#2, ##1}
\CatchFileDef \l__codehigh_input_tl {##2} {\__codehigh_do_specials:}
\setlength \parskip {0pt plus 1pt}
\__codehigh_typeset_input:N \l__codehigh_input_tl
\group_end:
}
}
\cs_new_protected:Npn \__codehigh_typeset_input:N #1
{
\seq_set_split:NVV \l__codehigh_input_seq \g__codehigh_eol_eol_tl #1
\seq_map_inline:Nn \l__codehigh_input_seq
{
\tl_gset:Nn \g__codehigh_code_tl {##1}
\__codehigh_typeset_comment:N \g__codehigh_code_tl
\tl_if_blank:VF \g__codehigh_code_tl
{
\__codehigh_typeset_code:
\par
\medskip
}
}
}
\regex_const:Nn \l__codehigh_comment_regex { ^ \% \% ( [\%>] ) ( [^\r]+ ) \r }
\tl_new:N \l__codehigh_comment_tl % comment lines that need to be typeset
\bool_new:N \l__codehigh_comment_bool
%% remove lines starting with %%%, and typeset lines starting with %%>
\cs_new_protected:Npn \__codehigh_typeset_comment:N #1
{
\tl_set_eq:NN \l_tmpa_tl #1
\tl_put_right:NV \l_tmpa_tl \g__codehigh_eol_tl
\tl_clear:N \l__codehigh_comment_tl
\bool_set_false:N \l__codehigh_comment_bool
\bool_do_until:Nn \l__codehigh_comment_bool
{
%% Unfortunately we need both \regex_extract_once and \regex_replace_once
\regex_extract_once:NVNTF \l__codehigh_comment_regex \l_tmpa_tl \l_tmpa_seq
{
\regex_replace_once:NnN \l__codehigh_comment_regex {} \l_tmpa_tl
\str_if_eq:enT { \seq_item:Nn \l_tmpa_seq {2} } {>}
{
\tl_put_right:Nx \l__codehigh_comment_tl
{ \seq_item:Nn \l_tmpa_seq {3} }
}
}
{ \bool_set_true:N \l__codehigh_comment_bool }
}
\exp_args:NV \scantokens \l__codehigh_comment_tl
\tl_gset_eq:NN #1 \l_tmpa_tl
}
\NewCodeHighInput \dochighinput {long}
%%% -------------------------------------------------------
%%> \section{Typeset CodeHigh Code}
%%% -------------------------------------------------------
\dim_new:N \l__codehigh_main_boxsep_dim
\keys_define:nn {codehigh}
{
boxsep .dim_set:N = \l__codehigh_main_boxsep_dim,
boxsep .initial:n = 3pt,
}
\box_new:N \g__codehigh_code_box
\cs_new_protected:Npn \__codehigh_typeset_code:
{
\par\addvspace{0.5em}\noindent
\bool_if:NTF \l__codehigh_long_bool
{\__codehigh_typeset_code_text:} {\__codehigh_typeset_code_box:}
\par\addvspace{0.5em}
}
\cs_new_protected:Npn \__codehigh_typeset_code_text:
{
\__codehigh_prepare_code:N \l_tmpa_tl
\__codehigh_get_code_text:n \l_tmpa_tl
}
\cs_new_protected:Npn \__codehigh_typeset_code_box:
{
\__codehigh_build_code:
\__codehigh_put_code_box:
}
\cs_new_protected:Npn \__codehigh_build_code:
{
\__codehigh_prepare_code:N \l_tmpa_tl
\__codehigh_get_code_box:nN \l_tmpa_tl \g__codehigh_code_box
}
\cs_new_protected:Npn \__codehigh_prepare_code:N #1
{
\tl_set_eq:NN #1 \g__codehigh_code_tl
\regex_replace_once:nnN {^ \r} {} #1
\regex_replace_once:nnN {\r $} {} #1
\regex_replace_all:nnN { . } { \c{string} \0 } #1
\tl_set:Nx #1 { #1 }
\__codehigh_tracing:nn {code} {\__codehigh_log:N #1}
}
\cs_new_protected:Npn \__codehigh_put_code_box:
{
\setlength \fboxsep {\l__codehigh_main_boxsep_dim}
\GetCodeHighStyle{main}
\colorbox{codehigh@bg}
{
\hbox_to_wd:nn {\linewidth-2\fboxsep}
{
\GetCodeHighStyle{code}
\colorbox{codehigh@bg}
{\box_use:N \g__codehigh_code_box}
}
}
}
%% #1: text to parse; #2: resulting box
\cs_new_protected:Npn \__codehigh_get_code_box:nN #1 #2
{
\hbox_gset:Nn #2
{
\begin{varwidth}{\linewidth}
\__codehigh_get_code_text:n {#1}
\end{varwidth}
}
}
\cs_new_protected:Npn \__codehigh_get_code_text:n #1
{
\group_begin:
\setlength \parindent {0pt}
\linespread {1}
\ttfamily
\bool_if:NTF \l__codehigh_lite_bool
{\__codehigh_parse_code_lite:N #1}
{\__codehigh_parse_code:VN \l__codehigh_language_name_tl #1}
\group_end:
}
%%% -------------------------------------------------------
%%> \section{Typeset CodeHigh Demo}
%%% -------------------------------------------------------
\box_new:N \g__codehigh_demo_box
\cs_new_protected:Npn \__codehigh_typeset_demo:
{
\__codehigh_build_code:
\__codehigh_build_demo:
\dim_set:Nn \l_tmpa_dim { \box_wd:N \g__codehigh_code_box }
\dim_set:Nn \l_tmpb_dim { \box_wd:N \g__codehigh_demo_box }
\__codehigh_tracing:nn {demo}
{ \tl_log:x { \dim_use:N \l_tmpa_dim + \dim_use:N \l_tmpb_dim } }
\par\addvspace{0.5em}\noindent
\setlength \fboxsep {\l__codehigh_main_boxsep_dim}
\GetCodeHighStyle{main}
\colorbox{codehigh@bg}
{
\dim_compare:nNnTF {\l_tmpa_dim + \l_tmpb_dim + 6\fboxsep} > {\linewidth}
{
\vbox:n
{
\dim_set:Nn \hsize {\linewidth-2\fboxsep}
\noindent\GetCodeHighStyle{code}
\colorbox{codehigh@bg}{\box_use:N \g__codehigh_code_box}
\par
\noindent\GetCodeHighStyle{demo}
\colorbox{codehigh@bg}{\box_use:N \g__codehigh_demo_box}
}
}
{
\hbox_to_wd:nn {\linewidth-2\fboxsep}
{
\GetCodeHighStyle{code}
\colorbox{codehigh@bg}{\box_use:N \g__codehigh_code_box}
\hfill
\GetCodeHighStyle{demo}
\colorbox{codehigh@bg}{\box_use:N \g__codehigh_demo_box}
}
}
}
\par\addvspace{0.5em}
}
\cs_new_protected:Npn \__codehigh_build_demo:
{
\tl_set_eq:NN \l_tmpb_tl \g__codehigh_code_tl
\tl_set_rescan:NnV \l_tmpb_tl
{
\catcode `\% = 14 \relax
\catcode `\^^M = 10 \relax
}
\l_tmpb_tl
\__codehigh_tracing:nn {demo} { \tl_log:N \l_tmpb_tl }
\__codehigh_get_demo_box:nN \l_tmpb_tl \g__codehigh_demo_box
}
%% #1: text to typeset; #2: resulting box
\cs_new_protected:Npn \__codehigh_get_demo_box:nN #1 #2
{
\hbox_gset:Nn #2
{
\dim_set:Nn \linewidth {\linewidth-4\l__codehigh_main_boxsep_dim}
\begin{varwidth}{\linewidth}
\setlength { \parindent } { 0pt }
\linespread {1}
\tl_use:N #1
\end{varwidth}
}
}
%%% -------------------------------------------------------
%%> \section{Add CodeHigh Languages}
%%% -------------------------------------------------------
\keys_define:nn {codehigh}
{
language .tl_set:N = \l__codehigh_language_name_tl,
language .initial:n = latex,
}
%% #1: language name; #2: rule type; #3: rule name; #4: rule regex
\NewDocumentCommand \AddCodeHighRule {O{latex} m m m}
{
\int_if_exist:cF {l__codehigh_#1_rule_count_int}
{\int_new:c {l__codehigh_#1_rule_count_int}}
\int_incr:c {l__codehigh_#1_rule_count_int}
\tl_set:cn
{l__codehigh_#1_ \int_use:c {l__codehigh_#1_rule_count_int} _type_tl} {#2}
\tl_set:cn
{l__codehigh_#1_ \int_use:c {l__codehigh_#1_rule_count_int} _name_tl} {#3}
\regex_set:cn
{l__codehigh_#1_ \int_use:c {l__codehigh_#1_rule_count_int} _regex} {#4}
}
\AddCodeHighRule[latex]{1}{Package} {\\(documentclass|usepackage)}
\AddCodeHighRule[latex]{6}{NewCommand}{\\newcommand}
\AddCodeHighRule[latex]{3}{SetCommand}{\\set[A-Za-z]+}
\AddCodeHighRule[latex]{4}{BeginEnd} {\\(begin|end)}
\AddCodeHighRule[latex]{5}{Section} {\\(part|chapter|section|subsection)}
\AddCodeHighRule[latex]{2}{Command} {\\[A-Za-z]+}
\AddCodeHighRule[latex]{7}{Brace} {[\{\}]}
\AddCodeHighRule[latex]{8}{MathMode} {\$}
\AddCodeHighRule[latex]{9}{Comment} {\%.*?\r}
\AddCodeHighRule[latex/math]{6}{LeftRight} {\\(left|right)}
\AddCodeHighRule[latex/math]{2}{Command} {\\[A-Za-z]+}
\AddCodeHighRule[latex/math]{8}{MathMode} {\$}
\AddCodeHighRule[latex/math]{4}{Script} {[\_\^]}
\AddCodeHighRule[latex/math]{5}{Number} {\d+}
\AddCodeHighRule[latex/math]{1}{Brace} {[\{\}]}
\AddCodeHighRule[latex/math]{7}{Bracket} {[\[\]]}
\AddCodeHighRule[latex/math]{3}{Parenthesis}{[\(\)]}
\AddCodeHighRule[latex/math]{9}{Comment} {\%.*?\r}
\AddCodeHighRule[latex/table]{8}{Newline} {\\\\}
\AddCodeHighRule[latex/table]{1}{Alignment}{\&}
\AddCodeHighRule[latex/table]{6}{BeginEnd} {\\(begin|end)}
\AddCodeHighRule[latex/table]{4}{Command} {\\[A-Za-z]+}
\AddCodeHighRule[latex/table]{2}{Brace} {[\{\}]}
\AddCodeHighRule[latex/table]{3}{Bracket} {[\[\]]}
\AddCodeHighRule[latex/table]{9}{Comment} {\%.*?\r}
\AddCodeHighRule[latex/latex2]{1}{Argument} {\#+\d}
\AddCodeHighRule[latex/latex2]{6}{NewCommand}{\\(|e|g|x)def}
\AddCodeHighRule[latex/latex2]{5}{SetCommand}{\\set[A-Za-z]+}
\AddCodeHighRule[latex/latex2]{4}{PrivateCmd}{\\[A-Za-z@]*@[A-Za-z@]*}
\AddCodeHighRule[latex/latex2]{3}{Command} {\\[A-Za-z]+}
\AddCodeHighRule[latex/latex2]{2}{Brace} {[\{\}]}
\AddCodeHighRule[latex/latex2]{7}{Bracket} {[\[\]]}
\AddCodeHighRule[latex/latex2]{9}{Comment} {\%.*?\r}
\AddCodeHighRule[latex/latex3]{1}{Argument} {\#+\d}
\AddCodeHighRule[latex/latex3]{2}{PrivateVar}{\\[cgl]__[A-Za-z_:@]+}
\AddCodeHighRule[latex/latex3]{5}{PrivateFun}{\\__[A-Za-z_:@]+}
\AddCodeHighRule[latex/latex3]{4}{PublicVar} {\\[cgl]_[A-Za-z_:@]+}
\AddCodeHighRule[latex/latex3]{6}{PublicFun} {\\[A-Za-z_:@]+}
\AddCodeHighRule[latex/latex3]{8}{Brace} {[\{\}]}
\AddCodeHighRule[latex/latex3]{3}{Bracket} {[\[\]]}
\AddCodeHighRule[latex/latex3]{9}{Comment} {\%.*?\r}
%%% -------------------------------------------------------
%%> \section{Add CodeHigh Themes}
%%% -------------------------------------------------------
\keys_define:nn {codehigh}
{
theme .tl_set:N = \l__codehigh_theme_name_tl,
theme .initial:n = default,
style/main .code:n = \SetCodeHighStyle{main}{#1},
style/code .code:n = \SetCodeHighStyle{code}{#1},
style/demo .code:n = \SetCodeHighStyle{demo}{#1},
}
%% #1: theme name; #2: rule type; #3: sytles
\NewDocumentCommand \SetCodeHighStyle {O{default} m m}
{
\tl_set:cn {l__codehigh_style_#1_#2_tl} {#3}
}
\NewDocumentCommand \GetCodeHighStyle {O{default} m}
{
\colorlet{codehigh@bg}{\tl_use:c {l__codehigh_style_#1_#2_tl}}
}
\SetCodeHighStyle[default]{main}{gray9}
\SetCodeHighStyle[default]{code}{gray9}
\SetCodeHighStyle[default]{demo}{white}
\SetCodeHighStyle[default]{0}{black}
\SetCodeHighStyle[default]{1}{brown3}
\SetCodeHighStyle[default]{2}{yellow3}
\SetCodeHighStyle[default]{3}{olive3}
\SetCodeHighStyle[default]{4}{teal3}
\SetCodeHighStyle[default]{5}{azure3}
\SetCodeHighStyle[default]{6}{blue3}
\SetCodeHighStyle[default]{7}{violet3}
\SetCodeHighStyle[default]{8}{purple3}
\SetCodeHighStyle[default]{9}{gray3}
%%% -------------------------------------------------------
%%> \section{Parse and Highlight Code}
%%% -------------------------------------------------------
\int_new:N \l__codehigh_item_count_int
\tl_new:N \l__codehigh_code_to_parse_tl
\tl_new:N \l__codehigh_regex_match_type_tl
\tl_new:N \l__codehigh_regex_match_text_tl
\tl_new:N \l__codehigh_regex_before_text_tl
\cs_new_protected:Npn \__codehigh_parse_code:nN #1 #2
{
\legacy_if:nTF {LuaTeX}
{ \__codehigh_parse_code_luatex:nN {#1} #2 }
{ \__codehigh_parse_code_normal:nN {#1} #2 }
}
\cs_generate_variant:Nn \__codehigh_parse_code:nN {VN}
\cs_new_protected:Npn \__codehigh_parse_code_normal:nN #1 #2
{
\tl_set_eq:NN \l__codehigh_code_to_parse_tl #2
\bool_do_until:nn {\tl_if_empty_p:N \l__codehigh_code_to_parse_tl}
{
\__codehigh_parse_code_once:nN {#1} \l__codehigh_code_to_parse_tl
\int_compare:nNnTF {\l__codehigh_item_count_int} = {-1}
{
\__codehigh_typeset_text:nN {0} \l__codehigh_code_to_parse_tl
\tl_clear:N \l__codehigh_code_to_parse_tl
}
{
\tl_concat:NNN \l__codehigh_a_tl
\l__codehigh_regex_before_text_tl \l__codehigh_regex_match_text_tl
\str_remove_once:NV \l__codehigh_code_to_parse_tl \l__codehigh_a_tl
\__codehigh_tracing:nn {parser}
{\tl_log:N \l__codehigh_code_to_parse_tl}
\__codehigh_typeset_text:nN {0}
\l__codehigh_regex_before_text_tl
\__codehigh_typeset_text:VN \l__codehigh_regex_match_type_tl
\l__codehigh_regex_match_text_tl
}
}
}
\cs_new_protected:Npn \__codehigh_parse_code_once:nN #1 #2
{
\int_set:Nn \l__codehigh_item_count_int { -1 }
\tl_clear:N \l__codehigh_regex_match_text_tl
\tl_clear:N \l__codehigh_regex_before_text_tl
\int_step_inline:nn {\cs:w l__codehigh_#1_rule_count_int \cs_end:}
{
\regex_extract_once:cVNT {l__codehigh_#1_##1_regex} #2 \l_tmpa_seq
{
\seq_get:NN \l_tmpa_seq \l__codehigh_m_tl
\regex_split:cVNT { l__codehigh_#1_##1_regex } #2 \l_tmpb_seq
{
\seq_get:NN \l_tmpb_seq \l__codehigh_b_tl
\tl_set:Nx \l__codehigh_c_tl {\str_count:N \l__codehigh_b_tl}
\bool_lazy_or:nnT
{ \int_compare_p:nNn {\l__codehigh_item_count_int} = {-1} }
{
\int_compare_p:nNn
{\l__codehigh_item_count_int} > {\l__codehigh_c_tl}
}
{
\int_set:Nn \l__codehigh_item_count_int {\l__codehigh_c_tl}
\tl_set_eq:NN \l__codehigh_regex_before_text_tl
\l__codehigh_b_tl
\tl_set_eq:NN \l__codehigh_regex_match_text_tl
\l__codehigh_m_tl
\tl_set_eq:Nc \l__codehigh_regex_match_type_tl
{l__codehigh_#1_##1_type_tl}
}
}
}
}
}
\legacy_if:nT {LuaTeX} { \directlua{require("codehigh.lua")} }
\cs_new_protected:Npn \__codehigh_parse_code_luatex:nN #1 #2
{
\directlua{ParseCode(token.scan_argument(), token.scan_argument())}{#1}{#2}
\__codehigh_tracing:nn {parser}
{\tl_log:N \l__codehigh_parse_code_count_tl}
\int_step_inline:nn {\l__codehigh_parse_code_count_tl}
{
\__codehigh_typeset_text:vc
{l__codehigh_parse_style_##1_tl} {l__codehigh_parse_code_##1_tl}
}
}
%% #1: rule type, #2: text
\cs_new_protected:Npn \__codehigh_typeset_text:nN #1 #2
{
\__codehigh_tracing:nn {parser} { \tl_log:e { type: #1; ~ text: #2 } }
\group_begin:
\regex_replace_all:nnN { \r } { \c{par} \c{leavevmode} } #2
\legacy_if:nF {LuaTeX}
{ \regex_replace_all:nnN { \ } { \c{leavevmode} \c{space} } #2 }
\color{\tl_use:c {l__codehigh_style_ \l__codehigh_theme_name_tl _#1_tl}}
%\obeyspaces
#2
\group_end:
}
\cs_generate_variant:Nn \__codehigh_typeset_text:nN { VN, vc }
%%% -------------------------------------------------------
%%> \section{Don't Highlight Code}
%%% -------------------------------------------------------
\cs_new_protected:Npn \__codehigh_parse_code_lite:N #1
{
\regex_replace_all:nnN { \r } { \c{par} \c{leavevmode} } #1
\regex_replace_all:nnN { \ } { \c{relax} \c{space} } #1
\tl_use:N #1
}
%%% -------------------------------------------------------
%%> \section{Fake Verbatim Command}
%%% -------------------------------------------------------
\tl_new:N \l__codehigh_fake_code_tl
\NewDocumentCommand \fakeverb { +m }
{
\group_begin:
\tl_set:Nn \l__codehigh_fake_code_tl {#1}
\__codehigh_fake_verb:N \l__codehigh_fake_code_tl
\group_end:
}
\cs_new_protected:Npn \__codehigh_fake_verb:N #1
{
\regex_replace_all:nnN { \c{\\} } { \\ } #1
% use \cO to avoid errors of unmatched braces
\regex_replace_all:nnN { \c{\{} } { \cO\{ } #1
\regex_replace_all:nnN { \c{\}} } { \cO\} } #1
% use \cO to avoid doubled hash characters
\regex_replace_all:nnN { \c{\#} } { \cO\# } #1
% need to escape ^ because ^^ and ^^^^ are special
\regex_replace_all:nnN { \c{\^} } { \^ } #1
% why we can not use \c{\ } instead of \c{\h}?
\regex_replace_all:nnN { \c{\h} } { \ } #1
\regex_replace_all:nnN { \c{\%} } { \% } #1
% remove spaces after control words
\regex_replace_all:nnN { . } { \c{string}\0 } #1
\tl_set:Ne #1 { #1 }
%\tl_log:N #1
\ttfamily \frenchspacing \tl_to_str:N #1
}
%%% -------------------------------------------------------
%%> \section{Tracing CodeHigh}
%%% -------------------------------------------------------
\NewDocumentCommand \SetCodeHighTracing { m }
{
\keys_set:nn { codehigh-set-tracing } {#1}
}
\bool_new:N \g__codehigh_tracing_code_bool
\bool_new:N \g__codehigh_tracing_demo_bool
\bool_new:N \g__codehigh_tracing_parser_bool
\keys_define:nn { codehigh-set-tracing }
{
+code .code:n = \bool_gset_true:N \g__codehigh_tracing_code_bool,
-code .code:n = \bool_gset_false:N \g__codehigh_tracing_code_bool,
+demo .code:n = \bool_gset_true:N \g__codehigh_tracing_demo_bool,
-demo .code:n = \bool_gset_false:N \g__codehigh_tracing_demo_bool,
+parser .code:n = \bool_gset_true:N \g__codehigh_tracing_parser_bool,
-parser .code:n = \bool_gset_false:N \g__codehigh_tracing_parser_bool,
all .code:n = \__codehigh_enable_all_tracings:,
none .code:n = \__codehigh_disable_all_tracings:,
}
\cs_new_protected_nopar:Npn \__codehigh_enable_all_tracings:
{
\bool_gset_true:N \g__codehigh_tracing_code_bool
\bool_gset_true:N \g__codehigh_tracing_demo_bool
\bool_gset_true:N \g__codehigh_tracing_parser_bool
}
\cs_new_protected_nopar:Npn \__codehigh_disable_all_tracings:
{
\bool_gset_false:N \g__codehigh_tracing_code_bool
\bool_gset_false:N \g__codehigh_tracing_demo_bool
\bool_gset_false:N \g__codehigh_tracing_parser_bool
}
\cs_new_protected:Npn \__codehigh_tracing:nn #1 #2
{
\bool_if:cT { g__codehigh_tracing_ #1 _bool } {#2}
}
\group_begin:
\char_set_catcode_active:N \^^M
\cs_new_protected:Npn \__codehigh_log:N #1
{
\tl_replace_all:Nnn #1 {^^M} {^^J}
\tl_log:N #1
}
\group_end: