% ----------------------------------------------------------------------------
% the XSIM package
%
% eXercise Sheets IMproved
%
% ----------------------------------------------------------------------------
% Clemens Niederberger
% Web: https://github.com/cgnieder/xsim
% E-Mail: clemens@cnltx.de
% ----------------------------------------------------------------------------
% Copyright 2017--2022 Clemens Niederberger
%
% This work may be distributed and/or modified under the
% conditions of the LaTeX Project Public License, either version 1.3c
% of this license or (at your option) any later version.
% The latest version of this license is in
% http://www.latex-project.org/lppl.txt
% and version 1.3c or later is part of all distributions of LaTeX
% version 2008/05/04 or later.
%
% This work has the LPPL maintenance status `maintained'.
%
% The Current Maintainer of this work is Clemens Niederberger.
% ----------------------------------------------------------------------------
% If you have any ideas, questions, suggestions or bugs to report, please
% feel free to contact me.
% ----------------------------------------------------------------------------
\RequirePackage {l3keys2e,xsimverb}
\ExplSyntaxOn
\tl_const:Nn \c_xsim_date_tl {2022/02/12}
\tl_const:Nn \c_xsim_version_major_number_tl {0}
\tl_const:Nn \c_xsim_version_minor_number_tl {21}
\tl_const:Nn \c_xsim_version_subrelease_tl {}
\tl_const:Nx \c_xsim_version_number_tl
{
\c_xsim_version_major_number_tl .
\c_xsim_version_minor_number_tl
}
\tl_const:Nx \c_xsim_version_tl
{
\c_xsim_version_number_tl
\c_xsim_version_subrelease_tl
}
\tl_const:Nn \c_xsim_info_tl {eXercise ~ Sheets ~ IMproved}
\ProvidesExplPackage
{xsim}
{\c_xsim_date_tl}
{\c_xsim_version_tl}
{\c_xsim_info_tl}
% --------------------------------------------------------------------------
% options, information
\cs_new_protected:Npn \xsim_bool_provide:N #1
{ \bool_if_exist:NF #1 { \bool_new:N #1 } }
\xsim_bool_provide:N \g__xsim_final_bool
\xsim_bool_provide:N \g__xsim_verbose_bool
\xsim_bool_provide:N \g_xsim_clear_aux_bool
\xsim_bool_provide:N \g__xsim_write_to_file_bool
\xsim_bool_provide:N \g_xsim_use_aux_bool
\xsim_bool_provide:N \g__xsim_rerun_bool
\xsim_bool_provide:N \g__xsim_debug_bool
\xsim_bool_provide:N \g__xsim_blank_bool
\keys_define:nn {xsim/package}
{
final .bool_gset:N = \g__xsim_final_bool ,
verbose .bool_gset:N = \g__xsim_verbose_bool ,
debug .bool_gset:N = \g__xsim_debug_bool ,
clear-aux .bool_gset:N = \g_xsim_clear_aux_bool ,
use-files .bool_gset:N = \g__xsim_write_to_file_bool ,
use-files .initial:n = false ,
no-files .choice: ,
no-files / true .meta:n = { use-files = false } ,
no-files / false .meta:n = { use-files = true } ,
no-files .default:n = true ,
use-aux .bool_gset:N = \g_xsim_use_aux_bool ,
use-aux .initial:n = false ,
blank .bool_gset:N = \g__xsim_blank_bool ,
blank .initial:n = false
}
\ProcessKeysPackageOptions {xsim/package}
\keys_define:nn {xsim/package}
{
final .code:n = \msg_error:nnn {xsim} {load-time-option} {final} ,
verbose .code:n = \msg_error:nnn {xsim} {load-time-option} {verbose} ,
debug .code:n = \msg_error:nnn {xsim} {load-time-option} {debug} ,
clear-aux .code:n = \msg_error:nnn {xsim} {load-time-option} {clear-aux} ,
use-files .code:n = \msg_error:nnn {xsim} {load-time-option} {use-files} ,
no-files .code:n = \msg_error:nnn {xsim} {load-time-option} {no-files} ,
use-aux .code:n = \msg_error:nnn {xsim} {load-time-option} {use-aux} ,
blank .code:n = \msg_error:nnn {xsim} {load-time-option} {blank}
}
% --------------------------------------------------------------------------
% messages:
\msg_new:nnn {xsim} {load-time-option}
{
`#1'~ is~ a~ load-time~ option! \\
You~ cannot~ set~ it~ with~ \token_to_str:N \xsimsetup ! \\
You~ need~ to~ use~ \token_to_str:N \usepackage [#1] {xsim} .
}
\msg_new:nnn {xsim} {rerun}
{
Exercise~ properties~ may~ have~ changed.~ Rerun~ to~ get~ them~
synchronized.
}
\msg_new:nnn {xsim} {verbose} { #1 ~( \msg_line_context: ) }
% --------------------------------------------------------------------------
\cs_new_protected:Npn \xsim_do_rerun:
{ \xsim_if_rerun:T { \msg_warning:nn {xsim} {rerun} } }
% --------------------------------------------------------------------------
% MODULE mechanism
\msg_new:nnn {xsim} {module-missing}
{
You've~ requested~ the~ xsim~ module~ `#1'~ but~ it~ appears~ to~
be~ missing~ on~ your~ system.~ Maybe~ you've~ misspelled~ the~ name?~
Loading~ the~ module~ will~ abort~ \msg_line_context:
}
\msg_new:nnn {xsim} {loading-module}
{ Loading~ module~ `#1'~ ... }
\msg_new:nnn {xsim} {wrong-module-name}
{ The~ module~ file~ name~ is~ `#2'~ but~ it~ provides~ module~ `#1'. }
\msg_new:nnn {xsim} {forbidden-module}
{
You've~ requested~ the~ xsim~ module~ `modules'~ \msg_line_context: .~
This~ module~ is~ a~ pseudo~ module~ which~ may~ not~ be~ loaded~ through~
the~ module~ loading~ mechansim.
}
% ----------------------------------------------------------------------------
\cs_generate_variant:Nn \str_if_eq:nnF {xx}
\tl_const:Nn \c__xsim_module_extension_tl {code.tex}
\tl_const:Nn \c__xsim_module_prefix_tl {xsim}
\cs_new_protected:Npn \xsim_load_module:n #1
{
\tl_set:Nx \l_tmpa_tl { \tl_trim_spaces:n {#1} }
\str_if_eq:VnTF \l_tmpa_tl {modules}
{ \msg_error:nn {xsim} {forbidden-module} }
{ \__xsim_load_module:V \l_tmpa_tl }
}
\cs_new_protected:Npn \__xsim_load_module:n #1
{
\xsim_if_module_loaded:nF {#1}
{
\xsim_if_module_exist:nTF {#1}
{
\__xsim_module_hook_use:nn {#1} {before}
\msg_info:nnn {xsim} {loading-module} {#1}
\@onefilewithoptions
{\c__xsim_module_prefix_tl.#1}[][]
\c__xsim_module_extension_tl
\__xsim_module_hook_use:nn {#1} {after}
}
{ \msg_error:nnn {xsim} {module-missing} {#1} }
}
}
\cs_generate_variant:Nn \__xsim_load_module:n {V}
\tl_new:N \g__xsim_modules_loaded_tl
\prg_new_conditional:Npnn \xsim_if_module_loaded:n #1 {p,T,F,TF}
{
\tl_if_in:NnTF \g__xsim_modules_loaded_tl {#1}
{ \prg_return_true: }
{ \prg_return_false: }
}
\prg_new_conditional:Npnn \xsim_if_module_exist:n #1 {p,T,F,TF}
{
\file_if_exist:nTF
{\c__xsim_module_prefix_tl.#1.\c__xsim_module_extension_tl}
{ \prg_return_true: }
{ \prg_return_false: }
}
% --------------------------------------------------------------------------
% module hooks:
% #1: module
% #2: code
\cs_new_protected:Npn \xsim_module_after:nn #1#2
{
\xsim_if_module_loaded:nTF {#1}
{#2}
{ \__xsim_add_to_module_hook:nnn {#1} {after} {#2} }
}
% #1: module
% #2: code
\cs_new_protected:Npn \xsim_module_before:nn #1#2
{
% TODO: error in T case?
\xsim_if_module_loaded:nF {#1}
{ \__xsim_add_to_module_hook:nnn {#1} {before} {#2} }
}
% #1: module
% #2: hook name
% #3: code
\cs_new_protected:Npn \__xsim_add_to_module_hook:nnn #1#2#3
{
\xsim_if_module_loaded:nF {#1}
{
\tl_if_exist:cF {g__xsim_module_hook_#1_#2_tl}
{ \tl_new:c {g__xsim_module_hook_#1_#2_tl} }
\tl_gput_right:cn {g__xsim_module_hook_#1_#2_tl} {#3}
}
}
% #1: module
% #2: hook name
\cs_new_protected:Npn \__xsim_module_hook_use:nn #1#2
{
\tl_if_exist:cT {g__xsim_module_hook_#1_#2_tl}
{
\tl_use:c {g__xsim_module_hook_#1_#2_tl}
\tl_gclear:c {g__xsim_module_hook_#1_#2_tl}
}
}
\cs_generate_variant:Nn \__xsim_module_hook_use:nn {V}
% --------------------------------------------------------------------------
\tl_new:N \l__xsim_module_date_tl
\tl_new:N \l__xsim_module_version_tl
\tl_if_exist:NF \c_xsim_date_tl
{ \tl_set:Nx \l__xsim_module_date_tl {\c_xsimverb_date_tl} }
\tl_if_exist:NF \c_xsim_version_tl
{ \tl_set:Nx \l__xsim_module_version_tl {\c_xsimverb_version_tl} }
\hook_gput_code:nnn {package/xsim/after} {xsim}
{
\tl_set:NV \l__xsim_module_date_tl \c_xsim_date_tl
\tl_set:NV \l__xsim_module_version_tl \c_xsim_version_tl
}
\cs_new_protected:Npn \__xsim_module:nn #1#2
{
\str_if_eq:xxF
{\c__xsim_module_prefix_tl.#1.\c__xsim_module_extension_tl}
{\@currname.\@currext}
{
\msg_error:nnnxx {xsim} {wrong-module-name}
{#1}
{\@currname.\@currext}
}
\ProvidesFile
{\c__xsim_module_prefix_tl.#1.\c__xsim_module_extension_tl}
[
\l__xsim_module_date_tl
\c_space_tl
v \l__xsim_module_version_tl
\c_space_tl
xsim~ module~ `#1'~ (#2)
]
}
\cs_generate_variant:Nn \msg_error:nnnn {nnnx}
% --------------------------------------------------------------------------
% define a xsim module:
% #1: if star: expl3 mode
% #2: name
% #3: description
\NewDocumentCommand \xsimstyle {smO{}}
{
\__xsim_module:nn {style.#2} {#3}
\IfBooleanT {#1} { \ExplSyntaxOn }
}
% \cs_new_protected:Npn \xsim_style_options:nn #1#2
% { \keys_define:nn {xsim/#1} {#2} }
\cs_new_protected:Npn \xsim_load_style:n #1
{ \clist_map_inline:nn {#1} { \xsim_load_module:n {style.##1} } }
\keys_define:nn {xsim}
{ load-style .code:n = \xsim_load_style:n {#1} }
\NewDocumentCommand \loadxsimstyle {m}
{ \xsim_load_style:n {#1} }
% --------------------------------------------------------------------------
% define internal xsim modules:
\tl_new:N \g_xsim_module_tl
\tl_new:N \g__xsim_module_stop_tl
\cs_new_protected:Npn \xsim_stop_module:n #1
{ \tl_gput_right:Nn \g__xsim_module_stop_tl {{#1}} }
% #1: name
% #2: description
\cs_set_protected:Npn \XSIMmodule #1#2
{
\msg_log:nnnn {xsim} {loading-module} {#1} {#2}
\tl_gput_right:Nn \g__xsim_modules_loaded_tl {{#1}}
\tl_gset:Nn \g_xsim_module_tl {#1}
\__xsim_module_hook_use:nn {#1} {before}
\tl_map_inline:Nn \g__xsim_module_stop_tl
{
\str_if_eq:nnT {##1} {#1}
{ \tl_map_break:n { \__xsim_gobble_module:w } }
}
}
\cs_set_protected:Npn \XSIMmoduleend
{ \__xsim_module_hook_use:Vn \g_xsim_module_tl {after} }
\cs_new_protected:Npn \__xsim_gobble_module:w #1 \XSIMmoduleend {}
% --------------------------------------------------------------------------
\XSIMmodule{base}{basic functionality of the package}
% \tl_new:N \g_xsim_end_document_hook_tl
% \tl_new:N \g_xsim_begin_document_hook_tl
% \hook_gput_code:nnn {begindocument} {xsim}
% { \tl_use:N \g_xsim_begin_document_hook_tl }
% \hook_gput_code:nnn {enddocument} {xsim}
% { \tl_use:N \g_xsim_end_document_hook_tl }
% \cs_new_protected:Npn \xsim_at_begin_document:n #1
% { \tl_gput_right:Nn \g_xsim_begin_document_hook_tl {#1} }
% \cs_new_protected:Npn \xsim_at_end_document:n #1
% { \tl_gput_right:Nn \g_xsim_end_document_hook_tl {#1} }
\cs_new_protected:Npn \xsim_at_begin_document:n #1
{ \hook_gput_code:nnn {begindocument} {xsim} {#1} }
\cs_new_protected:Npn \xsim_before_begin_document:n #1
{ \hook_gput_code:nnn {begindocument/before} {xsim} {#1} }
\cs_new_protected:Npn \xsim_at_end_document:n #1
{ \hook_gput_code:nnn {enddocument} {xsim} {#1} }
\cs_new_protected:Npn \xsim_before_end_document:n #1
{ \hook_gput_code:nnn {enddocument/before} {xsim} {#1} }
% ----------------------------------------------------------------------------
% variants of kernel functions:
\cs_generate_variant:Nn \seq_set_split:Nnn {Nnx,NV}
\cs_generate_variant:Nn \seq_gset_split:Nnn {c,cVx,cnx}
\cs_generate_variant:Nn \seq_use:Nn {cV}
\cs_generate_variant:Nn \seq_count:N {c}
\cs_generate_variant:Nn \seq_if_empty:NT {c}
\cs_generate_variant:Nn \seq_if_in:NnT {cV}
\cs_generate_variant:Nn \seq_gremove_all:Nn {cV}
\cs_generate_variant:Nn \seq_gput_right:Nn {cV}
\cs_generate_variant:Nn \seq_set_from_clist:Nn {c,Nx}
\cs_generate_variant:Nn \prop_put:Nnn {Nnx,cxx}
\cs_generate_variant:Nn \prop_gput:Nnn {Nx,Nnx,cxx}
\cs_generate_variant:Nn \prop_item:Nn {c}
\cs_generate_variant:Nn \prop_if_in:NnTF {Nx}
\cs_generate_variant:Nn \use:nn {nx}
\cs_generate_variant:Nn \file_input:n {V,x}
\cs_generate_variant:Nn \file_if_exist:nT {V,x}
\cs_generate_variant:Nn \file_if_exist:nTF {V}
\cs_generate_variant:Nn \file_get_mdfive_hash:nN {V}
\cs_generate_variant:Nn \msg_error:nnnnn {nnnxx}
\cs_generate_variant:Nn \msg_warning:nnn {nnV}
\cs_generate_variant:Nn \keys_define:nn {nx}
\cs_generate_variant:Nn \keys_set:nn {xn,nx}
\cs_generate_variant:Nn \text_titlecase:n {e}
\cs_generate_variant:Nn \tl_if_eq:nnTF {ee,ff,V}
\cs_generate_variant:Nn \tl_if_eq:nnT {x}
\cs_generate_variant:Nn \tl_if_blank:nTF {f,e}
\cs_generate_variant:Nn \tl_set_rescan:Nnn {Nnx}
\cs_generate_variant:Nn \iow_now:Nn {NV}
\cs_generate_variant:Nn \iow_open:Nn {NV}
\cs_generate_variant:Nn \str_if_eq:nnT {x}
\cs_generate_variant:Nn \str_if_eq:nnF {xx}
\cs_generate_variant:Nn \str_if_eq_p:nn {e}
\cs_generate_variant:Nn \prg_new_protected_conditional:Npnn {c}
\cs_generate_variant:Nn \clist_map_inline:nn {V}
% ----------------------------------------------------------------------------
% temporary variables:
\tl_new:N \l__xsim_tmpa_tl
\tl_new:N \l__xsim_tmpb_tl
\tl_new:N \l__xsim_tmpc_tl
\tl_new:N \l__xsim_tmpd_tl
\str_new:N \l__xsim_tmpa_str
\str_new:N \l__xsim_tmpb_str
\str_new:N \l__xsim_tmpc_str
\bool_new:N \l__xsim_tmpa_bool
\bool_new:N \l__xsim_tmpb_bool
\bool_new:N \l__xsim_tmpc_bool
\dim_new:N \l__xsim_tmpa_dim
\dim_new:N \l__xsim_tmpb_dim
\dim_new:N \l__xsim_tmpc_dim
\seq_new:N \l__xsim_tmpa_seq
\seq_new:N \l__xsim_tmpb_seq
\seq_new:N \l__xsim_tmpc_seq
\int_new:N \l__xsim_tmpa_int
\int_new:N \l__xsim_tmpb_int
\int_new:N \l__xsim_tmpc_int
\fp_new:N \l__xsim_tmpa_fp
\fp_new:N \l__xsim_tmpb_fp
\fp_new:N \l__xsim_tmpc_fp
\box_new:N \l__xsim_tmpa_box
\box_new:N \l__xsim_tmpb_box
\box_new:N \l__xsim_tmpc_box
\clist_new:N \l__xsim_tmpa_clist
\clist_new:N \l__xsim_tmpb_clist
\clist_new:N \l__xsim_tmpc_clist
% ----------------------------------------------------------------------------
\prg_new_conditional:Npnn \xsim_if_komascript: {T,F,TF}
{
\cs_if_exist:cTF {KOMAClassName}
{ \prg_return_true: }
{ \prg_return_false: }
}
% ----------------------------------------------------------------------------
\cs_if_exist:NF \xsim_if_final:T
{
\prg_new_conditional:Npnn \xsim_if_final: {p,T,F,TF}
{
\bool_if:NTF \g__xsim_final_bool
{ \prg_return_true: }
{ \prg_return_false: }
}
\prg_new_conditional:Npnn \xsim_if_verbose: {p,T,F,TF}
{
\bool_if:NTF \g__xsim_verbose_bool
{ \prg_return_true: }
{ \prg_return_false: }
}
}
\prg_new_conditional:Npnn \xsim_if_debug: {p,T,F,TF}
{
\bool_if:NTF \g__xsim_debug_bool
{ \prg_return_true: }
{ \prg_return_false: }
}
\prg_new_conditional:Npnn \xsim_if_package_blank: {p,T,F,TF}
{
\bool_if:NTF \g__xsim_blank_bool
{ \prg_return_true: }
{ \prg_return_false: }
}
\prg_new_conditional:Npnn \xsim_if_rerun: {p,T,F,TF}
{
\bool_if:NTF \g__xsim_rerun_bool
{ \prg_return_true: }
{ \prg_return_false: }
}
\prg_new_conditional:Npnn \xsim_if_write_to_files: {p,T,F,TF}
{
\bool_if:NTF \g__xsim_write_to_file_bool
{ \prg_return_true: }
{ \prg_return_false: }
}
\prg_new_conditional:Npnn \xsim_if_clear_aux: {p,T,F,TF}
{
\xsim_if_final:TF
{ \prg_return_false: }
{
\bool_if:NTF \g_xsim_clear_aux_bool
{ \prg_return_true: }
{ \prg_return_false: }
}
}
\cs_if_exist:NF \xsim_verbose:n
{
\cs_new_protected:Npn \xsim_verbose:n #1
{ \xsim_if_verbose:T { \msg_info:nnn {xsim} {verbose} {#1} } }
\cs_generate_variant:Nn \xsim_verbose:n {x}
}
\cs_new_protected:Npn \xsim_rerun:
{ \bool_gset_true:N \g__xsim_rerun_bool }
\prg_new_conditional:Npnn \xsim_if_chapter: {p,T,F,TF}
{
\bool_lazy_and:nnTF
{ \cs_if_exist_p:N \chapter }
{ \cs_if_exist_p:N \c@chapter }
{ \prg_return_true: }
{ \prg_return_false: }
}
% ----------------------------------------------------------------------------
\msg_new:nnn {xsim} {attribute-not-set}
{ The~ attribute~ `#1'~ is~ not~ set~ \msg_line_context: }
% #1: attribute
% #2: item
\cs_new_protected:Npn \xsim_attribute_new:nn #1#2
{ \cs_new:cpn {____xsim_attribute_ \tl_to_str:n {#1::#2} :} {} }
% #1: attribute
% #2: item
% #3: value
\cs_new_protected:Npn \xsim_attribute_set:nnn #1#2#3
{
\cs_gset:cpx
{____xsim_attribute_ \tl_to_str:n {#1::#2} :}
{ \exp_not:n { \exp_not:n {#3} } }
}
\cs_generate_variant:Nn \xsim_attribute_set:nnn {nnx}
% #1: attribute
% #2: item
\cs_new_protected:Npn \xsim_attribute_unset:nn #1#2
{ \cs_undefine:c {____xsim_attribute_ \tl_to_str:n {#1::#2} :} }
% #1: attribute
% #2: item
\cs_new:Npn \xsim_attribute_get:nn #1#2
{
\cs_if_exist:cTF {____xsim_attribute_ \tl_to_str:n {#1::#2} :}
{ \use:c {____xsim_attribute_ \tl_to_str:n {#1::#2} :} }
{
\xsim_if_debug:T
{ \msg_expandable_error:nnn {xsim} {attribute-not-set} {#1::#2} }
}
}
% #1: attribute
% #2: item
\prg_new_conditional:Npnn \xsim_attribute_if_set:nn #1#2 {p,T,F,TF}
{
\cs_if_exist:cTF {____xsim_attribute_ \tl_to_str:n {#1::#2} :}
{ \prg_return_true: }
{ \prg_return_false: }
}
% #1: attribute
% #2: item
\prg_new_conditional:Npnn \__xsim_if_attribute_eq:nnn #1#2#3 {p,T,F,TF}
{
\tl_if_eq:enTF
{ \use:c {____xsim_attribute_ \tl_to_str:n {#1::#2} :} }
{#3}
{ \prg_return_true: }
{ \prg_return_false: }
}
% #1: attribute
% #2: item
\cs_new_protected:Npn \xsim_attribute_show:nn #1#2
{
\iow_term:n {}
\iow_term:x
{
\c_space_tl \c_space_tl
\tl_to_str:n {#1::#2}
\c_space_tl \c_space_tl == \c_space_tl \c_space_tl
{\use:c {____xsim_attribute_ \tl_to_str:n {#1::#2} :}}
}
\iow_term:n {}
}
% ----------------------------------------------------------------------------
\cs_new_protected:Npn \xsim_setup:n #1
{ \keys_set:nn {xsim} {#1} }
\XSIMmoduleend
\XSIMmodule{auxfile}{writing stuff to an auxiliary file}
\prg_new_conditional:Npnn \xsim_if_use_aux: {p,T,F,TF}
{
\bool_if:NTF \g_xsim_use_aux_bool
{ \prg_return_true: }
{ \prg_return_false: }
}
\cs_new_protected:Npn \xsim_write_to_aux:n #1
{
\legacy_if:nT {@filesw}
{
\xsim_if_use_aux:TF
{ \iow_now:Nn \@auxout {#1} }
{ \iow_now:Nn \l__xsim_aux_file_iow {#1} }
}
}
\cs_generate_variant:Nn \xsim_write_to_aux:n {x}
% --------------------------------------------------------------------------
\cs_new_protected:Npn \XSIM #1 { \use:c {XSIMaux#1} }
\cs_new_protected:Npn \xsim_new_aux_property:cpn #1
{ \cs_new_protected:cpn {XSIMaux#1} }
\cs_new_protected:Npn \xsim_add_property_to_aux:nn #1#2
{
\xsim_verbose:n { Writing~ command~ \XSIM {#1}~ to~ aux~ file }
\xsim_write_to_aux:x { \token_to_str:N \XSIM {#1} #2 }
}
\xsim_at_begin_document:n
{
\iow_now:Nx \@auxout
{ \token_to_str:N \providecommand \token_to_str:N \XSIM [1] {} }
}
% ----------------------------------------------------------------------------
\xsim_if_use_aux:F
{
\iow_new:N \l__xsim_aux_file_iow
\tl_new:N \l__xsim_mdfive_hash_tl
\tl_const:Nx \c_xsim_auxfile_tl { \c_sys_jobname_str .xsim }
\hook_gput_code:nnn {begindocument} {xsim}
{
\file_get_mdfive_hash:VN
\c_xsim_auxfile_tl
\l__xsim_mdfive_hash_tl
\iow_open:NV \l__xsim_aux_file_iow \c_xsim_auxfile_tl
}
}
\cs_new_protected:Npn \xsim_close_aux:
{
\xsim_if_use_aux:F
{
\iow_close:N \l__xsim_aux_file_iow
\file_get_mdfive_hash:VN
\c_xsim_auxfile_tl
\l__xsim_tmpa_tl
\tl_if_eq:NNF \l__xsim_mdfive_hash_tl \l__xsim_tmpa_tl { \xsim_rerun: }
\legacy_if:nT {@filesw}
{ \iow_now:Nx \@auxout { \token_to_str:N \XSIM {readaux} } }
}
}
\xsim_new_aux_property:cpn {readaux}
{
\file_if_exist:VT \c_xsim_auxfile_tl
{ \file_input:V \c_xsim_auxfile_tl }
}
% ----------------------------------------------------------------------------
% list for recording values that need to be written to the aux file and
% updated at begin document
\str_new:N \l__xsim_split_aux_lists_str
\keys_define:nn {xsim}
{
split-aux-lists .code:n = \str_set:Nn \l__xsim_split_aux_lists_str {#1} ,
split-aux-lists .initial:n = ||
}
% define list:
% #1: name
\cs_new_protected:Npn \xsim_new_list:n #1
{
\xsim_verbose:n { Defining~ new~ auxfile~ list~ `#1'. }
\seq_new:c {g__xsim_list_#1_seq}
\seq_new:c {g__xsim_list_recorded_#1_seq}
\xsim_new_aux_property:cpn {#1} ##1
{
\tl_if_blank:nF {##1}
{
\seq_gset_split:cVx {g__xsim_list_#1_seq}
\l__xsim_split_aux_lists_str
{ \tl_to_str:n {##1} }
\seq_map_inline:cn {g__xsim_list_#1_seq}
{ \xsim_attribute_set:nnn {#1} {####1} {} }
}
}
\xsim_at_begin_document:n { \xsim_set_list:n {#1} }
}
% #1: name
\cs_new_protected:Npn \xsim_set_list:n #1
{
\seq_gclear:c {g__xsim_list_recorded_#1_seq}
\seq_set_eq:Nc \l__xsim_tmpa_seq {g__xsim_list_#1_seq}
\seq_map_inline:Nn \l__xsim_tmpa_seq
{
\str_set:Nn \l__xsim_tmpa_str {##1}
\seq_gput_right:cV {g__xsim_list_recorded_#1_seq} \l__xsim_tmpa_str
}
\seq_gremove_duplicates:c {g__xsim_list_recorded_#1_seq}
}
% add to or remove from list:
% #1: name
% #2: entry
\cs_new_protected:Npn \xsim_add_to_list:nn #1#2
{
\xsim_verbose:n { Adding~ `#2'~ to~ list~ `#1'. }
\str_set:Nn \l__xsim_tmpa_str {#2}
\xsim_attribute_set:nnn {#1} {#2} {}
\seq_if_in:cVT {g__xsim_list_#1_seq} \l__xsim_tmpa_str
{ \seq_gremove_all:cV {g__xsim_list_#1_seq} \l__xsim_tmpa_str }
\seq_gput_right:cV {g__xsim_list_#1_seq} \l__xsim_tmpa_str
}
\cs_generate_variant:Nn \xsim_add_to_list:nn {nx,nV}
% #1: name
% #2: entry
\cs_new_protected:Npn \xsim_remove_from_list:nn #1#2
{
\xsim_verbose:n { Removing~ `#2'~ to~ list~ `#1'. }
\str_set:Nn \l__xsim_tmpa_str {#2}
\xsim_attribute_if_set:nnT {#1} {#2}
{ \xsim_attribute_unset:nn {#1} {#2} }
\seq_if_in:cVT {g__xsim_list_#1_seq} \l__xsim_tmpa_str
{ \seq_gremove_all:cV {g__xsim_list_#1_seq} \l__xsim_tmpa_str }
\seq_if_in:cVT {g__xsim_list_recorded#1_seq} \l__xsim_tmpa_str
{ \seq_gremove_all:cV {g__xsim_list_recorded_#1_seq} \l__xsim_tmpa_str }
}
\cs_generate_variant:Nn \xsim_remove_from_list:nn {nx}
% check if in list:
% #1: name
% #2: entry
\prg_new_conditional:Npnn \xsim_if_in_list:nn #1#2 {p,T,F,TF}
{
\xsim_attribute_if_set:nnTF {#1} {#2}
{ \prg_return_true: }
{ \prg_return_false: }
}
\prg_generate_conditional_variant:Nnn \xsim_if_in_list:nn {nx} {T,TF}
\bool_new:N \l__xsim_empty_lists_bool
\cs_new_protected:Npn \xsim_empty_lists:
{ \bool_set_true:N \l__xsim_empty_lists_bool }
% update list (should be used inside \xsim_at_end_document:n):
% #1: name
\cs_new_protected:Npn \xsim_update_list:n #1
{
\xsim_verbose:n { Updating~ list~ `#1'. }
\seq_gremove_duplicates:c {g__xsim_list_#1_seq}
\seq_gremove_duplicates:c {g__xsim_list_recorded_#1_seq}
\str_set:Nx \l__xsim_tmpa_str
{ \seq_use:cn {g__xsim_list_#1_seq} {} }
\str_set:Nx \l__xsim_tmpb_str
{ \seq_use:cn {g__xsim_list_recorded_#1_seq} {} }
\str_if_eq:NNF \l__xsim_tmpa_str \l__xsim_tmpb_str
{ \xsim_rerun: }
\bool_if:NF \l__xsim_empty_lists_bool
{
\xsim_add_property_to_aux:nn {#1}
{ { \seq_use:cV {g__xsim_list_#1_seq} \l__xsim_split_aux_lists_str } }
}
}
% loop over list:
% #1: name
% #2: code
\cs_new_protected:Npn \xsim_foreach_list_entry:nn #1#2
{ \seq_map_inline:cn {g__xsim_list_recorded_#1_seq} {#2} }
\cs_new_protected:Npn \xsim_foreach_new_list_entry:nn #1#2
{ \seq_map_inline:cn {g__xsim_list_#1_seq} {#2} }
% length of a list:
% #1: name
\cs_new:Npn \xsim_list_count:n #1
{ \seq_count:c {g__xsim_list_recorded_#1_seq} }
% item of a list:
% #1: name
% #2: integer
\cs_new:Npn \xsim_list_item:nn #1#2
{ \seq_item:cn {g__xsim_list_recorded_#1_seq} {#2} }
\XSIMmoduleend
\XSIMmodule{properties}{properties of exercises}
\msg_new:nnn {xsim} {unknown-property}
{
You~ tried~ to~ set~ the~ property~ `#1'~ \msg_line_context: . \\
This~ property~ does~ not~ exist.~ Check~ for~ a~ typo~ or~ \\
define~ the~ property~ yourself.
}
\msg_new:nnn {xsim} {property-unique}
{
You~ tried~ to~ set~ the~ property~ `#1'~ \msg_line_context: . \\
This~ property~ has~ to~ have~ a~ unique~ value~ and~ thus~ \\
cannot~ be~ set~ to~ `#2'~ since~ this~ value~ is~ already~ taken.
}
\msg_new:nnn {xsim} {no-boolean-property}
{
You~ tried~ to~ check~ the~ boolean~ value~ of~ property~ `#1'~
\msg_line_context: . \\
However,~ property~ `#1'~ is~ not~ a~ boolean~ property!
}
\msg_new:nnn {xsim} {unbalanced-property-list}
{
There~ is~ a~ mis-match~ in~ the~ property~ list: \\
`#1' \\
\msg_line_context:
}
% ----------------------------------------------------------------------------
\seq_new:N \l__xsim_properties_seq
\seq_new:N \l__xsim_boolean_properties_seq
\seq_new:N \l__xsim_unique_properties_seq
\seq_new:N \l__xsim_noupdate_properties_seq
\seq_new:N \l__xsim_given_properties_seq
% #1: type
% #2: id
% #3: property
\cs_new_protected:Npn \__xsim_define_property:nnn #1#2#3
{ \xsim_attribute_new:nn {#1!#2} {#3} }
% check if property is set:
% #1: type
% #2: id
% #3: property
\prg_new_conditional:Npnn \xsim_if_property_set:nnn #1#2#3 {p,T,F,TF}
{
\xsim_attribute_if_set:nnTF {#1!#2} {#3}
{ \prg_return_true: }
{ \prg_return_false: }
}
\prg_generate_conditional_variant:Nnn \xsim_if_property_set:nnn
{ne,nne,ee,nV}
{p,T,F,TF}
% new property:
% #1: boolean if unique
% #2: boolean if boolean
% #3: boolean if noupdate
% #4: property name
\cs_new_protected:Npn \xsim_declare_property:nnnn #1#2#3#4
{
\xsim_if_property_exist:nF {#4}
{
\seq_put_right:Nn \l__xsim_properties_seq {#4}
\bool_if:nTF {#3}
{
\seq_if_in:NnF \l__xsim_noupdate_properties_seq {#4}
{ \seq_put_right:Nn \l__xsim_noupdate_properties_seq {#4} }
}
{ \xsim_new_list:n {#4} }
\bool_if:nTF {#2}
{
\xsim_verbose:n
{ Declaring~ new~ boolean~ exercise~ property~ `#4'. }
\seq_if_in:NnF \l__xsim_boolean_properties_seq {#4}
{ \seq_put_right:Nn \l__xsim_boolean_properties_seq {#4} }
}
{
\bool_if:nTF {#1}
{
\xsim_verbose:n
{ Declaring~ new~ unique~ exercise~ property~ `#4'. }
\seq_if_in:NnF \l__xsim_unique_properties_seq {#4}
{ \seq_put_right:Nn \l__xsim_unique_properties_seq {#4} }
\seq_new:c {l__xsim_unique_property_#4_values_seq}
}
{ \xsim_verbose:n { Declaring~ new~ exercise~ property~ `#4'. } }
}
\bool_if:nF {#3}
{
\xsim_at_end_document:n { \xsim_update_list:n {#4} }
\xsim_at_begin_document:n { \__xsim_set_property_from_list:n {#4} }
}
}
}
% ----------------------------------------------------------------------------
% check if property exists:
\prg_new_conditional:Npnn \xsim_if_property_exist:n #1 {p,T,F,TF}
{
\seq_if_in:NnTF \l__xsim_properties_seq {#1}
{ \prg_return_true: }
{ \prg_return_false: }
}
\cs_generate_variant:Nn \xsim_if_property_exist:nTF {x}
\prg_new_conditional:Npnn \xsim_if_property_noupdate:n #1 {p,T,F,TF}
{
\seq_if_in:NnTF \l__xsim_noupdate_properties_seq {#1}
{ \prg_return_true: }
{ \prg_return_false: }
}
\cs_generate_variant:Nn \xsim_if_property_noupdate:nF {V}
\prg_new_conditional:Npnn \xsim_if_property_boolean:n #1 {p,T,F,TF}
{
\seq_if_in:NnTF \l__xsim_boolean_properties_seq {#1}
{ \prg_return_true: }
{ \prg_return_false: }
}
\prg_new_conditional:Npnn \xsim_if_property_unique:n #1 {p,T,F,TF}
{
\seq_if_in:NnTF \l__xsim_unique_properties_seq {#1}
{ \prg_return_true: }
{ \prg_return_false: }
}
% true if property #1 has been set in the /last/ call of
% \xsim_set_properties:nnn
\prg_new_conditional:Npnn \xsim_if_property_given:n #1 {p,T,F,TF}
{
\seq_if_in:NnTF \l__xsim_given_properties_seq {#1}
{ \prg_return_true: }
{ \prg_return_false: }
}
% #1: property
% #2: value
\prg_new_conditional:Npnn \xsim_if_property_unique_value:nn #1#2 {p,T,F,TF}
{
\xsim_if_property_unique:nTF {#1}
{
\seq_if_in:cnTF {l__xsim_unique_property_#1_values_seq} {#2}
{ \prg_return_true: }
{ \prg_return_false: }
}
{ \prg_return_false: }
}
% #1: code
\cs_new_protected:Npn \xsim_foreach_property:n #1
{ \seq_map_inline:Nn \l__xsim_properties_seq {#1} }
% ----------------------------------------------------------------------------
% #1: type
% #2: id
% #3: property
% #4: value
\cs_new_protected:Npn \xsim_set_property:nnnn #1#2#3#4
{
\xsim_if_property_unique:nTF {#3}
{
\xsim_if_property_unique_value:nnTF {#3} {#4}
{ \msg_warning:nnnn {xsim} {property-unique} {#3} {#4} }
{ \__xsim_set_unique_property:nnnn {#1} {#2} {#3} {#4} }
}
{
\xsim_if_property_boolean:nTF {#3}
{ \__xsim_set_boolean_property:nnnn {#1} {#2} {#3} {#4} }
{ \__xsim_set_property:nnnn {#1} {#2} {#3} {#4} }
}
}
\cs_generate_variant:Nn \xsim_set_property:nnnn {nnee,nnnV,nV,nVne,nnne,ee,eene,nene}
% #1: type
% #2: id
% #3: property
% #4: value
\cs_new_protected:Npn \__xsim_set_boolean_property:nnnn #1#2#3#4
{
\str_case_e:nnTF { \str_lowercase:n {#4} }
{
{} {}
{true} {}
}
{ \__xsim_set_property:nnnn {#1} {#2} {#3} {true} }
{ \__xsim_set_property:nnnn {#1} {#2} {#3} {false} }
}
% #1: type
% #2: id
% #3: property
% #4: value
\cs_new_protected:Npn \__xsim_set_unique_property:nnnn #1#2#3#4
{
\__xsim_set_property:nnnn {#1} {#2} {#3} {#4}
\__xsim_set_property_reverse:nnnn {#1} {#2} {#3} {#4}
}
% #1: type
% #2: id
% #3: property
\cs_new_protected:Npn \__xsim_unset_property:nnn #1#2#3
{
\xsim_verbose:n
{ Un-setting~ property~ `#3'~ of~ exercise~ type~ `#1'~ id~ `#2'. }
\xsim_if_property_noupdate:nF {#3}
{ \__xsim_remove_property_from_list:nnn {#1} {#2} {#3} }
\xsim_attribute_unset:nn {#1!#2} {#3}
}
% #1: type
% #2: id
% #3: property
\cs_new_protected:Npn \xsim_unset_property:nnn #1#2#3
{
\xsim_if_property_exist:nTF {#3}
{ \__xsim_unset_property:nnn {#1} {#2} {#3} }
{ \msg_error:nnn {xsim} {unknown-property} {#3} }
}
\cs_generate_variant:Nn \xsim_unset_property:nnn {nx,nnx,nV}
% #1: type
% #2: id
% #3: property
% #4: value
\cs_new_protected:Npn \__xsim_set_property:nnnn #1#2#3#4
{
\xsim_verbose:n
{
Setting~ property~ `#3'~ of~ exercise~ type~ `#1'~ id~ `#2'~ to~
value~ `#4'.
}
\xsim_if_property_noupdate:nF {#3}
{
\__xsim_remove_property_from_list:nnn {#1} {#2} {#3}
\xsim_add_to_list:nn {#3} {#1-#2=={#4}}
}
\xsim_attribute_set:nnn {#1!#2} {#3} {#4}
}
\cs_generate_variant:Nn \__xsim_set_property:nnnn {VVnV}
% #1: type
% #2: id
% #3: property
% #4: value
\cs_new_protected:Npn \__xsim_set_property_reverse:nnnn #1#2#3#4
{
\xsim_attribute_set:nnn {type:#3} {#4} {#1}
\xsim_attribute_set:nnn {id:#3} {#4} {#2}
}
\tl_set:Nx \l__xsim_tmpa_tl { \cs_to_str:N \{ }
\tl_set:Nx \l__xsim_tmpb_tl { \cs_to_str:N \} }
\use:x
{
\cs_new_protected:Npn
\exp_not:N \__xsim_extract_property_list_entry:NNNwww
##1##2##3##4-##5== \l__xsim_tmpa_tl ##6 \l__xsim_tmpb_tl
\exp_not:N \q_stop
}
{
\str_set:Nn #1 {#4}
\str_set:Nn #2 {#5}
\str_set:Nn #3 {#6}
}
% #1: type
% #2: id
% #3: property
\cs_new_protected:Npn \__xsim_remove_property_from_list:nnn #1#2#3
{
% make sure we change the entry if it has been recorded previously:
\xsim_foreach_list_entry:nn {#3}
{
\__xsim_extract_property_list_entry:NNNwww
\l__xsim_tmpa_str \l__xsim_tmpb_str \l__xsim_tmpc_str ##1 \q_stop
\str_if_eq:xnT { \l__xsim_tmpa_str - \l__xsim_tmpb_str } {#1-#2}
{
\xsim_remove_from_list:nx {#3}
{ #1-#2 == {\l__xsim_tmpc_str} }
}
}
% make sure we change the entry if it has been set during the current run:
\xsim_foreach_new_list_entry:nn {#3}
{
\__xsim_extract_property_list_entry:NNNwww
\l__xsim_tmpa_str \l__xsim_tmpb_str \l__xsim_tmpc_str ##1 \q_stop
\str_if_eq:xnT { \l__xsim_tmpa_str - \l__xsim_tmpb_str } {#1-#2}
{
\xsim_remove_from_list:nx {#3}
{ #1-#2 == {\l__xsim_tmpc_str} }
}
}
}
\seq_new:N \g_xsim_used_order_seq
\seq_new:N \g_xsim_printed_order_seq
\cs_new_protected:Npn \__xsim_set_property_from_list:n #1
{
\xsim_foreach_list_entry:nn {#1}
{
\__xsim_extract_property_list_entry:NNNwww
\l__xsim_tmpa_str \l__xsim_tmpb_str \l__xsim_tmpc_str ##1 \q_stop
\tl_set_rescan:Nnx \l__xsim_tmpa_tl {} { \l__xsim_tmpa_str }
\tl_set_rescan:Nnx \l__xsim_tmpb_tl {} { \l__xsim_tmpb_str }
\tl_set_rescan:Nnx \l__xsim_tmpc_tl {} { \l__xsim_tmpc_str }
\str_if_eq:nnT {#1} {used}
{
\str_if_eq:VnT \l__xsim_tmpc_str {true}
{
\seq_gput_right:Nx \g_xsim_used_order_seq
{ \l__xsim_tmpa_tl - \l__xsim_tmpb_tl }
}
}
\str_if_eq:nnT {#1} {printed}
{
\str_if_eq:VnT \l__xsim_tmpc_str {true}
{
\seq_gput_right:Nx \g_xsim_printed_order_seq
{ \l__xsim_tmpa_tl - \l__xsim_tmpb_tl }
}
}
\__xsim_set_property:VVnV
\l__xsim_tmpa_str
\l__xsim_tmpb_str
{#1}
\l__xsim_tmpc_tl
}
}
% set properties:
% #1: type
% #2: id
% #3: csv list of properties
\cs_new_protected:Npn \xsim_set_properties:nnn #1#2#3
{
\cs_set_protected:Npn \__xsim_tmp:n ##1
{ \xsim_set_property:nnnn {#1} {#2} {##1} {} }
\cs_set_protected:Npn \__xsim_tmp:nn ##1##2
{ \xsim_set_property:nnnn {#1} {#2} {##1} {##2} }
\keyval_parse:NNn
\__xsim_tmp:n
\__xsim_tmp:nn
{#3}
\xsim_property_set_aliases:nn {#1} {#2}
}
\cs_generate_variant:Nn \xsim_set_properties:nnn {nne,nee,nV,nVe}
% ----------------------------------------------------------------------------
\seq_new:N \g__xsim_property_aliases_seq
% #1: property
\prg_new_conditional:Npnn \xsim_if_property_alias:n #1 {p,T,F,TF}
{
\seq_if_in:NnTF \g__xsim_property_aliases_seq {#1}
{ \prg_return_true: }
{ \prg_return_false: }
}
% #1: property
\cs_new:Npn \xsim_property_alias:n #1
{ \xsim_attribute_get:nn {#1} {alias} }
% #1: property
% #2: alias of
\cs_new_protected:Npn \xsim_make_property_alias:nn #1#2
{
\xsim_if_property_alias:nF {#1}
{
\xsim_verbose:n
{ Making~ property~ `#1'~ an~ alias~ of~ property~ `#2'. }
\xsim_attribute_set:nnn {#1} {alias} {#2}
\seq_gput_right:Nn \g__xsim_property_aliases_seq {#1}
}
}
% #1: type
% #2: id
% #3: property
\cs_new_protected:Npn \xsim_property_set_alias:nnn #1#2#3
{
\xsim_if_property_set:nneT {#1} {#2}
{ \xsim_property_alias:n {#3} }
{
\xsim_attribute_set:nnx {alias:#1!#2} {#3}
{
\xsim_get_property:nnf {#1} {#2}
{ \xsim_property_alias:n {#3} }
}
\xsim_if_property_set:nnnF {#1} {#2} {#3}
{
\xsim_set_property:nnne {#1} {#2} {#3}
{
\xsim_get_property:nnf {#1} {#2}
{ \xsim_property_alias:n {#3} }
}
}
}
}
\cs_generate_variant:Nn \xsim_property_set_alias:nnn {nV}
% #1: type
% #2: id
\cs_new_protected:Npn \xsim_property_set_aliases:nn #1#2
{
\seq_map_inline:Nn \g__xsim_property_aliases_seq
{ \xsim_property_set_alias:nnn {#1} {#2} {##1} }
}
% ----------------------------------------------------------------------------
% retrieve properties:
% #1: type
% #2: id
% #3: property
\cs_new:Npn \xsim_get_property:nnn #1#2#3
{ \xsim_attribute_get:nn {#1!#2} {#3} }
\cs_generate_variant:Nn \xsim_get_property:nnn {nx,ne,xx,oo,no,nnf,nf,oof,nV}
% #1: type
% #2: id
% #3: property
\cs_new:Npn \xsim_show_property:nnn #1#2#3
{ \xsim_attribute_show:nn {#1!#2} {#3} }
% #1: property
% #2: value
\cs_new:Npn \xsim_get_id_for_property:nn #1#2
{ \xsim_attribute_get:nn {id:#1} {#2} }
% #1: ID
% #2: variable
\cs_new_protected:Npn \xsim_get_type_for_id:nN #1#2
{
\xsim_foreach_list_entry:nn {idtypes}
{
\__xsim_extract_property_list_entry:NNNwww
\l__xsim_tmpa_str \l__xsim_tmpb_str \l__xsim_tmpc_str -##1 \q_stop
\str_if_eq:VnT \l__xsim_tmpb_str {#1}
{
\str_set_eq:NN #2 \l__xsim_tmpc_str
\seq_map_break:
}
}
}
% #1: property
% #2: value
\cs_new:Npn \xsim_get_type_for_property:nn #1#2
{ \xsim_attribute_get:nn {type:#1} {#2} }
\cs_generate_variant:Nn \xsim_get_type_for_property:nn {nV}
% #1: id or ID
\cs_new:Npn \xsim_normalize_id:n #1
{
\tl_if_blank:eTF
{ \xsim_get_id_for_property:nn {ID} {#1} }
{#1}
{ \xsim_get_id_for_property:nn {ID} {#1} }
}
\cs_generate_variant:Nn \xsim_normalize_id:n {e}
\tl_new:N \l_xsim_property_value_tl
\tl_new:N \PropertyValue
\cs_new:Npn \__xsim_tmp:n #1 {#1}
\cs_generate_variant:Nn \__xsim_tmp:n {V}
% #1: type
% #2: id
% #3: property
\cs_new_protected:Npn \xsim_get_property_if_set:nnnTF #1#2#3#4#5
{
\xsim_if_property_exist:nTF {#3}
{
\xsim_if_property_set:nnnTF {#1} {#2} {#3}
{
\tl_set:Nx \l_xsim_property_value_tl
{ \xsim_get_property:nnn {#1} {#2} {#3} }
\tl_set_eq:NN \PropertyValue \l_xsim_property_value_tl
\cs_set:Npn \__xsim_tmp:n ##1 {#4}
\__xsim_tmp:V \l_xsim_property_value_tl
}
{#5}
}
{ \msg_error:nnn {xsim} {unknown-property} {#3} }
}
\cs_generate_variant:Nn \xsim_get_property_if_set:nnnTF {oo}
\cs_new_protected:Npn \xsim_get_property_if_set:nnnT #1#2#3#4
{ \xsim_get_property_if_set:nnnTF {#1} {#2} {#3} {#4} {} }
\cs_new_protected:Npn \xsim_get_property_if_set:nnnF #1#2#3#4
{ \xsim_get_property_if_set:nnnTF {#1} {#2} {#3} {} {#4} }
% #1: type
% #2: id
% #3: property
\prg_new_conditional:Npnn \xsim_if_boolean_property:nnn #1#2#3 {T,F,TF}
{
\xsim_if_property_exist:nTF {#3}
{
\xsim_if_property_boolean:nTF {#3}
{
\xsim_if_property_set:nnnTF {#1} {#2} {#3}
{
\bool_if:cTF
{c_ \xsim_get_property:nnn {#1} {#2} {#3} _bool}
{ \prg_return_true: }
{ \prg_return_false: }
}
{ \prg_return_false: }
}
{ \msg_error:nnn {xsim} {no-boolean-property} {#3} }
}
{ \msg_error:nnn {xsim} {unknown-property} {#3} }
}
\prg_generate_conditional_variant:Nnn \xsim_if_boolean_property:nnn {oo,nV} {T,F,TF}
\cs_new_protected:Npn \xsim_save_property:nnnN #1#2#3#4
{ \tl_set:Nx #4 { \xsim_get_property:nnn {#1} {#2} {#3} } }
\cs_generate_variant:Nn \xsim_save_property:nnnN {nx,xx}
\cs_new_protected:Npn \xsim_gsave_property:nnnN #1#2#3#4
{
\xsim_save_property:nnnN {#1} {#2} {#3} #4
\tl_gset:NV #4 #4
}
\cs_generate_variant:Nn \xsim_gsave_property:nnnN {nx,xx,nV}
\XSIMmoduleend
\XSIMmodule{environments}{generic code for exercise and solution environments}
\xsim_if_write_to_files:F
{
\xsim_declare_property:nnnn
{ \c_false_bool }
{ \c_false_bool }
{ \c_false_bool }
{solution-body}
\xsim_declare_property:nnnn
{ \c_false_bool }
{ \c_false_bool }
{ \c_false_bool }
{exercise-body}
}
\tl_new:N \l__xsim_file_name_signature_tl
\tl_new:N \l_xsim_file_path_tl
\tl_new:N \l_xsim_file_path_and_name_tl
\tl_new:N \l_xsim_file_name_tl
\tl_new:N \l__xsim_file_extension_tl
\bool_new:N \l__xsim_options_given_bool
\bool_new:N \l__xsim_insert_mode_bool
\tl_new:N \ExerciseText
\tl_set:Nn \ExerciseText { \msg_error:nn {xsim} {only-in-solution} }
% ----------------------------------------------------------------------------
\msg_new:nnn {xsim} {only-in-solution}
{
You~ can't~ use~ \token_to_str:N \ExerciseText \c_space_tl inside~ an~
exercise.~ It~ is~ only~ allowed~ inside~ solution~ environments!
}
% ----------------------------------------------------------------------------
\keys_define:nn {xsim}
{
path .tl_set:N = \l_xsim_file_path_tl ,
file-extension .tl_set:N = \l__xsim_file_extension_tl ,
file-extension .initial:n = tex
}
% ----------------------------------------------------------------------------
\tl_const:Nn \c__xsim_comment_line_tl { \c__xsim_percent_char_tl }
\tl_const:Nn \c__xsim_comment_line_fill_tl { \prg_replicate:nn {72} {-} }
\tl_const:Nn \c__xsim_comment_line_indent_tl { \c_space_tl \c_space_tl }
\cs_new:Npn \__xsim_comment_line_and_feed:n #1
{ \__xsim_comment_line:n {#1} ^^J }
\cs_new:Npn \__xsim_comment_line:n #1
{
\c__xsim_comment_line_tl
\tl_if_blank:nF {#1} { \c_space_tl }
#1
}
\cs_new:Npn \__xsim_two_digits:n #1
{ \int_compare:nT { #1 < 10 } {0} \int_eval:n {#1} }
% #1: type
% #2: id
% #3: exercise|solution
\cs_new_protected:Npn \xsim_set_file_signature:nnn #1#2#3
{ \tl_set:Nn \l__xsim_file_name_signature_tl {#1-#2-#3} }
\cs_generate_variant:Nn \xsim_set_file_signature:nnn {nx,nV}
\tl_set:Nn \l_xsim_file_name_tl
{ \c_sys_jobname_str - \l__xsim_file_name_signature_tl -body . \l__xsim_file_extension_tl }
\tl_set:Nn \l_xsim_file_path_and_name_tl
{
\tl_if_blank:VF \l_xsim_file_path_tl
{ \l_xsim_file_path_tl / }
\l_xsim_file_name_tl
}
% #1: type
% #2: id
% #3: exercise|solution
% #4: file name
% #5: path
\cs_new_protected:Npn \__xsim_file_info:nnnnn #1#2#3#4#5
{
\tl_set:Nx \l_xsim_file_begin_tl
{
\__xsim_comment_line_and_feed:n { \c__xsim_comment_line_fill_tl }
\__xsim_comment_line_and_feed:n {file~ `#4'}
\tl_if_blank:nF {#5}
{
\__xsim_comment_line_and_feed:n
{ \c__xsim_comment_line_indent_tl in~ folder~ `#5/'}
}
\__xsim_comment_line_and_feed:n {}
\__xsim_comment_line_and_feed:n
{
\c__xsim_comment_line_indent_tl
\c__xsim_comment_line_indent_tl
#3~ of~ type~ `#1'~ with~ id~ `#2'
}
\__xsim_comment_line_and_feed:n {}
\__xsim_comment_line_and_feed:n
{generated~ by~ the~ `\@currenvir'~ environment~ of~ the}
\__xsim_comment_line_and_feed:n
{
\c__xsim_comment_line_indent_tl
`xsim'~ package~ v \c_xsim_version_tl
\c_space_tl (\c_xsim_date_tl)
}
\__xsim_comment_line_and_feed:n
{
from~ source~ `\c_sys_jobname_str'~ on~
\int_use:N \c_sys_year_int /
\__xsim_two_digits:n { \c_sys_month_int } /
\__xsim_two_digits:n { \c_sys_day_int } ~
\msg_line_context:
}
\__xsim_comment_line:n { \c__xsim_comment_line_fill_tl }
}
}
\cs_generate_variant:Nn \__xsim_file_info:nnnnn {nnnVV}
% ----------------------------------------------------------------------------
% #1: type
% #2: id
% #3: exercise|solution
% #4: potential environment body
\cs_new_protected:Npn \xsim_save_environment_body:nnnn #1#2#3#4
{
\xsim_if_write_to_files:TF
{ \__xsim_write_environment_body:nnn {#1} {#2} {#3} }
{ \__xsim_save_environment_body:nnnn {#1} {#2} {#3} {#4} }
}
\cs_new_protected:Npn \xsim_save_environment_body_end:
{
\xsim_if_write_to_files:TF
{ \__xsim_write_environment_body_end: }
{ \__xsim_save_environment_body_end: }
}
% writing to files:
% #1: type
% #2: id
% #3: exercise|solution
\cs_new_protected:Npn \__xsim_write_environment_body:nnn #1#2#3
{
\xsim_verbose:n
{ Starting~ to~ write~ #3~ environment~ type~ `#1'~ id~ `#2' }
\xsim_set_file_signature:nnn {#1} {#2} {#3}
\__xsim_file_info:nnnVV {#1} {#2} {#3}
\l_xsim_file_name_tl
\l_xsim_file_path_tl
\int_zero:N \l_xsim_line_gobble_int
\xsim_file_write_start:nV
{ \l__xsim_options_given_bool }
\l_xsim_file_path_and_name_tl
}
\cs_new_protected:Npn \__xsim_write_environment_body_end:
{ \xsim_file_write_stop: }
% saving to property lists:
% #1: type
% #2: id
% #3: exercise|solution
% #4: environment body
\cs_new_protected:Npn \__xsim_save_environment_body:nnnn #1#2#3#4
{
\xsim_verbose:n { Saving~ #3~ environment~ type~ `#1'~ id~ `#2' }
\xsim_set_property:nnnn {#1} {#2} {#3-body} {#4}
\xsim_if_exchange:nnnT {#1} {#2} {#3}
{
\tl_if_eq:nnT {#3} {exercise}
{ \xsim_set_property:nnnn {#1} {#2} {solution-body} {#4} }
}
}
\cs_new:Npn \__xsim_save_environment_body_end: { }
% ----------------------------------------------------------------------------
% #1: type
% #2: exercise|solution
% #3: hook
\cs_new_protected:Npn \xsim_new_hook:nnn #1#2#3
{
\xsim_verbose:n { Defining~ new~ #1~ (#2)~ hook~ `#3' }
\tl_new:c {l__xsim_#1_#2_#3_hook_tl}
\keys_define:nx {xsim}
{
\xsim_get_parameter:nn {#1} {#2-env}/#3-hook .tl_set:N =
\exp_not:c {l__xsim_#1_#2_#3_hook_tl}
}
}
% #1: type
% #2: exercise|solution
% #3: hook
\cs_new:Npn \xsim_use_hook:nnn #1#2#3
{ \exp_not:v {l__xsim_#1_#2_#3_hook_tl} }
% #1: type
% #2: exercise|solution
% #3: hook
% #4: code
\cs_new_protected:Npn \xsim_set_hook:nnnn #1#2#3#4
{
\xsim_verbose:n { Setting~ #1~ (#2)~ hook~ `#3' }
\tl_set:cn {l__xsim_#1_#2_#3_hook_tl} {#4}
}
% #1: type
% #2: exercise|solution
% #3: hook
% #4: code
\cs_new_protected:Npn \xsim_addto_hook:nnnn #1#2#3#4
{
\xsim_verbose:n { Adding~ to~ #1~ (#2)~ hook~ `#3' }
\tl_put_right:cn {l__xsim_#1_#2_#3_hook_tl} {#4}
}
% ----------------------------------------------------------------------------
% #1: type
% #2: id
% #3: exercise|solution
% #4: potential enironment body
\cs_new_protected:Npn \xsim_start_environment:nnnn #1#2#3#4
{ \xsim_save_environment_body:nnnn {#1} {#2} {#3} {#4} }
\cs_generate_variant:Nn \xsim_start_environment:nnnn {nV}
% #1: type
% #2: id
% #3: exercise|solution
\cs_new_protected:Npn \xsim_stop_environment:nnn #1#2#3
{
\xsim_save_environment_body_end:
\xsim_if_print:nnnTF {#1} {#2} {#3}
{ \xsim_typeset_environment:nnn {#1} {#2} {#3} }
{ \xsim_use_hook:nnn {#1} {#3} {print-false} }
}
\cs_generate_variant:Nn \xsim_stop_environment:nnn {nV}
% #1: type
% #2: id
% #3: exercise|solution
\cs_new_protected:Npn \xsim_typeset_environment:nnn #1#2#3
{
\tl_set:Nn \ExerciseType {#1}
\tl_set:Nn \ExerciseID {#2}
\xsim_verbose:n
{ Typesetting~ #3~ environment~ type~ `#1'~ id~ `#2' }
\xsim_use_hook:nnn {#1} {#3} {pre}
\xsim_use_template:nx
{begin}
{ \xsim_get_parameter:nn {#1} {#3-template} }
\xsim_use_hook:nnn {#1} {#3} {begin}
\xsim_input:nnn {#1} {#2} {#3}
\xsim_use_hook:nnn {#1} {#3} {end}
\xsim_use_template:nx
{end}
{ \xsim_get_parameter:nn {#1} {#3-template} }
\xsim_use_hook:nnn {#1} {#3} {post}
}
% #1: type
% #2: id
% #3: exercise|solution
\prg_new_conditional:Npnn \xsim_if_exchange:nnn #1#2#3 {T,F,TF}
{
\str_if_eq:nnTF {#3} {solution}
{
\xsim_if_boolean_property:nnnTF {#1} {#2} {solution}
{ \prg_return_true: }
{ \prg_return_false: }
}
{ \prg_return_false: }
}
% #1: type
% #2: id
% #3: exercise|solution
\prg_new_protected_conditional:Npnn \xsim_if_exist:nnn #1#2#3 {T,F,TF}
{
\xsim_if_write_to_files:TF
{
\xsim_if_exchange:nnnTF {#1} {#2} {#3}
{ \xsim_set_file_signature:nnn {#1} {#2} {exercise} }
{ \xsim_set_file_signature:nnn {#1} {#2} {#3} }
\file_if_exist:VTF \l_xsim_file_path_and_name_tl
{ \prg_return_true: }
{ \prg_return_false: }
}
{
\xsim_if_property_exist:nTF {#3-body}
{
\xsim_if_property_set:nnnTF {#1} {#2} {#3-body}
{ \prg_return_true: }
{ \prg_return_false: }
}
{ \prg_return_false: }
}
}
% #1: type
% #2: id
% #3: options
% #4: exercise|solution
\cs_new_protected:Npn \xsim_insert:nnnn #1#2#3#4
{
\xsim_if_exist:nnnT {#1} {#2} {#4}
{
\xsim_verbose:n
{ Inserting~ #4~ type~ `#1'~ id~ `#2'. }
\group_begin:
\xsim_insert_mode:
\tl_gset:Nx \g_xsim_exercise_id_tl {#2}
\tl_gset:Nn \g_xsim_exercise_type_tl {#1}
\use:c {xsim_start_#4:nn} {#1} {#3}
\xsim_typeset_environment:nnn {#1} {#2} {#4}
\use:c {xsim_stop_#4:n} {#1} {}
\group_end:
}
}
\cs_generate_variant:Nn \xsim_insert:nnnn {nV,VV,nnnV,xx,ne}
% #1: type
% #2: id
% #3: exercise|solution
\cs_new_protected:Npn \xsim_input:nnn #1#2#3
{
\xsim_if_exchange:nnnTF {#1} {#2} {#3}
{ \xsim_set_file_signature:nnn {#1} {#2} {exercise} }
{ \xsim_set_file_signature:nnn {#1} {#2} {#3} }
\xsim_if_write_to_files:TF
{
\file_if_exist:VTF \l_xsim_file_path_and_name_tl
{ \file_input:V \l_xsim_file_path_and_name_tl }
{
\xsim_verbose:n
{ File~ `\l_xsim_file_path_and_name_tl'~ doesn't~ exist. }
}
}
{
\xsim_if_exchange:nnnTF {#1} {#2} {#3}
{ \xsim_get_property:nnn {#1} {#2} {exercise-body} }
{ \xsim_get_property:nnn {#1} {#2} {#3-body} }
}
}
\cs_generate_variant:Nn \xsim_input:nnn {oo,nV}
\prg_new_conditional:Npnn \xsim_if_insert_mode: {T,F,TF}
{
\bool_if:NTF \l__xsim_insert_mode_bool
{ \prg_return_true: }
{ \prg_return_false: }
}
\cs_new_protected:Npn \xsim_insert_mode:
{ \bool_set_true:N \l__xsim_insert_mode_bool }
% ----------------------------------------------------------------------------
% #1: type
% #2: exercise|solution
\cs_new_protected:Npn \xsim_new_environment:nn #1#2
{
\xsim_verbose:n { Defining~ #2~ environment~ type~ `#1'. }
\xsim_new_hook:nnn {#1} {#2} {pre}
\xsim_new_hook:nnn {#1} {#2} {begin}
\xsim_new_hook:nnn {#1} {#2} {end}
\xsim_new_hook:nnn {#1} {#2} {post}
\xsim_new_hook:nnn {#1} {#2} {print-false}
\xsim_if_write_to_files:TF
{
\NewDocumentEnvironment
{ \xsim_get_parameter:nn {#1} {#2-env} } {!o}
{
\IfNoValueTF {##1}
{
\bool_set_false:N \l__xsim_options_given_bool
\use:c {xsim_start_#2:nn} {#1} {}
}
{
\bool_set_true:N \l__xsim_options_given_bool
\use:c {xsim_start_#2:nn} {#1} {##1}
}
\xsim_start_environment:nVnn {#1} \g_xsim_exercise_id_tl {#2} { }
}
{
\xsim_stop_environment:nVn {#1} \g_xsim_exercise_id_tl {#2}
\use:c {xsim_stop_#2:n} {#1}
}
}
{
\NewDocumentEnvironment
{ \xsim_get_parameter:nn {#1} {#2-env} } {o+b}
{
\IfNoValueTF {##1}
{
\bool_set_false:N \l__xsim_options_given_bool
\use:c {xsim_start_#2:nn} {#1} {}
}
{
\bool_set_true:N \l__xsim_options_given_bool
\use:c {xsim_start_#2:nn} {#1} {##1}
}
\xsim_start_environment:nVnn {#1} \g_xsim_exercise_id_tl {#2} {##2}
}
{
\xsim_stop_environment:nVn {#1} \g_xsim_exercise_id_tl {#2}
\use:c {xsim_stop_#2:n} {#1}
}
}
}
\XSIMmoduleend
\XSIMmodule{templates}{templates for typesetting exercises}
\msg_new:nnn {xsim} {unknown-template}
{
You~ are~ trying~ to~ load~ the~ template~ `#2'~ (template~ type~ `#1')~
\msg_line_context: .~ This~ template~ does~ not~ seem~ to~ be~ defined.~
I~ am~ using~ the~ template~ `#3'~ (template~ type~ `#1')~ instead.
}
\msg_new:nnn {xsim} {template-type-exists}
{ The~ template~ type~ `#1'~ already~ exists~ \msg_line_context: }
% ----------------------------------------------------------------------------
\seq_new:N \l__xsim_template_types_seq
% #1: template type
\cs_new_protected:Npn \xsim_new_template_type:n #1
{
\seq_if_in:NnTF \l__xsim_template_types_seq {#1}
{ \msg_error:nnn {xsim} {template-type-exists} {#1} }
{
\xsim_verbose:n { Declaring~ new~ template~ type~ `#1'. }
\seq_put_right:Nn \l__xsim_template_types_seq {#1}
}
}
% #1: template type
% #2: template name
% #3: code
\cs_new_protected:Npn \__xsim_add_template:nnn #1#2#3
{
\xsim_verbose:n { Defining~ new~ template~ `#2'~ of~ type~ `#1'. }
\tl_new:c {l__xsim_template_#1_#2_setup_tl}
\xsim_attribute_set:nnn {template::#1} {#2} {#3}
}
\prg_new_conditional:Npnn \xsim_if_template_exist:nn #1#2 {T,F,TF}
{
\xsim_attribute_if_set:nnTF {template::#1} {#2}
{ \prg_return_true: }
{ \prg_return_false: }
}
% #1: template type
% #2: template name
\cs_new_protected:Npn \__xsim_get_template:nn #1#2
{ \xsim_attribute_get:nn {template::#1} {#2} }
% ----------------------------------------------------------------------------
% environment templates (types `begin' and `end'):
\xsim_new_template_type:n {begin}
\xsim_new_template_type:n {end}
% #1: template name
% #2: begin code
% #3: end code
\cs_new_protected:Npn \xsim_declare_environment_template:nnn #1#2#3
{
\__xsim_add_template:nnn {begin} {#1}
{
\__xsim_start_template:nn {begin} {#1}
\__xsim_start_template:nn {end} {#1}
#2
}
\__xsim_add_template:nnn {end} {#1}
{
#3
\__xsim_stop_template:nn {end} {#1}
\__xsim_stop_template:nn {begin} {#1}
}
}
% ----------------------------------------------------------------------------
% heading templates for the solution list (type `heading'):
\xsim_new_template_type:n {heading}
% #1: template name
% #2: code
\cs_new_protected:Npn \xsim_declare_heading_template:nn #1#2
{
\__xsim_add_template:nnn {heading} {#1}
{
\__xsim_start_template:nn {heading} {#1}
#2
\__xsim_stop_template:nn {heading} {#1}
}
}
% ----------------------------------------------------------------------------
% grading table templates (type `table'):
\xsim_new_template_type:n {table}
% #1: template name
% #2: code
\cs_new_protected:Npn \xsim_declare_table_template:nn #1#2
{
\__xsim_add_template:nnn {table} {#1}
{
\__xsim_start_template:nn {table} {#1}
#2
\__xsim_stop_template:nn {table} {#1}
}
}
% ----------------------------------------------------------------------------
% using templates:
% setup up the next usage of `template name':
% #1: template type
% #2: template name
% #3: setup code
\cs_new_protected:Npn \xsim_setup_template:nnn #1#2#3
{ \tl_set:cn {l__xsim_template_#1_#2_setup_tl} {#3} }
\cs_generate_variant:Nn \xsim_setup_template:nnn {nnV,nVn}
% #1: template type
% #2: template name
\cs_new_protected:Npn \__xsim_setup_template:nn #1#2
{ \tl_use:c {l__xsim_template_#1_#2_setup_tl} }
% #1: template type
% #2: template name
\cs_new_protected:Npn \__xsim_clear_template_setup:nn #1#2
{ \tl_clear:c {l__xsim_template_#1_#2_setup_tl} }
% #1: template type
% #2: template name
\cs_new_protected:Npn \__xsim_start_template:nn #1#2
{ \group_begin: \__xsim_setup_template:nn {#1} {#2} }
% #1: template type
% #2: template name
\cs_new_protected:Npn \__xsim_stop_template:nn #1#2
{ \group_end: \__xsim_clear_template_setup:nn {#1} {#2} }
% #1: template type
% #2: template name
\cs_new_protected:Npn \xsim_use_template:nn #1#2
{
\xsim_if_template_exist:nnTF {#1} {#2}
{ \__xsim_get_template:nn {#1} {#2} }
{
\msg_warning:nnnnn {xsim} {unknown-template} {#1} {#2} {default}
\__xsim_get_template:nn {#1} {default}
}
}
\cs_generate_variant:Nn \xsim_use_template:nn {nx,nV}
\XSIMmoduleend
\XSIMmodule{tags}{tagging of exercises}
\seq_new:N \l__xsim_tag_types_seq
\bool_new:N \l____xsim_tagged_bool
\msg_new:nnn {xsim} {tag-exists}
{ The~ tag~ type~ `#1'~ already~ exists.~ I~ am~ doing~ nothing. }
\msg_new:nnn {xsim} {tag-unknown}
{ The~ tag~ type~ `#1'~ is~ not~ defined.~ Check~ for~ a~ typo. }
% #1: name
\cs_new_protected:Npn \xsim_new_tag_type:n #1
{
\xsim_verbose:n { Declaring~ new~ tag~ type~ `#1'. }
\seq_put_right:Nn \l__xsim_tag_types_seq {#1}
\seq_remove_duplicates:N \l__xsim_tag_types_seq
\seq_new:c {l__xsim_chosen_tags_#1_seq}
\bool_new:c {l__xsim_ignore_untagged_#1_bool}
\bool_new:c {l____xsim_tagged_#1_bool}
\bool_new:c {l__xsim_use_unmatched_#1_bool}
\keys_define:nn {xsim}
{
#1/ignore-untagged .bool_set:c = {l__xsim_ignore_untagged_#1_bool} ,
#1/ignore-untagged .initial:n = true ,
#1 .code:n = \seq_set_from_clist:cn {l__xsim_chosen_tags_#1_seq} {##1} ,
#1/use-unmatched .bool_set:c = {l__xsim_use_unmatched_#1_bool} ,
#1/use-unmatched .initial:n = false
}
\prg_new_protected_conditional:cpnn {xsim_if_#1_value:n} ##1 {T,F,TF}
{
\seq_if_in:cnTF {l__xsim_chosen_tags_#1_seq} {##1}
{ \prg_return_true: }
{ \prg_return_false: }
}
\xsim_declare_property:nnnn
{ \c_false_bool }
{ \c_false_bool }
{ \c_false_bool }
{#1}
\xsim_declare_printsolutions_condition:nn {#1}
{ \__xsim_printsolutions_if_tagged:nnnnTF {#1} }
\keys_define:nn {xsim/print-solutions}
{
#1 .choice: ,
#1/false .code:n =
\__xsim_printsolutions_condition:nn {#1} {false} ,
#1/true .code:n =
\__xsim_printsolutions_condition:nn {#1} {true} ,
#1/unknown .code:n =
\keys_set:nn {xsim} { #1 = ##1 }
\__xsim_printsolutions_condition:nn {#1} {true} ,
#1 .initial:n = false
}
}
% #1: tag type
\prg_new_protected_conditional:Npnn \xsim_if_tag_type_exist:n #1 {T,F,TF}
{
\seq_if_in:NnTF \l__xsim_tag_types_seq {#1}
{ \prg_return_true: }
{ \prg_return_false: }
}
\prg_generate_conditional_variant:Nnn \xsim_if_tag_type_exist:n {V} {TF}
% #1: tag type
% #2: exercise type
% #3: id
% #4: print|use
\prg_new_protected_conditional:Npnn
\__xsim_printsolutions_if_tagged:nnnn #1#2#3#4 {T,F,TF}
{
\xsim_if_in_list:nnTF {#4} {#2-#3=={true}}
{
\__xsim_printsolutions_if_condition:nTF {#1}
{
\__xsim_printsolutions_condition_true:
\xsim_if_tagged:nnnTF {#2} {#3} {#1}
{ \prg_return_true: }
{ \prg_return_false: }
}
{ \prg_return_false: }
}
{ \prg_return_false: }
}
% #1: exercise type
% #2: id
% #3: tag type
\prg_new_protected_conditional:Npnn \xsim_if_tagged:nnn #1#2#3 {T,F,TF}
{
\bool_set_false:c {l____xsim_tagged_#3_bool}
\seq_if_empty:cTF {l__xsim_chosen_tags_#3_seq}
{ \bool_set_true:c {l____xsim_tagged_#3_bool} }
{
\seq_set_from_clist:Nx
\l__xsim_tmpa_seq
{ \xsim_get_property:nnn {#1} {#2} {#3} }
\seq_if_empty:NTF \l__xsim_tmpa_seq
{
\bool_set_eq:cc
{l____xsim_tagged_#3_bool}
{l__xsim_ignore_untagged_#3_bool}
}
{
\seq_map_inline:Nn \l__xsim_tmpa_seq
{
\seq_if_in:cnT {l__xsim_chosen_tags_#3_seq} {##1}
{
\bool_set_true:c {l____xsim_tagged_#3_bool}
\seq_map_break:
}
}
}
}
\bool_if:cTF {l____xsim_tagged_#3_bool}
{ \prg_return_true: }
{ \prg_return_false: }
}
% #1: exercise type
% #2: id
% #3: tag type
% #4: tag values
\prg_new_protected_conditional:Npnn \xsim_has_tags:nnnn #1#2#3#4 {T,F,TF}
{
\bool_set_false:c {l____xsim_tagged_#3_bool}
\seq_set_from_clist:Nn \l__xsim_tmpa_seq {#4}
\seq_if_empty:NTF \l__xsim_tmpa_seq
{% no tag values given:
\bool_set_true:c {l____xsim_tagged_#3_bool}
}
{
\seq_set_from_clist:Nx
\l__xsim_tmpb_seq
{ \xsim_get_property:nnn {#1} {#2} {#3} }
\seq_if_empty:NTF \l__xsim_tmpb_seq
{% exercise has no tag values given
% \bool_set_eq:cc
% {l____xsim_tagged_#3_bool}
% {l__xsim_ignore_untagged_#3_bool}
\bool_set_false:c {l____xsim_tagged_#3_bool}
}
{
\seq_map_inline:Nn \l__xsim_tmpb_seq
{
\seq_if_in:NnT \l__xsim_tmpa_seq {##1}
{
\bool_set_true:c {l____xsim_tagged_#3_bool}
\seq_map_break:
}
}
}
}
\bool_if:cTF {l____xsim_tagged_#3_bool}
{ \prg_return_true: }
{ \prg_return_false: }
}
\prg_generate_conditional_variant:Nnn \xsim_has_tags:nnnn {nnVV} {T,F}
% #1: exercise type
% #2: id
\prg_new_protected_conditional:Npnn \xsim_if_tagged:nn #1#2 {T,F,TF}
{
\bool_set_true:N \l____xsim_tagged_bool
\seq_map_inline:Nn \l__xsim_tag_types_seq
{
\xsim_if_tagged:nnnF {#1} {#2} {##1}
{
\bool_set_false:N \l____xsim_tagged_bool
\seq_map_break:
}
}
\bool_if:NTF \l____xsim_tagged_bool
{ \prg_return_true: }
{ \prg_return_false: }
}
% #1: exercise type
% #2: id
% #3: tag type
\prg_new_protected_conditional:Npnn \xsim_if_tags_match:nnn #1#2#3 {T,F,TF}
{
\bool_set_false:c {l____xsim_tagged_#3_bool}
\seq_if_empty:cTF {l__xsim_chosen_tags_#3_seq}
{ \bool_set_true:c {l____xsim_tagged_#3_bool} }
{
\seq_set_from_clist:Nx
\l__xsim_tmpa_seq
{ \xsim_get_property:nnn {#1} {#2} {#3} }
\seq_if_empty:NTF \l__xsim_tmpa_seq
{
\bool_set_eq:cc
{l____xsim_tagged_#3_bool}
{l__xsim_ignore_untagged_#3_bool}
}
{
\seq_map_inline:Nn \l__xsim_tmpa_seq
{
\seq_if_in:cnT {l__xsim_chosen_tags_#3_seq} {##1}
{
\bool_set_true:c {l____xsim_tagged_#3_bool}
\seq_map_break:
}
}
}
}
\bool_if:cTF {l____xsim_tagged_#3_bool}
{ \prg_return_true: }
{ \prg_return_false: }
}
\prg_new_protected_conditional:Npnn \xsim_if_tagged_use:nn #1#2 {T,F,TF}
{
\bool_set_true:N \l____xsim_tagged_bool
\seq_map_inline:Nn \l__xsim_tag_types_seq
{
\xsim_if_tags_match:nnnF {#1} {#2} {##1}
{
\bool_if:cF {l__xsim_use_unmatched_##1_bool}
{
\bool_set_false:N \l____xsim_tagged_bool
\seq_map_break:
}
}
}
\bool_if:NTF \l____xsim_tagged_bool
{ \prg_return_true: }
{ \prg_return_false: }
}
% #1: exercise type
% #2: id
% #3: tag type
% #4: code
\cs_new_protected:Npn \xsim_foreach_exercise_tag:nnnn #1#2#3#4
{
\seq_set_from_clist:Nx \l__xsim_tmpa_seq
{ \xsim_get_property:nnn {#1} {#2} {#3} }
\seq_map_inline:Nn \l__xsim_tmpa_seq {#4}
}
\cs_generate_variant:Nn \xsim_foreach_exercise_tag:nnnn {oo}
% #1: exercise type
% #2: id
% #3: tag type
% #4: sep
\cs_new_protected:Npn \xsim_exercise_tags_use:nnnn #1#2#3#4
{
\seq_set_from_clist:Nx \l__xsim_tmpa_seq
{ \xsim_get_property:nnn {#1} {#2} {#3} }
\seq_use:Nn \l__xsim_tmpa_seq {#4}
}
\cs_generate_variant:Nn \xsim_exercise_tags_use:nnnn {oo}
% #1: exercise type
% #2: id
% #3: tag type
% #4: sep between two
% #5: sep between more than two
% #6: sep between last two
\cs_new_protected:Npn \xsim_exercise_tags_use:nnnnnn #1#2#3#4#5#6
{
\seq_set_from_clist:Nx \l__xsim_tmpa_seq
{ \xsim_get_property:nnn {#1} {#2} {#3} }
\seq_use:Nnnn \l__xsim_tmpa_seq {#4} {#5} {#6}
}
\cs_generate_variant:Nn \xsim_exercise_tags_use:nnnn {oo}
\cs_generate_variant:Nn \xsim_exercise_tags_use:nnnnnn {oo}
\XSIMmoduleend
\XSIMmodule{goals}{counting of points and bonus points}
\msg_new:nnn {xsim} {goal-unknown}
{ The~ goal~ `#1'~ has~ never~ been~ declared~ \msg_line_context: }
\seq_new:N \l__xsim_goals_seq
\tl_new:N \l_xism_grading_table_template_tl
\tl_new:N \l_xism_grading_table_exercise_type_tl
% #1: name
\cs_new_protected:Npn \xsim_declare_exercise_goal:n #1
{
\xsim_if_goal_exist:nF {#1}
{
\xsim_verbose:n { Declaring~ new~ goal~ `#1'. }
\xsim_declare_property:nnnn
{ \c_false_bool } { \c_false_bool } { \c_false_bool } {#1}
\xsim_declare_property:nnnn
{ \c_false_bool } { \c_false_bool } { \c_false_bool } {user#1}
\xsim_declare_property:nnnn
{ \c_false_bool } { \c_false_bool } { \c_false_bool } {body#1}
\seq_put_right:Nn \l__xsim_goals_seq {#1}
\fp_gzero_new:c {g__xsim_goal_#1_fp}
\fp_new:c {l__xsim_temporary_#1_fp}
\bool_new:c {l__xsim_temporary_#1_bool}
\bool_new:c {l__xsim_goal_#1_given_bool}
\fp_gzero_new:c {l__xsim_current_goal_#1_fp}
\fp_if_exist:cF {g__xsim_total_goal_#1_fp}
{ \fp_new:c {g__xsim_total_goal_#1_fp} }
\fp_if_exist:cF {g__xsim_total_goal_recorded_#1_fp}
{ \fp_new:c {g__xsim_total_goal_recorded_#1_fp} }
\xsim_before_begin_document:n
{
\xsim_foreach_exercise_type:n
{ \xsim_goal_init:nn {##1} {#1} }
}
}
}
% #1: type
% #2: goal
\cs_new_protected:Npn \xsim_goal_init:nn #1#2
{
\fp_gzero_new:c {g__xsim_#1_goal_#2_fp}
\fp_if_exist:cF {g__xsim_total_#1_goal_#2_fp}
{ \fp_new:c {g__xsim_total_#1_goal_#2_fp} }
}
\prg_new_conditional:Npnn \xsim_if_goal_exist:n #1 {p,T,F,TF}
{
\seq_if_in:NnTF \l__xsim_goals_seq {#1}
{ \prg_return_true: }
{ \prg_return_false: }
}
\prg_new_conditional:Npnn \xsim_if_goal_given:n #1 {p,T,F,TF}
{
\bool_if:cTF {l__xsim_goal_#1_given_bool}
{ \prg_return_true: }
{ \prg_return_false: }
}
\cs_new_protected:Npn \xsim_goal_given:n #1
{ \bool_set_true:c {l__xsim_goal_#1_given_bool} }
% #1: exercise type
% #2: id
% #3: goal
\cs_new_protected:Npn \xsim_update_goal:nnn #1#2#3
{
\xsim_if_goal_exist:nT {#3}
{
\fp_gadd:cn {g__xsim_goal_#3_fp}
{ \xsim_get_property:nnn {#1} {#2} {#3} + 0 }
\fp_gadd:cn {g__xsim_#1_goal_#3_fp}
{ \xsim_get_property:nnn {#1} {#2} {#3} + 0 }
}
}
% #1: exercise type
% #2: id
\cs_new_protected:Npn \xsim_update_goals:nn #1#2
{
\xsim_foreach_goal:n
{ \xsim_update_goal:nnn {#1} {#2} {##1} }
}
\cs_generate_variant:Nn \xsim_update_goals:nn {nV}
\cs_new_protected:Npn \xsim_foreach_goal:n #1
{ \seq_map_inline:Nn \l__xsim_goals_seq {#1} }
% #1: exercise type
% #2: id
% #3: goal
% #4: value
\cs_new_protected:Npn \xsim_addto_goal:nnnn #1#2#3#4
{
\xsim_if_goal_exist:nT {#3}
{
\xsim_verbose:n { Adding~ `#4'~ to~ `#3'~ goal~ of~ #1~ #2 }
\fp_set:Nn \l__xsim_tmpa_fp
{ \xsim_get_property:nnn {#1} {#2} {body#3} + 0 + #4 }
\xsim_set_property:nnne {#1} {#2} {body#3}
{ \fp_to_decimal:N \l__xsim_tmpa_fp }
}
}
\cs_generate_variant:Nn \xsim_addto_goal:nnnn {xx,nVnx}
% #1: exercise type
% #2: id
% #3: goal
% #4: relation and value
\prg_new_conditional:Npnn \xsim_if_goal_value:nnnn #1#2#3#4 {p,T,F,TF}
{
\fp_compare:nTF
{ (0 + \xsim_get_property:nnn {#1} {#2} {#3}) #4 }
{ \prg_return_true: }
{ \prg_return_false: }
}
\cs_generate_variant:Nn \xsim_if_goal_value:nnnnTF {xx}
% ----------------------------------------------------------------------------
% a function which can be used to modify how the numbers of a goal are
% printed:
\cs_new_protected:Npn \__xsim_print_goal:n #1 {#1}
\cs_generate_variant:Nn \__xsim_print_goal:n {x}
% #1: value
% #2: value == 1
% #3: value != 1
\cs_new_protected:Npn \xsim_print_goal:nnn #1#2#3
{
\__xsim_print_goal:x { \fp_to_decimal:n {#1} }
\fp_compare:nTF { (#1) = 1 } {#2} {#3}
}
% #1: exercise type
% #2: goal
% #3: sum == 1
% #4: sum != 1
\cs_new_protected:Npn \xsim_print_goal_sum:nnnn #1#2#3#4
{ \xsim_print_goal:nnn { \use:c {g__xsim_total_#1_goal_#2_fp} } {#3} {#4} }
% #1: goal
% #2: sum == 1
% #3: sum != 1
\cs_new_protected:Npn \xsim_print_total_goal_sum:nnn #1#2#3
{ \xsim_print_goal:nnn { \use:c {g__xsim_total_goal_#1_fp} } {#2} {#3} }
% ----------------------------------------------------------------------------
% the same as the last to functions but for a list of goals:
% #1: fp variable to be set
% #2: list of goals (separated with +)
% #3: function to be applied to goal names
\cs_new_protected:Npn \__xsim_exercise_goals_sum_aux:Nnn #1#2#3
{
\seq_set_split:Nnn \l__xsim_tmpa_seq {+} {#2}
\seq_set_map:NNn \l__xsim_tmpb_seq \l__xsim_tmpa_seq {#3}
\fp_set:Nn #1 { \seq_use:Nn \l__xsim_tmpb_seq {+} }
}
% #1: fp variable
% #2: exercise type
% #3: list of goals (separated with +)
\cs_new_protected:Npn \__xsim_exercise_goals_sum:Nnn #1#2#3
{
\__xsim_exercise_goals_sum_aux:Nnn #1 {#3}
{ \use:c {g__xsim_total_#2_goal_ \tl_trim_spaces:n {##1} _fp} }
}
% #1: fp variable
% #2: list of goals (separated with +)
\cs_new_protected:Npn \__xsim_exercise_goals_sum:Nn #1#2
{
\__xsim_exercise_goals_sum_aux:Nnn #1 {#2}
{ \use:c {g__xsim_total_goal_ \tl_trim_spaces:n {##1} _fp} }
}
% #1: exercise type
% #2: list of goals (separated with +)
% #3: sum == 1
% #4: sum != 1
\cs_new_protected:Npn \xsim_print_goals_sum:nnnn #1#2#3#4
{
\__xsim_exercise_goals_sum:Nnn \l__xsim_tmpa_fp {#1} {#2}
\xsim_print_goal:nnn { \l__xsim_tmpa_fp } {#3} {#4}
}
% #1: list of goals (separated with +)
% #2: sum == 1
% #3: sum != 1
\cs_new_protected:Npn \xsim_print_total_goals_sum:nnn #1#2#3
{
\__xsim_exercise_goals_sum:Nn \l__xsim_tmpa_fp {#1}
\xsim_print_goal:nnn { \l__xsim_tmpa_fp } {#2} {#3}
}
% ----------------------------------------------------------------------------
% #1: exercise type
% #2: goal
% #3: relation and value
\prg_new_conditional:Npnn \xsim_if_goal_sum:nnn #1#2#3 {p,T,F,TF}
{
\fp_compare:nTF
{ ( \use:c {g__xsim_total_#1_goal_#2_fp} ) #3 }
{ \prg_return_true: }
{ \prg_return_false: }
}
% #1: exercise type
% #2: list of goals (separated with +)
% #3: relation and value
\prg_new_protected_conditional:Npnn \xsim_if_goals_sum:nnn #1#2#3 {T,F,TF}
{
\__xsim_exercise_goals_sum:Nnn \l__xsim_tmpa_fp {#1} {#2}
\fp_compare:nTF
{ ( \l__xsim_tmpa_fp ) #3 }
{ \prg_return_true: }
{ \prg_return_false: }
}
% #1: goal
% #2: relation and value
\prg_new_conditional:Npnn \xsim_if_total_goal_sum:nn #1#2 {p,T,F,TF}
{
\fp_compare:nTF
{ ( \use:c {g__xsim_total_goal_#1_fp} ) #2 }
{ \prg_return_true: }
{ \prg_return_false: }
}
% #1: list of goals (separated with +)
% #2: relation and value
\prg_new_protected_conditional:Npnn \xsim_if_total_goals_sum:nn #1#2 {T,F,TF}
{
\__xsim_exercise_goals_sum:Nn \l__xsim_tmpa_fp {#1}
\fp_compare:nTF
{ ( \l__xsim_tmpa_fp ) #2 }
{ \prg_return_true: }
{ \prg_return_false: }
}
% ----------------------------------------------------------------------------
% #1: exercise type
% #2: goal
% #3: value
\xsim_new_aux_property:cpn {goal} #1#2#3
{ \fp_gset:cn {g__xsim_total_#1_goal_#2_fp} {#3} }
% #1: goal
% #2: value
\xsim_new_aux_property:cpn {totalgoal} #1#2
{ \fp_gset:cn {g__xsim_total_goal_#1_fp} {#2} }
\xsim_at_begin_document:n
{ \xsim_foreach_goal:n { \xsim_get_total_goal:n {#1} } }
% #1: goal
\cs_new_protected:Npn \xsim_get_total_goal:n #1
{
\fp_gset_eq:cc
{g__xsim_total_goal_recorded_#1_fp}
{g__xsim_total_goal_#1_fp}
}
\xsim_at_end_document:n { \xsim_save_goals: }
\cs_new_protected:Npn \xsim_save_goals:
{
\xsim_foreach_goal:n
{
\xsim_foreach_exercise_type:n
{
\xsim_add_property_to_aux:nn {goal}
{ {####1} {##1} { \fp_to_decimal:c {g__xsim_####1_goal_##1_fp} } }
}
\tl_set:Nx \l__xsim_tmpa_tl
{ \fp_to_decimal:c {g__xsim_total_goal_##1_fp} }
\tl_set:Nx \l__xsim_tmpb_tl
{ \fp_to_decimal:c {g__xsim_total_goal_recorded_##1_fp} }
\tl_if_eq:NNF \l__xsim_tmpa_tl \l__xsim_tmpb_tl { \xsim_rerun: }
\xsim_add_property_to_aux:nn {totalgoal}
{ {##1} { \fp_to_decimal:c {g__xsim_goal_##1_fp} } }
}
}
% ----------------------------------------------------------------------------
\keys_define:nn {xsim}
{
goal-print .code:n =
\cs_set_protected:Npn \__xsim_print_goal:n ##1 {#1} ,
grading-table/template .tl_set:N = \l_xism_grading_table_template_tl ,
grading-table/template .initial:n = default ,
grading-table/type .tl_set:N = \l_xism_grading_table_exercise_type_tl ,
grading-table/type .initial:n =
}
\XSIMmoduleend
\XSIMmodule{exercises}{main exercises definitions}
\seq_new:N \l__xsim_exercise_types_seq
\seq_new:N \l__xsim_parameters_seq
\seq_new:N \l__xsim_fixed_parameters_seq
\seq_new:N \l__xsim_mandatory_parameters_seq
\int_gzero_new:N \g_xsim_id_int
\int_gzero_new:N \g_xsim_max_id_int
\tl_new:N \l_xsim_current_id_tl
\tl_new:N \g_xsim_exercise_id_tl
\tl_new:N \g_xsim_exercise_type_tl
\tl_new:N \ExerciseID
\tl_new:N \ExerciseType
% ----------------------------------------------------------------------------
\msg_new:nnn {xsim} {parameter-fixed}
{
You~ tried~ to~ set~ parameter~ `#2'~ for~ type~ `#1'~ \msg_line_context:
. ~ However,~ parameter~ `#2'~ is~ a~ fixed~ parameter~ that~ already~
has~ been~ set~ for~ type~ `#1'.~ Its~ value~ can't~ be~ changed!
}
\msg_new:nnn {xsim} {type-exists}
{
You~ try~ to~ define~ exercise~ type~ `#1'~ \msg_line_context: .~
However,~ the~ exercise~ type~ `#1'~ already~ exists.
}
\msg_new:nnn {xsim} {mandatory-parameter}
{
You~ forget~ to~ set~ the~ mandatory~ parameter~ `#1'~ when~ defining~
exercise~ type~ `#2'.
}
\msg_new:nnn {xsim} {unknown-parameter}
{
You~ tried~ to~ retrieve~ the~ parameter~ `#1'~ \msg_line_context: . \\
This~ parameter~ does~ not~ exist.~ Check~ for~ a~ typo~ or~ \\
define~ the~ parameter~ yourself.
}
\msg_new:nnn {xsim} {parameter-undefined}
{
You~ tried~ to~ set~ the~ parameter~ `#2'~ for~ exercise~ type~ `#1'~
\msg_line_context: . \\
This~ parameter~ does~ not~ exist.~ Check~ for~ a~ typo~ or~ \\
define~ the~ parameter~ yourself.
}
\msg_new:nnn {xsim} {parameter-value}
{
A~ parameter~ needs~ to~ be~ set~ to~ a~ (possibly~ empty)~ value! \\
Not~ setting~ parameter~ `#2'~ for~ exercise~ type~ `#1'~
\msg_line_context: .
}
% ----------------------------------------------------------------------------
% #1: type
% #2: parameter
% #3: value
\cs_new_protected:Npn \__xsim_set_parameter_type:nnn #1#2#3
{ \xsim_attribute_set:nnn {#1} {#2} {#3} }
% #1: type
% #2: parameter
\cs_new:Npn \xsim_get_parameter:nn #1#2
{ \xsim_attribute_get:nn {#1} {#2} }
\cs_generate_variant:Nn \xsim_get_parameter:nn {o}
% #1: type
% #2: parameter
\prg_new_conditional:Npnn \xsim_if_parameter_set:nn #1#2 {p,T,F,TF}
{
\xsim_attribute_if_set:nnTF {#1} {#2}
{ \prg_return_true: }
{ \prg_return_false: }
}
\prg_generate_conditional_variant:Nnn \xsim_if_parameter_set:nn {o} {T,F,TF}
% ----------------------------------------------------------------------------
\xsim_new_list:n {types}
\xsim_new_list:n {order}
\xsim_at_end_document:n { \xsim_update_list:n {order} }
\xsim_new_list:n {idtypes}
% #1: true|false (fixed parameter)
% #2: true|false (mandatory parameter)
% #3: parameter name
\cs_new_protected:Npn \xsim_declare_parameter:nnn #1#2#3
{
\xsim_verbose:n { Declaring~ parameter~ `#3'. }
\xsim_if_parameter_exist:nF {#3}
{
\seq_put_right:Nn \l__xsim_parameters_seq {#3}
\bool_if:cT {c_#1_bool}
{ \seq_put_right:Nn \l__xsim_fixed_parameters_seq {#3} }
\bool_if:cT {c_#2_bool}
{ \seq_put_right:Nn \l__xsim_mandatory_parameters_seq {#3} }
}
}
\cs_new_protected:Npn \xsim_remove_parameter:n #1
{
\xsim_verbose:n { Removing~ parameter~ `#1'. }
\xsim_if_parameter_exist:nT {#1}
{ \seq_remove_all:Nn \l__xsim_parameters_seq {#1} }
}
\prg_new_conditional:Npnn \xsim_if_parameter_exist:n #1 {p,T,F,TF}
{
\seq_if_in:NnTF \l__xsim_parameters_seq {#1}
{ \prg_return_true: }
{ \prg_return_false: }
}
\cs_generate_variant:Nn \xsim_if_parameter_exist:nT {x}
\prg_new_conditional:Npnn \xsim_if_parameter_fixed:n #1 {p,T,F,TF}
{
\seq_if_in:NnTF \l__xsim_fixed_parameters_seq {#1}
{ \prg_return_true: }
{ \prg_return_false: }
}
% #1: type
% #2: csv list of parameters
\cs_new_protected:Npn \xsim_set_parameters:nn #1#2
{
\cs_set_protected:Npn \__xsim_set_parameter:n ##1
{ \msg_warning:nnnn {xsim} {parameter-value} {#1} {##1} }
\cs_set_protected:Npn \__xsim_set_parameter:nn ##1##2
{ \xsim_set_parameter:nnn {#1} {##1} {##2} }
\keyval_parse:NNn
\__xsim_set_parameter:n
\__xsim_set_parameter:nn
{#2}
}
\cs_generate_variant:Nn \xsim_set_parameters:nn {nx}
% #1: type
\cs_new_protected:Npn \xsim_check_mandatory_parameters:n #1
{
\seq_map_inline:Nn \l__xsim_mandatory_parameters_seq
{
\xsim_if_parameter_set:nnF {#1} {##1}
{ \msg_error:nnnn {xsim} {mandatory-parameter} {##1} {#1} }
}
}
% #1: type
\prg_new_conditional:Npnn \xsim_if_type:n #1 {p,T,F,TF}
{
\seq_if_in:NnTF \l__xsim_exercise_types_seq {#1}
{ \prg_return_true: }
{ \prg_return_false: }
}
% #1: type
% #2: parameter
% #3: value
\cs_new_protected:Npn \xsim_set_parameter:nnn #1#2#3
{
\xsim_if_parameter_exist:nTF {#2}
{
\xsim_if_parameter_fixed:nTF {#1}
{
\xsim_if_parameter_set:nnTF {#1} {#2}
{
\msg_warning:nnnn {xsim} {parameter-fixed} {#1} {#2}
\xsim_verbose:n
{
Not~ setting~ already~ set~ and~ fixed~ parameter~ `#2'~
for~ type~ `#1'.
}
}
{
\xsim_verbose:n
{ Setting~ parameter~ `#2'~ for~ type~ `#1'~ to~ `#3'. }
\__xsim_set_parameter_type:nnn {#1} {#2} {#3}
}
}
{
\xsim_verbose:n
{ Setting~ parameter~ `#2'~ for~ type~ `#1'~ to~ `#3'. }
\__xsim_set_parameter_type:nnn {#1} {#2} {#3}
}
}
{ \msg_error:nnnn {xsim} {parameter-undefined} {#1} {#2} }
}
\cs_generate_variant:Nn \xsim_set_parameter:nnn {nnx,nxx}
\cs_new:Npn \__xsim_get_parameter_tmp:n #1 {}
\cs_generate_variant:Nn \__xsim_get_parameter_tmp:n {V}
% #1: type
% #2: parameter
\cs_new_protected:Npn \xsim_get_parameter_if_set:nnTF #1#2#3#4
{
\group_begin:
\xsim_if_parameter_exist:nTF {#2}
{
\xsim_if_parameter_set:nnTF {#1} {#2}
{
\tl_set:Nx \ParameterValue
{ \xsim_get_parameter:nn {#1} {#2} }
\cs_set:Npn \__xsim_get_parameter_tmp:n ##1 {#3}
\__xsim_get_parameter_tmp:V \ParameterValue
}
{#4}
}
{ \msg_error:nnn {xsim} {unknown-parameter} {#2} }
\group_end:
}
\cs_new_protected:Npn \xsim_get_parameter_if_set:nnT #1#2#3
{ \xsim_get_parameter_if_set:nnTF {#1} {#2} {#3} {} }
\cs_new_protected:Npn \xsim_get_parameter_if_set:nnF #1#2#3
{ \xsim_get_parameter_if_set:nnTF {#1} {#2} {} {#3} }
\cs_generate_variant:Nn \xsim_get_parameter_if_set:nnTF {o}
% ----------------------------------------------------------------------------
% inside the argument `#1' refers to the type
\cs_new_protected:Npn \xsim_foreach_exercise_type:n #1
{ \xsim_foreach_new_list_entry:nn {types} {#1} }
\cs_new_protected:Npn \xsim_foreach_exercise_id:n #1
{ \int_step_inline:nnnn {1} {1} { \g_xsim_max_id_int } {#1} }
\cs_new_protected:Npn \xsim_foreach_exercise_order:n #1
{ \xsim_foreach_new_list_entry:nn {order} {#1} }
% #1: macro name
% #2: 0 to 9 times `n' (= number of arguments of internal item)
% #3: code; may contain a suiting \__xsim_loop_item:<nnn>
\cs_new_protected:Npn \xsim_define_loop_macro:Nnn #1#2#3
{
\xsim_verbose:n { Defining~ loop~ macro~ #1 }
\cs_new_protected:Npn #1 ##1##2
{ \cs_set:cn {__xsim_loop_item:#2} {##2} #3 }
}
\cs_new:Npn \__xsim_loop_item:nnnnnn #1#2#3#4#5#6 {}
\cs_generate_variant:Nn \__xsim_loop_item:nnnnnn {VVxxxx}
% #1: type
% #2: id
% #3: boolean property
\cs_new_protected:Npn \__xsim_deliver_exercise_details:nnn #1#2#3
{
\tl_if_blank:nTF {#3}
{ \use:n }
{ \xsim_if_in_list:nnT {#3} {#1-#2=={true}} }
{
\tl_set_rescan:Nnx \ExerciseType {} {#1}
\tl_set_rescan:Nnx \ExerciseID {} {#2}
\__xsim_loop_item:VVxxxx
\ExerciseType % #1
\ExerciseID % #2
{ \xsim_get_property:nnn {#1} {#2} {counter} } % #3
{ \xsim_get_property:nnn {#1} {#2} {subtitle} } % #4
{ \xsim_get_property:nnn {#1} {#2} {points} } % #5
{ \xsim_get_property:nnn {#1} {#2} {bonus-points} } % #6
}
}
% #1: boolean property
% #2: loop code
\xsim_define_loop_macro:Nnn \xsim_foreach_exercise_type_id:nn
{nnnnnn}
{
\xsim_foreach_exercise_type:n
{
\xsim_foreach_exercise_id:n
{ \__xsim_deliver_exercise_details:nnn {##1} {####1} {#1} }
}
}
\xsim_define_loop_macro:Nnn \xsim_foreach_exercise_type_order:nn
{nnnnnn}
{
\xsim_foreach_exercise_type:n
{
\xsim_foreach_exercise_order:n
{ \__xsim_deliver_exercise_details:nnn {##1} {####1} {#1} }
}
}
\xsim_define_loop_macro:Nnn \xsim_foreach_exercise_id_type:nn
{nnnnnn}
{
\xsim_foreach_exercise_id:n
{
\xsim_foreach_exercise_type:n
{ \__xsim_deliver_exercise_details:nnn {####1} {##1} {#1} }
}
}
\cs_new:Npn \__xsim_loop_item:nn #1#2 {}
\cs_generate_variant:Nn \__xsim_loop_item:nn {VV}
\xsim_define_loop_macro:Nnn \xsim_foreach_exercise:nn
{nn}
{
\cs_set:Npn \__xsim_tmpa:w ##1-##2 \q_stop {##1}
\cs_set:Npn \__xsim_tmpb:w ##1-##2 \q_stop {##2}
\seq_map_inline:cn {g_xsim_#1_order_seq}
{
\tl_set:Nx \l__xsim_tmpa_tl { \__xsim_tmpa:w ##1 \q_stop }
\tl_set:Nx \l__xsim_tmpb_tl { \__xsim_tmpb:w ##1 \q_stop }
\__xsim_loop_item:VV \l__xsim_tmpa_tl \l__xsim_tmpb_tl
}
}
% ----------------------------------------------------------------------------
\cs_new_protected:Npn \xsim_define_exercise_type_variables:n #1
{
\seq_put_right:Nn \l__xsim_exercise_types_seq {#1}
\bool_new:c {l__xsim_#1_solution_print_bool}
\bool_new:c {l__xsim_#1_exercise_print_bool}
\bool_new:c {l__xsim_#1_exercise_use_bool}
}
\cs_new_protected:Npn \xsim_define_counters:n #1
{
\xsim_verbose:n { Defining~ counters~ for~ new~ exercise~ type~ `#1' }
\cs_if_exist:cF { c@ \xsim_get_parameter:nn {#1} {counter} }
{ \newcounter { \xsim_get_parameter:nn {#1} {counter} } }
\cs_if_exist:cF { c@ \xsim_get_parameter:nn {#1} {solution-counter} }
{ \newcounter { \xsim_get_parameter:nn {#1} {solution-counter} } }
\cs_if_exist:cF { c@ number of \xsim_get_parameter:nn {#1} {exercise-env} s }
{ \newcounter { number of \xsim_get_parameter:nn {#1} {exercise-env} s } }
\xsim_if_parameter_set:nnT {#1} {within}
{
\counterwithin
{ \xsim_get_parameter:nn {#1} {counter} }
{ \xsim_get_parameter:nn {#1} {within} }
}
\xsim_if_parameter_set:nnT {#1} {the-counter}
{
\cs_set:cpx { the \xsim_get_parameter:nn {#1} {counter} }
{ \xsim_get_parameter:nn {#1} {the-counter} }
}
}
% #1: type
% #2: id
\cs_new_protected:Npn \xsim_step_exercise_counter:nn #1#2
{
\refstepcounter { \xsim_get_parameter:nn {#1} {counter} }
\xsim_set_properties:nne {#1} {#2}
{
counter = \use:c { the \xsim_get_parameter:nn {#1} {counter} } ,
counter-value = \arabic { \xsim_get_parameter:nn {#1} {counter} }
}
}
\cs_generate_variant:Nn \xsim_step_exercise_counter:nn {nV}
% #1: type
\cs_new_protected:Npn \xsim_declare_exercise_type:nn #1#2
{
\xsim_if_type:nTF {#1}
{ \msg_error:nnn {xsim} {type-exists} {#1} }
{
\xsim_verbose:n { Declaring~ new~ exercise~ type~ `#1'. }
\xsim_define_exercise_type_variables:n {#1}
\xsim_add_to_list:nn {types} {#1}
\xsim_set_parameters:nn {#1} {#2}
\xsim_set_parameter:nnx {#1} {number}
{ number of \xsim_get_parameter:nn {#1} {exercise-env} s }
\xsim_check_mandatory_parameters:n {#1}
\xsim_if_parameter_set:nnF {#1} {exercises-name}
{
\xsim_set_parameters:nn {#1}
{ exercises-name = \xsim_get_parameter:nn {#1} {exercise-name} s }
}
\xsim_if_parameter_set:nnF {#1} {solutions-name}
{
\xsim_set_parameters:nn {#1}
{ solutions-name = \xsim_get_parameter:nn {#1} {solution-name} s }
}
\xsim_if_parameter_set:nnF {#1} {counter}
{
\xsim_set_parameters:nx {#1}
{ counter = \xsim_get_parameter:nn {#1} {exercise-env} }
}
\xsim_if_parameter_set:nnF {#1} {solution-counter}
{
\xsim_set_parameters:nx {#1}
{ solution-counter = \xsim_get_parameter:nn {#1} {solution-env} }
}
\xsim_define_counters:n {#1}
\xsim_verbose:n { Defining~ options~ for~ new~ exercise~ type~ `#1' }
\keys_define:nx {xsim}
{
\xsim_get_parameter:nn {#1} {solution-env} / print
.bool_set:N = \exp_not:c {l__xsim_#1_solution_print_bool} ,
\xsim_get_parameter:nn {#1} {solution-env} / print
.initial:n = false ,
\xsim_get_parameter:nn {#1} {exercise-env} / print
.bool_set:N = \exp_not:c {l__xsim_#1_exercise_print_bool} ,
\xsim_get_parameter:nn {#1} {exercise-env} / print
.initial:n = true ,
\xsim_get_parameter:nn {#1} {exercise-env} / use
.bool_set:N = \exp_not:c {l__xsim_#1_exercise_use_bool} ,
\xsim_get_parameter:nn {#1} {exercise-env} / use
.initial:n = true ,
\xsim_get_parameter:nn {#1} {exercise-env} / collect .choice: ,
\xsim_get_parameter:nn {#1} {exercise-env} / collect / true .code:n =
\keys_set:nn
{ xsim / \xsim_get_parameter:nn {#1} {exercise-env} }
{ use = false , print = false } ,
\xsim_get_parameter:nn {#1} {exercise-env} / collect / false .code:n =
\keys_set:nn
{ xsim / \xsim_get_parameter:nn {#1} {exercise-env} }
{ use = true , print = true } ,
\xsim_get_parameter:nn {#1} {exercise-env} / collect .default:n = true ,
\xsim_get_parameter:nn {#1} {exercise-env} / collect .initial:n = false ,
\xsim_get_parameter:nn {#1} {exercise-env} / within .code:n =
\exp_not:N \counterwithin { \xsim_get_parameter:nn {#1} {counter} } {####1},
\xsim_get_parameter:nn {#1} {exercise-env} / the-counter .code:n =
\cs_set:cpn {the \xsim_get_parameter:nn {#1} {counter} } {####1} ,
\xsim_get_parameter:nn {#1} {exercise-env} / template
.code:n = \xsim_set_parameter:nnn {#1} {exercise-template} {####1} ,
\xsim_get_parameter:nn {#1} {solution-env} / template
.code:n = \xsim_set_parameter:nnn {#1} {solution-template} {####1} ,
\xsim_get_parameter:nn {#1} {exercise-env} / name
.code:n = \xsim_set_parameter:nnn {#1} {exercise-name} {####1} ,
\xsim_get_parameter:nn {#1} {exercise-env} s / name
.code:n = \xsim_set_parameter:nnn {#1} {exercises-name} {####1} ,
\xsim_get_parameter:nn {#1} {solution-env} / name
.code:n = \xsim_set_parameter:nnn {#1} {solution-name} {####1} ,
\xsim_get_parameter:nn {#1} {solution-env} s / name
.code:n = \xsim_set_parameter:nnn {#1} {solutions-name} {####1} ,
\xsim_get_parameter:nn {#1} {exercise-env} / heading
.code:n = \xsim_set_parameter:nnn {#1} {exercise-heading} {####1} ,
\xsim_get_parameter:nn {#1} {solution-env} / heading
.code:n = \xsim_set_parameter:nnn {#1} {solution-heading} {####1}
}
\xsim_new_environment:nn {#1} {exercise}
\xsim_new_environment:nn {#1} {solution}
}
}
% #1: type
% #2: id
\prg_new_conditional:Npnn \xsim_if_exercise_exist:nn #1#2 {T,F,TF}
{
\xsim_if_exist:nnnTF {#1} {#2} {exercise}
{ \prg_return_true: }
{ \prg_return_false: }
}
\cs_generate_variant:Nn \xsim_if_exercise_exist:nnT {VV}
% ----------------------------------------------------------------------------
% define boolean properties <do> and <done> (<done> is a noupdate property)
% and the conditional:
% \xsim_if_<do>:nnTF
%
% #1: <do>
% #2: <done>
\cs_new_protected:Npn \__xsim_new_exercise_mode:nn #1#2
{
% boolean:
\xsim_declare_property:nnnn
{ \c_false_bool } { \c_true_bool } { \c_false_bool } {#1}
% boolean:
\xsim_declare_property:nnnn
{ \c_false_bool } { \c_true_bool } { \c_false_bool } {#1!}
% boolean, noupdate:
\xsim_declare_property:nnnn
{ \c_false_bool } { \c_true_bool } { \c_true_bool } {(#2)}
% boolean:
\xsim_declare_property:nnnn
{ \c_false_bool } { \c_true_bool } { \c_false_bool } {#2}
% ##1: type
% ##2: id
% ##3: exercise|solution
\prg_new_protected_conditional:cpnn {xsim_if_#1:nnn} ##1##2##3 {T,F,TF}
{
\use:c {xsim_##3_if_#1:nnTF} {##1} {##2}
{ \prg_return_true: }
{ \prg_return_false: }
}
}
\cs_generate_variant:Nn \prg_new_protected_conditional:Npnn {c}
\cs_generate_variant:Nn \prg_generate_conditional_variant:Nnn {c}
\__xsim_new_exercise_mode:nn {use} {used}
\__xsim_new_exercise_mode:nn {print} {printed}
% #1: type
% #2: options
\cs_new_protected:Npn \xsim_exercise_setup:nn #1#2
{
\int_gincr:N \g_xsim_id_int
\int_compare:nF { \g_xsim_max_id_int > \g_xsim_id_int }
{ \int_gset_eq:NN \g_xsim_max_id_int \g_xsim_id_int }
\tl_gset:Nx \g_xsim_exercise_id_tl { \int_use:N \g_xsim_id_int }
\tl_gset:Nn \g_xsim_exercise_type_tl {#1}
\xsim_add_to_list:nx {idtypes} { \g_xsim_exercise_id_tl == {#1} }
\xsim_foreach_goal:n
{
\xsim_if_property_set:nVnT {#1} \g_xsim_exercise_id_tl {##1}
{
\bool_set_true:c {l__xsim_temporary_##1_bool}
\fp_set:cn {l__xsim_temporary_##1_fp}
{ \xsim_get_property:nVn {#1} \g_xsim_exercise_id_tl {##1} }
\xsim_unset_property:nVn {#1} \g_xsim_exercise_id_tl {##1}
}
}
\xsim_set_properties:nVe {#1} \g_xsim_exercise_id_tl
{
% properties set by the user:
\exp_not:n {#2} ,
% properties which need to have certain values:
id = \g_xsim_exercise_id_tl ,
printed = false ,
used = false
}
\xsim_foreach_goal:n
{
\xsim_if_property_set:nVnT {#1} \g_xsim_exercise_id_tl {##1}
{
\xsim_set_property:nVne {#1} \g_xsim_exercise_id_tl {user##1}
{ \xsim_get_property:nVn {#1} \g_xsim_exercise_id_tl {##1} }
}
\bool_if:cT {l__xsim_temporary_##1_bool}
{
\xsim_set_property:nVne {#1} \g_xsim_exercise_id_tl {##1}
{ \fp_to_decimal:c {l__xsim_temporary_##1_fp} }
}
}
}
\prg_new_conditional:Npnn \xsim_exercise_if_use:nn #1#2 {T,F,TF}
{
\xsim_if_boolean_property:nnnTF {#1} {#2} {use!}
{ \prg_return_true: }
{
\xsim_if_tagged_use:nnTF {#1} {#2}
{
\xsim_if_boolean_property:nnnTF {#1} {#2} {(used)}
{ \prg_return_false: }
{
\xsim_if_insert_mode:TF
{
\xsim_if_property_set:nnnTF {#1} {#2} {use}
{
\xsim_if_boolean_property:nnnTF {#1} {#2} {use}
{ \prg_return_true: }
{ \prg_return_false: }
}
{
\bool_if:cTF {l__xsim_#1_exercise_use_bool}
{ \prg_return_false: }
{ \prg_return_true: }
}
}
{
\xsim_if_property_set:nnnTF {#1} {#2} {use}
{
\xsim_if_boolean_property:nnnTF {#1} {#2} {use}
{ \prg_return_true: }
{ \prg_return_false: }
}
{
\bool_if:cTF {l__xsim_#1_exercise_use_bool}
{ \prg_return_true: }
{ \prg_return_false: }
}
}
}
}
{ \prg_return_false: }
}
}
\prg_generate_conditional_variant:Nnn \xsim_exercise_if_use:nn {nV} {T,TF}
% #1: type
% #2: ID
\cs_new_protected:Npn \xsim_exercise_use_setup:nn #1#2
{
\stepcounter { \xsim_get_parameter:nn {#1} {number} }
\xsim_step_exercise_counter:nn {#1} {#2}
\xsim_set_properties:nne {#1} {#2}
{
section-value = \arabic{section} ,
section = \thesection ,
page-value = \arabic{page} ,
sectioning =
{ \cs_if_exist:NTF \thechapter { \arabic {chapter} } {0} }
{ \arabic {section} }
{ \arabic {subsection} }
{ \arabic {subsubsection} }
{ \arabic {paragraph} } ,
page = \thepage
}
\xsim_if_property_exist:nT {chapter}
{
\xsim_set_properties:nne {#1} {#2}
{
chapter-value = \arabic{chapter} ,
chapter = \thechapter
}
}
}
\cs_generate_variant:Nn \xsim_exercise_use_setup:nn {nV}
\prg_new_conditional:Npnn \xsim_exercise_if_print:nn #1#2 {T,F,TF}
{
\xsim_if_boolean_property:nnnTF {#1} {#2} {print!}
{ \prg_return_true: }
{
\xsim_if_tagged:nnTF {#1} {#2}
{
\xsim_if_insert_mode:TF
{ \prg_return_true: }
{
\bool_if:cTF {l__xsim_#1_exercise_print_bool}
{
\xsim_if_property_set:nnnTF {#1} {#2} {print}
{
\xsim_if_boolean_property:nnnTF {#1} {#2} {print}
{ \prg_return_true: }
{ \prg_return_false: }
}
{ \prg_return_true: }
}
{
\xsim_if_boolean_property:nnnTF {#1} {#2} {print}
{ \prg_return_true: }
{ \prg_return_false: }
}
}
}
{ \prg_return_false: }
}
}
\prg_generate_conditional_variant:Nnn \xsim_exercise_if_print:nn {nV} {T,TF}
% #1: type
% #2: ID
\cs_new_protected:Npn \xsim_exercise_print_setup:nn #1#2
{
\xsim_foreach_goal:n
{
\xsim_if_property_set:nnnT {#1} {#2} {body##1}
{ \xsim_set_property:nnnn {#1} {#2} {body##1} {0} }
}
}
\cs_generate_variant:Nn \xsim_exercise_print_setup:nn {nV}
% #1: type
% #2: options
\cs_new_protected:Npn \xsim_start_exercise:nn #1#2
{
\xsim_if_insert_mode:F { \xsim_exercise_setup:nn {#1} {#2} }
\xsim_exercise_if_use:nVT {#1} \g_xsim_exercise_id_tl
{ \xsim_exercise_use_setup:nV {#1} \g_xsim_exercise_id_tl }
\xsim_exercise_if_print:nVT {#1} \g_xsim_exercise_id_tl
{ \xsim_exercise_print_setup:nV {#1} \g_xsim_exercise_id_tl }
\tl_set_eq:NN \ExerciseID \g_xsim_exercise_id_tl
\tl_set:Nn \ExerciseType {#1}
\xsim_verbose:x
{ Starting~ exercise~ type~ `#1' with~ id~ ` \g_xsim_exercise_id_tl '. }
\xsim_if_insert_mode:F { \xsim_collect:nV {#1} \g_xsim_exercise_id_tl }
}
% #1: type
\cs_new_protected:Npn \xsim_stop_exercise:n #1
{
\tl_set_eq:NN \ExerciseID \g_xsim_exercise_id_tl
\tl_set:Nn \ExerciseType {#1}
\xsim_if_insert_mode:F
{
\xsim_foreach_goal:n
{
\xsim_if_property_set:nVnTF {#1} \g_xsim_exercise_id_tl {##1}
{
\fp_set:Nn \l__xsim_tmpa_fp
{ \xsim_get_property:nVn {#1} \g_xsim_exercise_id_tl {body##1} + 0 }
\fp_set:Nn \l__xsim_tmpb_fp
{ \xsim_get_property:nVn {#1} \g_xsim_exercise_id_tl {user##1} + 0 }
\fp_set:Nn \l__xsim_tmpa_fp { \l__xsim_tmpa_fp + \l__xsim_tmpb_fp }
\xsim_set_property:nVne {#1} \g_xsim_exercise_id_tl {##1}
{ \fp_to_decimal:N \l__xsim_tmpa_fp }
}
{
\xsim_if_property_set:nVnT {#1} \g_xsim_exercise_id_tl {body##1}
{ \xsim_set_property:nVnn {#1} \g_xsim_exercise_id_tl {##1} {0} }
}
}
}
\xsim_exercise_if_print:nVT {#1} \g_xsim_exercise_id_tl
{
\xsim_set_property:nVnn {#1} \g_xsim_exercise_id_tl {(printed)} {true}
\xsim_set_property:nVnn {#1} \g_xsim_exercise_id_tl {printed} {true}
}
\xsim_exercise_if_use:nVT {#1} \g_xsim_exercise_id_tl
{
\xsim_add_to_list:nV {order} \g_xsim_exercise_id_tl
\xsim_set_property:nVnn {#1} \g_xsim_exercise_id_tl {(used)} {true}
\xsim_set_property:nVnn {#1} \g_xsim_exercise_id_tl {used} {true}
\xsim_update_goals:nV {#1} \g_xsim_exercise_id_tl
}
}
% ----------------------------------------------------------------------------
\xsim_new_aux_property:cpn {total-number} #1
{ \int_gset:Nn \g_xsim_max_id_int {#1} }
\hook_gput_code:nnn {begindocument/before} {xsim}
{
\xsim_foreach_exercise_type:n
{
\tl_new:c { number of #1 s }
\tl_gset:cn { number of #1 s } {0}
\xsim_new_aux_property:cpn {#1} ##1
{ \tl_gset:cn { number of #1 s } {##1} }
}
}
\xsim_at_begin_document:n
{
\xsim_foreach_exercise_type:n
{
\xsim_write_to_aux:x
{ \token_to_str:N \providecommand \token_to_str:N \numberof #1 s {} }
}
}
\xsim_at_end_document:n
{
\xsim_if_clear_aux:T
{
\int_compare:nNnF { \g_xsim_max_id_int } = { \g_xsim_id_int }
{ \xsim_empty_lists: }
}
\xsim_add_property_to_aux:nn {total-number} { { \int_use:N \g_xsim_id_int } }
\xsim_foreach_exercise_type:n
{
\xsim_add_property_to_aux:nn {#1}
{ { \arabic { \xsim_get_parameter:nn {#1} {number} } } }
}
\xsim_update_list:n {types}
\xsim_update_list:n {idtypes}
}
\XSIMmoduleend
\XSIMmodule{solutions}{managing solutions}
\bool_new:N \l_xsim_inside_solution_bool
\bool_new:N \l__xsim_include_question_bool
\bool_new:N \l__xsim_printsolutions_headings_bool
\bool_new:N \l__xsim_printsolutions_conditions_bool
\bool_new:N \l____xsim_this_condition_bool
\seq_new:N \l__xsim_printsolutions_conditions_seq
\int_new:N \l_xsim_printsolutions_section_int
\int_new:N \l_xsim_printsolutions_chapter_int
\tl_new:N \l__xsim_printsolutions_headings_template_tl
\tl_new:N \ExerciseSection
\tl_new:N \ExerciseChapter
\tl_new:N \l__xsim_printsolutions_collection_tl
% ----------------------------------------------------------------------------
\prg_new_conditional:Npnn \xsim_if_inside_solution: {p,T,F,TF}
{
\bool_if:NTF \l_xsim_inside_solution_bool
{ \prg_return_true: }
{ \prg_return_false: }
}
\prg_new_conditional:Npnn \xsim_if_solution_print:n #1 {p,T,F,TF}
{
\bool_if:cTF {l__xsim_#1_solution_print_bool}
{ \prg_return_true: }
{ \prg_return_false: }
}
\bool_new:N \l____xsim_print_bool
% #1: type
% #2: id
\prg_new_protected_conditional:Npnn \xsim_solution_if_print:nn #1#2 {T,F,TF}
{
\bool_set_true:N \l____xsim_print_bool
\xsim_if_tagged:nnF {#1} {#2}
{ \bool_set_false:N \l____xsim_print_bool }
\xsim_if_boolean_property:nnnF {#1} {#2} {(used)}
{ \bool_set_false:N \l____xsim_print_bool }
\bool_if:cF {l__xsim_#1_solution_print_bool}
{ \bool_set_false:N \l____xsim_print_bool }
\bool_if:NTF \l____xsim_print_bool
{ \prg_return_true: }
{ \prg_return_false: }
}
\cs_generate_variant:Nn \xsim_solution_if_print:nnT {nV,oo}
% #1: type
% #2: id
\prg_new_protected_conditional:Npnn \xsim_if_solution_exist:nn #1#2 {T,F,TF}
{
\xsim_if_boolean_property:nnnTF {#1} {#2} {solution}
{ \xsim_if_exist:nnnTF {#1} {#2} {exercise} }
{ \xsim_if_exist:nnnTF {#1} {#2} {solution} }
{ \prg_return_true: }
{ \prg_return_false: }
}
\cs_generate_variant:Nn \xsim_if_solution_exist:nnT {VV,oo}
\cs_generate_variant:Nn \xsim_if_solution_exist:nnTF {oo}
% #1: type
% #2: options
\cs_new_protected:Npn \xsim_start_solution:nn #1#2
{
\keys_set:xn { xsim/\xsim_get_parameter:nn {#1} {solution-env} } {#2}
\bool_set_true:N \l_xsim_inside_solution_bool
\refstepcounter { \xsim_get_parameter:nn {#1} {solution-counter} }
}
\cs_new_protected:Npn \xsim_stop_solution:n #1 {}
% ----------------------------------------------------------------------------
% #1: conditional base function (three n args)
% #2: name
% #3: code (refer to type and id with `#1' and `#2'), #3 refers to the boolean
% properties use/print
\cs_new_protected:Npn \xsim_new_solutions_condition:Nnn #1#2#3
{
\prg_new_protected_conditional:Npnn #1 ##1##2##3 {T,F,TF}
{
\xsim_if_in_list:nnTF {##3} {##1-##2=={true}}
{
\__xsim_printsolutions_if_condition:nTF {#2}
{ \__xsim_printsolutions_condition_true: #3 }
{ \prg_return_false: }
}
{ \prg_return_false: }
}
}
% per section condition:
\xsim_new_solutions_condition:Nnn \__xsim_if_solutions_per_section:nnn
{per-section}
{
\xsim_if_in_list:nxTF {section-value}
{ #1-#2 == { \int_use:N \l_xsim_printsolutions_section_int } }
{
\tl_set:Nx \ExerciseSection
{ \xsim_get_property:nnn {#1} {#2} {section} }
\prg_return_true:
}
{ \prg_return_false: }
}
% per chapter condition:
\xsim_new_solutions_condition:Nnn \__xsim_if_solutions_per_chapter:nnn
{per-chapter}
{
\xsim_if_in_list:nxTF {chapter-value}
{ #1-#2 == { \int_use:N \l_xsim_printsolutions_chapter_int } }
{
\tl_set:Nx \ExerciseChapter
{ \xsim_get_property:nnn {#1} {#2} {chapter} }
\prg_return_true:
}
{ \prg_return_false: }
}
% per collection condition:
\xsim_new_solutions_condition:Nnn \__xsim_if_solutions_in_collection:nnn
{per-collection}
{
\tl_if_blank:VTF \l__xsim_printsolutions_collection_tl
{ \prg_return_false: }
{
\xsim_if_in_collection:VnnTF
\l__xsim_printsolutions_collection_tl
{#1}
{#2}
{ \prg_return_true: }
{ \prg_return_false: }
}
}
% ----------------------------------------------------------------------------
% conditions mechanism
\cs_new_protected:Npn \__xsim_printsolutions_condition_false:
{ \bool_set_false:N \l__xsim_printsolutions_conditions_bool }
\cs_new_protected:Npn \__xsim_printsolutions_condition_true:
{ \bool_set_true:N \l__xsim_printsolutions_conditions_bool }
% #1: type
% #2: id
% #3: boolean property
\prg_new_conditional:Npnn
\__xsim_printsolutions_if_conditions:nnn #1#2#3 {T,F,TF}
{
\bool_if:NTF \l__xsim_printsolutions_conditions_bool
{ \prg_return_true: }
{
\xsim_if_in_list:nnTF {#3} {#1-#2=={true}}
{ \prg_return_false: }
{ \prg_return_true: }
}
}
% #1: name
% #2: condition
\cs_new_protected:Npn \xsim_declare_printsolutions_condition:nn #1#2
{
\bool_new:c {l__xsim_printsolutions_#1_condition_bool}
\seq_put_right:Nn \l__xsim_printsolutions_conditions_seq {#1}
\xsim_attribute_set:nnn {printsolutions} {#1} {#2}
}
\prg_new_conditional:Npnn \__xsim_printsolutions_if_condition:n #1 {T,F,TF}
{
\bool_if:cTF {l__xsim_printsolutions_#1_condition_bool}
{ \prg_return_true: }
{ \prg_return_false: }
}
% #1: name
% #2: true|false
\cs_new_protected:Npn \__xsim_printsolutions_condition:nn #1#2
{ \bool_set_eq:cc {l__xsim_printsolutions_#1_condition_bool} {c_#2_bool} }
% false if any condition is false for this solution:
% #1: type
% #2: id
% #3: boolean property
\prg_new_protected_conditional:Npnn
\__xsim_printsolutions_check_conditions:nnn #1#2#3 {T,F,TF}
{
\__xsim_printsolutions_condition_false:
\bool_set_true:N \l____xsim_this_condition_bool
\seq_map_inline:Nn \l__xsim_printsolutions_conditions_seq
{
\bool_if:cT {l__xsim_printsolutions_##1_condition_bool}
{
\xsim_attribute_get:nn {printsolutions} {##1}
{#1} {#2} {#3}
{ }
{ \bool_set_false:N \l____xsim_this_condition_bool }
}
}
\bool_if:NTF \l____xsim_this_condition_bool
{ \prg_return_true: }
{ \prg_return_false: }
}
% #1: type
% #2: id
% #3: boolean property
% #4: code
\cs_new_protected:Npn \xsim_if_this_solution_do:nnnn #1#2#3#4
{
\xsim_if_solution_exist:nnT {#1} {#2}
{ \__xsim_printsolutions_check_conditions:nnnT {#1} {#2} {#3} {#4} }
}
\cs_generate_variant:Nn \xsim_if_this_solution_do:nnnn {nV}
% #1: type
% #2: boolean property
% #3: code
\cs_new_protected:Npn \xsim_if_solutions_do:nnn #1#2#3
{
\xsim_foreach_exercise:nn {#2}
{
\str_if_eq:nnT {#1} {##1}
{
\xsim_if_this_solution_do:nnnn
{#1}
{##2}
{#2}
{#3}
}
}
}
\cs_generate_variant:Nn \str_if_eq:nnT {nV}
% ----------------------------------------------------------------------------
% #1: boolean -- if true only the solutions of printed exercises will be
% output
% #2: pre
% #3: post
% #4: type
% #5: code (refer to type with #1 and id with #2)
\cs_new_protected:Npn \xsim_print_type_code:nnnnn #1#2#3#4#5
{
\group_begin:
\cs_set_protected:Npn \__xsim_print_entry:nn ##1##2 {#5}
#2
\bool_set_false:N \l__xsim_tmpa_bool
\bool_if:nTF {#1}
{
\xsim_if_solutions_do:nnn {#4} {printed}
{ \bool_set_true:N \l__xsim_tmpa_bool }
}
{
\xsim_if_solutions_do:nnn {#4} {used}
{ \bool_set_true:N \l__xsim_tmpa_bool }
}
\tl_set:Nn \ExerciseType {#4}
\bool_if:NT \l__xsim_tmpa_bool
{
\bool_if:NT \l__xsim_printsolutions_headings_bool
{
\xsim_use_template:nV
{heading}
\l__xsim_printsolutions_headings_template_tl
}
}
\bool_if:nTF {#1}
{
\xsim_if_solutions_do:nnn {#4} {printed}
{ \__xsim_print_entry:nn {#4} {##2} }
}
{
\xsim_if_solutions_do:nnn {#4} {used}
{ \__xsim_print_entry:nn {#4} {##2} }
}
#3
\group_end:
}
% #1: boolean -- if true only the solutions of printed exercises will be
% output
% #2: options
% #3: type
\cs_new_protected:Npn \xsim_print_type_solutions:nnn #1#2#3
{
\xsim_print_type_code:nnnnn
{#1}
{
\xsim_verbose:n
{ Printing~ solutions~ for~ exercise~ type~ `#3'. }
\keys_set:nn {xsim/print-solutions} {#2}
}
{}
{#3}
{ \xsim_insert:nnnn {##1} {##2} {} {solution} }
}
% #1: boolean -- if true only the solutions of printed exercises will be
% output
% #2: options
\cs_new_protected:Npn \xsim_print_all_solutions_per_type:nn #1#2
{
\xsim_foreach_exercise_type:n
{ \xsim_print_type_solutions:nnn {#1} {#2} {##1} }
}
% #1: boolean -- if true only the solutions of printed exercises will be
% output
% #2: options
\cs_new_protected:Npn \xsim_print_all_solutions_per_id:nn #1#2
{
\xsim_verbose:n { Printing~ solutions. }
\group_begin:
\keys_set:nn {xsim/print-solutions} {#2}
\bool_set_false:N \l__xsim_tmpa_bool
\bool_if:nTF {#1}
{
\xsim_foreach_exercise_id_type:nn {print}
{
\xsim_if_this_solution_do:nnnn {##1} {##2} {print}
{ \xsim_insert:nnnn {##1} {##2} {} {solution} }
}
}
{
\xsim_foreach_exercise_id_type:nn {used}
{
\xsim_if_this_solution_do:nnnn {##1} {##2} {used}
{ \xsim_insert:nnnn {##1} {##2} {} {solution} }
}
}
\group_end:
}
% ----------------------------------------------------------------------------
\xsim_declare_printsolutions_condition:nn {per-section}
{ \__xsim_if_solutions_per_section:nnnTF }
\xsim_declare_printsolutions_condition:nn {per-chapter}
{ \__xsim_if_solutions_per_chapter:nnnTF }
\xsim_declare_printsolutions_condition:nn {per-collection}
{ \__xsim_if_solutions_in_collection:nnnTF }
% ----------------------------------------------------------------------------
\keys_define:nn {xsim/print-solutions}
{
headings .bool_set:N = \l__xsim_printsolutions_headings_bool ,
headings .initial:n = true ,
headings-template .tl_set:N = \l__xsim_printsolutions_headings_template_tl ,
headings-template .initial:n = default ,
include-exercise .bool_set:N = \l__xsim_include_question_bool ,
include-exercise .initial:n = false ,
section .choice: ,
section/true .code:n =
\__xsim_printsolutions_condition:nn {per-section} {true}
\int_set:Nn \l_xsim_printsolutions_section_int { \value {section} } ,
section/false .code:n =
\__xsim_printsolutions_condition:nn {per-section} {false} ,
section/unknown .code:n =
\__xsim_printsolutions_condition:nn {per-section} {true}
\int_set:Nn \l_xsim_printsolutions_section_int {#1} ,
section .default:n = true ,
section .initial:n = false ,
chapter .choice: ,
chapter/true .code:n =
\__xsim_printsolutions_condition:nn {per-chapter} {true}
\int_set:Nn \l_xsim_printsolutions_chapter_int { \value {chapter} } ,
chapter/false .code:n =
\__xsim_printsolutions_condition:nn {per-chapter} {false} ,
chapter/unknown .code:n =
\__xsim_printsolutions_condition:nn {per-chapter} {true}
\int_set:Nn \l_xsim_printsolutions_chapter_int {#1} ,
chapter .default:n = true ,
chapter .initial:n = false ,
collection .choice: ,
collection/false .code:n =
\__xsim_printsolutions_condition:nn {per-collection} {false} ,
collection/unknown .code:n =
\xsim_if_collection_exist:nT {#1}
{
\__xsim_printsolutions_condition:nn {per-collection} {true}
\tl_set:Nn \l__xsim_printsolutions_collection_tl {#1}
} ,
collection .initial:n = false
}
\XSIMmoduleend
\XSIMmodule{collections}{collect exercises and print collected exercises}
\seq_new:N \g__xsim_collections_seq
\bool_new:N \l____xsim_active_bool
\msg_new:nnn {xsim} {collection-exists}
{
The~ collection~ `#1'~ you're~ trying~ to~ define~ \msg_line_context:
\c_space_tl already~ exists.
}
\msg_new:nnn {xsim} {collection-unknown}
{
The~ collection~ `#1'~ does~ not~ seem~ to~ exist~ \msg_line_context: .
If~ this~ is~ not�� a~ typo~ define~ it~ first.
}
\msg_new:nnn {xsim} {collection-activate}
{
The~ collection~ `#1'~ is~ already~ active~ \msg_line_context: .~
Not~ activating~ it~ now.
}
\msg_new:nnn {xsim} {collection-deactivate}
{
The~ collection~ `#1'~ is~ not~ active~ \msg_line_context: .~
Not~ deactivating~ it~ now.
}
\msg_new:nnn {xsim} {print-collection-choice}
{
The~ choice~ `#1'~ neither~ exists~ for~ `print-collection/print'~ nor~
for~ `random/print'.~ I'm~ using~ `exercises'~ instead~ \msg_line_context: .
}
% ----------------------------------------------------------------------------
\xsim_declare_property:nnnn
{ \c_false_bool }
{ \c_false_bool }
{ \c_false_bool }
{collections}
% #1: collection name
% #2: conditions: clist of <tag>=<value>
\cs_new_protected:Npn \xsim_new_collection:nn #1#2
{
\xsim_if_collection_exist:nTF {#1}
{ \msg_error:nnn {xsim} {collection-exists} {#1} }
{
\xsim_verbose:n { Declaring~ new~ collection~ `#1'. }
\xsim_attribute_new:nn {collection} {#1}
\xsim_attribute_set:nnn {collection} {#1} { \c_false_bool }
\xsim_attribute_new:nn {collection:conditions} {#1}
\xsim_attribute_set:nnn {collection:conditions} {#1} {#2}
\seq_gput_right:Nn \g__xsim_collections_seq {#1}
\xsim_new_list:n {collection:#1}
\bool_new:c {l__xsim_collection_#1_condition_all_bool}
\keys_define:nn {xsim/collection/#1}
{
match-all .bool_set:c = {l__xsim_collection_#1_condition_all_bool} ,
match-all .initial:n = true ,
match-any .bool_set_inverse:c = {l__xsim_collection_#1_condition_all_bool}
}
\xsim_before_begin_document:n
{
\xsim_foreach_exercise_type:n
{
\int_new:c {g_xsim_collection_##1_in_#1_int}
\newcounter {total##1in#1}
}
}
\xsim_at_end_document:n
{
\xsim_update_list:n {collection:#1}
\xsim_foreach_exercise_type:n
{
\xsim_write_to_aux:x
{
\token_to_str:N \setcounter {total##1in#1}
{ \int_use:c {g_xsim_collection_##1_in_#1_int} }
}
}
}
}
}
% #1: collection name
\prg_new_conditional:Npnn \xsim_if_collection_exist:n #1 {T,F,TF}
{
\seq_if_in:NnTF \g__xsim_collections_seq {#1}
{ \prg_return_true: }
{ \prg_return_false: }
}
\cs_new_protected:Npn \xsim_foreach_collection:n #1
{ \seq_map_inline:Nn \g__xsim_collections_seq {#1} }
\cs_new:Npn \xsim_collection_map_break: { \seq_map_break: }
% ----------------------------------------------------------------------------
% #1: collection name
\prg_new_conditional:Npnn \xsim_if_collection_active:n #1 {T,F,TF}
{
\xsim_attribute_if_set:nnTF {collection} {#1}
{
\bool_if:nTF
{ \xsim_attribute_get:nn {collection} {#1} }
{ \prg_return_true: }
{ \prg_return_false: }
}
{ \prg_return_false: }
}
% #1: collection name
\cs_new_protected:Npn \xsim_activate_collection:n #1
{
\xsim_if_collection_exist:nTF {#1}
{
\xsim_if_collection_active:nTF {#1}
{ \msg_warning:nnn {xsim} {collection-activate} {#1} }
{
\xsim_verbose:n { Activating~ collection~ `#1'. }
\xsim_attribute_set:nnn {collection} {#1} { \c_true_bool }
}
}
{ \msg_error:nnn {xsim} {collection-unknown} {#1} }
}
% #1: collection name
\cs_new_protected:Npn \xsim_deactivate_collection:n #1
{
\xsim_if_collection_exist:nTF {#1}
{
\xsim_if_collection_active:nTF {#1}
{
\xsim_verbose:n { Deactivating~ collection~ `#1'. }
\xsim_attribute_set:nnn {collection} {#1} { \c_false_bool }
}
{ \msg_warning:nnn {xsim} {collection-deactivate} {#1} }
}
{ \msg_error:nnn {xsim} {collection-unknown} {#1} }
}
% #1: csv list of collections
% #2: type
\cs_new_protected:Npn \xsim_collect_type_start:nn #1#2
{
\group_begin:
\keys_set:nn {xsim} { #2/collect = true }
\clist_map_inline:nn {#1}
{
\xsim_if_collection_active:nF {##1}
{ \xsim_activate_collection:n {##1} }
}
}
% #1: csv list of collections
\cs_new_protected:Npn \xsim_collect_start:n #1
{
\group_begin:
\xsim_foreach_exercise_type:n
{
\keys_set:nx {xsim}
{ \xsim_get_parameter:nn {##1} {exercise-env} / collect = true }
}
\clist_map_inline:nn {#1}
{
\xsim_if_collection_active:nF {##1}
{ \xsim_activate_collection:n {##1} }
}
}
% #1: csv list of collections
\cs_new_protected:Npn \xsim_collect_stop:n #1
{
\clist_map_inline:nn {#1} { \xsim_deactivate_collection:n {##1} }
\group_end:
}
\keys_define:nn {xsim}
{
collect .code:n =
\xsim_foreach_exercise_type:n
{
\keys_set:nx {xsim}
{ \xsim_get_parameter:nn {##1} {exercise-env} / collect = #1 }
} ,
collect .default:n = true ,
collect .initial:n = false
}
% ----------------------------------------------------------------------------
% #1: collection name
% #2: type
% #3: ID
\prg_new_conditional:Npnn \xsim_if_in_collection:nnn #1#2#3 {T,F,TF}
{
\xsim_if_in_list:nnTF {collection:#1} {#2-#3}
{ \prg_return_true: }
{ \prg_return_false: }
}
\cs_generate_variant:Nn \xsim_if_in_collection:nnnTF {V}
\cs_generate_variant:Nn \xsim_if_in_collection:nnnT {x,nV}
\cs_new:Npn \xsim_collection_count:n #1
{ \xsim_list_count:n {collection:#1} }
\bool_new:N \l____xsim_collection_condition_bool
% #1: collection name
% #2: type
% #3: ID
\prg_new_protected_conditional:Npnn \xsim_collection_conditions_if:nnn #1#2#3 {T,F,TF}
{
\bool_if:cTF {l__xsim_collection_#1_condition_all_bool}
{ \bool_set_true:N \l____xsim_collection_condition_bool }
{ \bool_set_false:N \l____xsim_collection_condition_bool }
\clist_set:Nx \l__xsim_tmpa_clist
{ \xsim_attribute_get:nn {collection:conditions} {#1} }
\clist_if_empty:NTF \l__xsim_tmpa_clist
{ \bool_set_true:N \l____xsim_collection_condition_bool }
{
\clist_map_inline:Vn
\l__xsim_tmpa_clist
{
\tl_set:Nx \l__xsim_tmpa_tl
{ \__xsim_get_condition_tag:w ##1 \q_stop }
\tl_set:Nx \l__xsim_tmpb_tl
{ \__xsim_get_condition_values:w ##1 \q_stop }
\xsim_if_tag_type_exist:VTF \l__xsim_tmpa_tl
{
\bool_if:cTF {l__xsim_collection_#1_condition_all_bool}
{
\xsim_has_tags:nnVVF {#2} {#3} \l__xsim_tmpa_tl \l__xsim_tmpb_tl
{
\bool_set_false:N \l____xsim_collection_condition_bool
\clist_map_break:
}
}
{
\xsim_has_tags:nnVVT {#2} {#3} \l__xsim_tmpa_tl \l__xsim_tmpb_tl
{
\bool_set_true:N \l____xsim_collection_condition_bool
\clist_map_break:
}
}
}
{ \msg_warning:nnV {xsim} {tag-unknown} \l__xsim_tmpa_tl }
}
}
\bool_if:NTF \l____xsim_collection_condition_bool
{ \prg_return_true: }
{ \prg_return_false: }
}
\cs_new:Npn \__xsim_get_condition_tag:w #1=#2 \q_stop {#1}
\cs_new:Npn \__xsim_get_condition_values:w #1=#2 \q_stop {#2}
% #1: type
% #2: ID
\cs_new_protected:Npn \xsim_collect:nn #1#2
{
\xsim_foreach_collection:n
{
\xsim_if_collection_active:nT {##1}
{
\xsim_collection_conditions_if:nnnT {##1} {#1} {#2}
{ \xsim_add_to_collection:nnn {##1} {#1} {#2} }
}
}
}
\cs_generate_variant:Nn \xsim_collect:nn {nV}
% #1: collection name
% #2: type
% #3: ID
\cs_new_protected:Npn \xsim_add_to_collection:nnn #1#2#3
{
\xsim_verbose:n
{ Adding~ exercise~ type~ `#2'~ ID~ `#3'~ to~ collection~ `#1'. }
\clist_set:Nx \l__xsim_tmpa_clist
{ \xsim_get_property:nnn {#2} {#3} {collections} }
\clist_if_in:NnF \l__xsim_tmpa_clist {#1}
{ \clist_put_right:Nn \l__xsim_tmpa_clist {#1} }
\xsim_set_property:nnnV {#2} {#3} {collections} \l__xsim_tmpa_clist
\xsim_add_to_list:nn {collection:#1} {#2-#3}
\int_gincr:c {g_xsim_collection_#2_in_#1_int}
}
% ----------------------------------------------------------------------------
\bool_new:N \l__xsim_printcollection_headings_bool
\tl_new:N \l__xsim_printcollection_headings_template_tl
\tl_new:N \l__xsim_print_collection_choice_tl
\keys_define:nn {xsim/print-collection}
{
headings .bool_set:N = \l__xsim_printcollection_headings_bool ,
headings .initial:n = false ,
headings-template .tl_set:N = \l__xsim_printcollection_headings_template_tl ,
headings-template .initial:n = collection ,
print .tl_set:N = \l__xsim_print_collection_choice_tl ,
print .initial:n = exercises
}
% #1: options
% #2: collection name
\cs_new_protected:Npn \xsim_print_collection:nn #1#2
{
\group_begin:
\keys_set:nn {xsim/print-collection} {#1}
\clist_clear:N \l__xsim_tmpa_clist
\clist_clear:N \l__xsim_tmpb_clist
\xsim_foreach_exercise_type_id:nn {}
{
\xsim_get_property_if_set:nnnT {##1} {##2} {collections}
{
\clist_if_in:NnT \l_xsim_property_value_tl {#2}
{
\str_set:Nn \l__xsim_tmpa_str {##1}
\clist_put_right:NV \l__xsim_tmpa_clist \l__xsim_tmpa_str
\clist_put_right:Nn \l__xsim_tmpb_clist {##2}
}
}
}
\xsim_foreach_exercise_type:n
{
\bool_if:NT \l__xsim_printcollection_headings_bool
{
\clist_if_in:NnT \l__xsim_tmpa_clist {##1}
{
\tl_set:Nn \ExerciseType {##1}
\xsim_use_template:nV
{heading}
\l__xsim_printcollection_headings_template_tl
}
}
\clist_map_inline:Nn \l__xsim_tmpa_clist
{
\str_if_eq:nnT {##1} {####1}
{
\clist_pop:NN \l__xsim_tmpa_clist \l__xsim_tmpa_tl
\clist_pop:NN \l__xsim_tmpb_clist \l__xsim_tmpb_tl
\str_case:Vn \l__xsim_print_collection_choice_tl
{
{exercises}
{ \xsim_insert:nVnn {##1} \l__xsim_tmpb_tl {} {exercise} }
{solutions}
{ \xsim_insert:nVnn {##1} \l__xsim_tmpb_tl {} {solution} }
{both} {
\xsim_insert:nVnn {##1} \l__xsim_tmpb_tl {} {exercise}
\xsim_insert:nVnn {##1} \l__xsim_tmpb_tl {} {solution}
}
}
}
}
}
\group_end:
}
% ----------------------------------------------------------------------------
\xsim_new_collection:nn {all~ exercises} {}
\xsim_activate_collection:n {all~ exercises}
\XSIMmoduleend
\XSIMmodule{blanks}{add blanks, cloze}
\bool_new:N \l__xsim_blank_width_bool
\bool_new:N \l__xsim_blank_linespread_bool
\bool_new:N \l__xsim_fill_blank_bool
\tl_new:N \l__xsim_blank_linespread_tl
\tl_new:N \l__xsim_blank_scale_tl
\dim_new:N \l__xsim_blank_dim
\dim_new:N \l__xsim_blank_line_increment_dim
\dim_new:N \l__xsim_blank_line_minimum_length_dim
\box_new:N \l__xsim_blank_box
\cs_new_protected:Npn \xsim_write_cloze_blank:n #1 {#1}
\cs_new_protected:Npn \xsim_write_cloze_filled:n #1 {#1}
\keys_define:nn {xsim/blank}
{
blank-style .code:n =
\cs_set_protected:Npn \xsim_write_cloze_blank:n ##1 {#1} ,
blank-style .initial:n = \underline {#1} ,
filled-style .code:n =
\cs_set_protected:Npn \xsim_write_cloze_filled:n ##1 {#1} ,
filled-style .initial:n = \underline {#1} ,
style .meta:n =
{ blank-style = #1 , filled-style = #1 } ,
fill .bool_set:N = \l__xsim_fill_blank_bool ,
fill .initial:n = false ,
scale .tl_set:N = \l__xsim_blank_scale_tl ,
scale .initial:n = 1 ,
width .code:n =
{
\bool_set_true:N \l__xsim_blank_width_bool
\dim_set:Nn \l__xsim_blank_dim {#1}
} ,
linespread .code:n =
\bool_set_true:N \l__xsim_blank_linespread_bool
\tl_set:Nn \l__xsim_blank_linespread_tl {#1} ,
linespread .initial:n = 1 ,
line-increment .dim_set:N = \l__xsim_blank_line_increment_dim ,
line-increment .initial:n = 0.001\linewidth ,
line-minimum-length .dim_set:N = \l__xsim_blank_line_minimum_length_dim ,
line-minimum-length .initial:n = 2em
}
\cs_new_protected:Npn \xsim_blank:n #1
{
\box_clear:N \l__xsim_blank_box
\mode_if_math:TF
{ \hbox_set:Nn \l__xsim_blank_box { $ \m@th \mathpalette{}{#1} $ } }
{ \hbox_set:Nn \l__xsim_blank_box {#1} }
\bool_lazy_or:nnTF
{ \xsim_if_inside_solution_p: }
{ \l__xsim_fill_blank_bool }
{ \xsim_write_cloze_filled:n {#1} }
{
\bool_if:NTF \l__xsim_blank_width_bool
{ \__xsim_blank_skip:V \l__xsim_blank_dim }
{ \__xsim_blank_skip:n { \box_wd:N \l__xsim_blank_box } }
}
}
\cs_new_protected:Npn \__xsim_blank_skip:n #1
{
\bool_if:NTF \l__xsim_blank_width_bool
{ \dim_set:Nn \l__xsim_tmpa_dim {#1} }
{
\fp_set:Nn \l__xsim_tmpa_fp
{ \dim_to_fp:n {#1} * \l__xsim_blank_scale_tl }
\dim_set:Nn \l__xsim_tmpa_dim { \fp_to_dim:N \l__xsim_tmpa_fp }
}
\dim_compare:nTF
{ \l__xsim_tmpa_dim > \l__xsim_blank_line_minimum_length_dim }
{
\mode_if_math:TF
{ \xsim_write_cloze_blank:n { \skip_horizontal:N \l__xsim_tmpa_dim } }
{
\dim_do_while:nn { \l__xsim_tmpa_dim > \c_zero_dim }
{
% I wonder what the correct l3 way would be -- if there is
% one, yet:
% \tex_hfil:D
\tex_penalty:D \hyphenpenalty
% \tex_hfilneg:D
\dim_compare:nTF
{ \l__xsim_tmpa_dim < \l__xsim_blank_line_increment_dim }
{ \xsim_write_cloze_blank:n { \skip_horizontal:N \l__xsim_tmpa_dim } }
{
\xsim_write_cloze_blank:n
{ \skip_horizontal:N \l__xsim_blank_line_increment_dim }
}
\dim_sub:Nn \l__xsim_tmpa_dim { \l__xsim_blank_line_increment_dim }
}
}
}
{
\xsim_write_cloze_blank:n
{ \skip_horizontal:N \l__xsim_blank_line_minimum_length_dim }
}
}
\cs_generate_variant:Nn \__xsim_blank_skip:n {V}
\XSIMmoduleend
\XSIMmodule{grades}{distribute goal sums to grades}
\msg_new:nnn {xsim} {grade-unknown}
{ The~ grade~ `#1'~ has~ never~ been~ declared~ \msg_line_context: }
\bool_new:N \l__xsim_grades_half_bool
\fp_new:N \l__xsim_grade_round_fp
\fp_zero:N \l__xsim_grade_round_fp
\prop_new:N \l__xsim_relative_grades_prop
\tl_new:N \l__xsim_grade_split_tl
\cs_new:Npn \__xsim_fp_round_to_half:n #1
{ round( 2*(#1),0)/2 }
\cs_new:Npn \__xsim_grades_round:n #1
{ round ( #1 , \l__xsim_grade_round_fp ) }
% #1: factor
% #2: goal sum
\cs_new:Npn \__xsim_grade_rounded:nn #1#2
{
\bool_if:NTF \l__xsim_grades_half_bool
{ \__xsim_fp_round_to_half:n }
{ \__xsim_grades_round:n }
{ (#1) * (#2) }
}
\cs_new_protected:Npn \xsim_declare_relative_grades:n #1
{
\seq_set_split:NVn \l__xsim_tmpa_seq \l__xsim_grade_split_tl {#1}
\seq_map_inline:Nn \l__xsim_tmpa_seq
{ \__xsim_declare_relative_grade:w ##1 \q_stop }
\xsim_verbose:n {Declaring~ relative~ grade~ distribution}
}
\cs_new_protected:Npn \__xsim_declare_relative_grade:w #1 = #2 \q_stop
{
\tl_set:Nx \l__xsim_tmpa_tl { \tl_trim_spaces:n {#1} }
\tl_set:Nx \l__xsim_tmpb_tl { \tl_trim_spaces:n {#2} }
\prop_put:NVV \l__xsim_relative_grades_prop
\l__xsim_tmpa_tl
\l__xsim_tmpb_tl
}
% #1: grade
% #2: sum of points
% #3: code after grade requirement if == 1
% #4: code after grade requirement if != 1
\cs_new_protected:Npn \xsim_get_grade:nnnn #1#2#3#4
{
\prop_get:NnNTF \l__xsim_relative_grades_prop {#1} \l__xsim_tmpa_tl
{
\xsim_print_goal:nnn
{
min(
\__xsim_grade_rounded:nn
{ \l__xsim_tmpa_tl }
{#2} ,
#2
)
}
{#3}
{#4}
}
{ \msg_error:nnn {xsim} {grade-unknown} {#1} }
}
% #1: grade
% #2: goal
% #3: code after grade requirement if == 1
% #4: code after grade requirement if != 1
\cs_new_protected:Npn \xsim_get_grade_goal:nnnn #1#2#3#4
{
\xsim_if_goal_exist:nTF {#2}
{
\xsim_get_grade:nnnn
{#1}
{ \use:c {g__xsim_total_goal_#2_fp} }
{#3}
{#4}
}
{ \msg_error:nnn {xsim} {goal-unknown} {#2} }
}
% #1: grade
% #2: goal list (separated with +)
% #3: code after grade requirement if == 1
% #4: code after grade requirement if != 1
\cs_new_protected:Npn \xsim_get_grade_requirement:nnnn #1#2#3#4
{
\seq_set_split:Nnn \l__xsim_tmpa_seq {+} {#2}
\fp_zero:N \l__xsim_tmpa_fp
\seq_map_inline:Nn \l__xsim_tmpa_seq
{
\fp_add:Nn \l__xsim_tmpa_fp
{ \use:c {g__xsim_total_goal_\tl_trim_spaces:n {##1} _fp} }
}
\xsim_get_grade:nnnn {#1} { \l__xsim_tmpa_fp } {#3} {#4}
}
% #1: grade
% #2: code after grade requirement if == 1
% #3: code after grade requirement if != 1
\cs_new_protected:Npn \xsim_get_absolute_grade_requirement:nnn #1#2#3
{
\fp_zero:N \l__xsim_tmpa_fp
\xsim_foreach_goal:n
{
\fp_add:Nn \l__xsim_tmpa_fp
{ \use:c {g__xsim_total_goal_##1_fp} }
}
\xsim_get_grade:nnnn {#1} { \l__xsim_tmpa_fp } {#2} {#3}
}
\keys_define:nn {xsim/grades}
{
round .fp_set:N = \l__xsim_grade_round_fp ,
half .bool_set:N = \l__xsim_grades_half_bool ,
split .tl_set:N = \l__xsim_grade_split_tl ,
split .initial:n = {,}
}
\XSIMmoduleend
\XSIMmodule{random}{randomly select exercises from collections}
\msg_new:nnn {xsim} {random-numbers-unavailable}
{
You~ are~ compiling~ your~ document~ using ~XeLaTeX.~ Please~ be~ aware~
that~ random~ selection~ of~ exercises~ is~ unavailable~ in~ XeLaTeX.~ If~
you~ use~ this~ feature~ you~ can~ safely~ ignore~ this~ message.
}
\sys_if_engine_xetex:T
{ \msg_warning:nn {xsim} {random-numbers-unavailable} }
\tl_new:N \l_xsim_random_collection_tl
\tl_new:N \l__xsim_print_random_choice_tl
\seq_new:N \g__xsim_random_list_seq
\seq_new:N \l__xsim_allowed_exercise_ids_seq
\int_new:N \g__xsim_random_list_id_int
\bool_new:N \l__xsim_sort_random_bool
\clist_new:N \l_xsim_random_exclude_list_clist
% #1: random list id
% #2: csv list of integers
\xsim_new_aux_property:cpn {random} #1#2
{
\xsim_random_list_if_exist:nF {#1}
{ \xsim_new_random_list:n {#1} }
\xsim_set_random_list:nn {#1} {#2}
}
\cs_new_protected:Npn \xsim_new_random_list:n #1
{
\xsim_verbose:n {Defining~ new~ random~ list~ `#1'}
\seq_new:c {g__xsim_random_#1 _seq}
}
\cs_new_protected:Npn \xsim_set_random_list:nn #1#2
{ \seq_gset_from_clist:cn {g__xsim_random_#1_seq} {#2} }
\cs_new_protected:Npn \xsim_set_random_list_from_seq:nN #1#2
{ \seq_gset_eq:cN {g__xsim_random_#1_seq} #2 }
\cs_new:Npn \xsim_use_random_list:nn #1#2
{ \seq_use:cn {g__xsim_random_#1_seq} {#2} }
\cs_new_protected:Npn \xsim_map_random_list:nn #1#2
{ \seq_map_inline:cn {g__xsim_random_#1_seq} {#2} }
\prg_new_conditional:Npnn \xsim_random_list_if_exist:n #1 {p,T,F,TF}
{
\seq_if_exist:cTF {g__xsim_random_#1_seq}
{ \prg_return_true: }
{ \prg_return_false: }
}
\prg_new_conditional:Npnn \xsim_random_list_if_empty:n #1 {p,T,F,TF}
{
\seq_if_empty:cTF {g__xsim_random_#1_seq}
{ \prg_return_true: }
{ \prg_return_false: }
}
% #1: random list id
% #2: sequence variable to set list from
\cs_new_protected:Npn \xsim_save_random_list:nN #1#2
{ % TODO: check if #2 is empty
\xsim_random_list_if_exist:nF {#1}
{ \xsim_new_random_list:n {#1} }
\xsim_random_list_if_empty:nT {#1}
{ \xsim_set_random_list_from_seq:nN {#1} #2 }
\xsim_verbose:n {Saving~ random~ list~ `#1'}
\xsim_add_property_to_aux:nn {random}
{ {#1} { \xsim_use_random_list:nn {#1} {,} } }
}
\cs_generate_variant:Nn \xsim_save_random_list:nN {x}
% #1: collection
% #2: number of items
% #3: clist variable of excluded ids
\cs_new_protected:Npn \xsim_print_random_list:nnN #1#2#3
{
\xsim_if_collection_exist:nTF {#1}
{
\int_gincr:N \g__xsim_random_list_id_int
\int_compare:nNnTF { \xsim_collection_count:n {#1} } = {0}
{
% TODO: message
\xsim_rerun:
}
{
% generate seq of allowed ids from collection:
\xsim_foreach_exercise_id:n
{
\xsim_get_type_for_id:nN {##1} \l__xsim_tmpa_str
\tl_set_rescan:Nnx \l__xsim_tmpa_tl {} { \l__xsim_tmpa_str }
\xsim_if_in_collection:nVnT {#1} \l__xsim_tmpa_tl {##1}
{
\clist_if_in:NnF #3 {##1}
{ \seq_put_right:Nn \l__xsim_allowed_exercise_ids_seq {##1} }
}
}
\int_compare:nNnTF
{#2}
>
{ \seq_count:N \l__xsim_allowed_exercise_ids_seq }
{
\int_set:Nn \l__xsim_tmpa_int
{ \seq_count:N \l__xsim_allowed_exercise_ids_seq }
}
{ \int_set:Nn \l__xsim_tmpa_int {#2} }
% generate random list:
\xsim_generate_random_list:nnnN
{ \int_to_alph:n { \g__xsim_random_list_id_int } }
{ \seq_count:N \l__xsim_allowed_exercise_ids_seq }
{ \l__xsim_tmpa_int }
\g__xsim_random_list_seq
}
\xsim_save_random_list:xN
{ \int_to_alph:n { \g__xsim_random_list_id_int } }
\g__xsim_random_list_seq
\xsim_verbose:x
{
Printing~ exercises~ of~ random~ list~
`\int_to_alph:n { \g__xsim_random_list_id_int }'~ of~
collection~ `#1'
}
\xsim_print_random_exercises:Nn
\l__xsim_allowed_exercise_ids_seq
{ \int_to_alph:n { \g__xsim_random_list_id_int } }
}
{ \msg_error:nnn {xsim} {unknown-collection} {#1} }
}
\cs_generate_variant:Nn \xsim_print_random_list:nnN {V}
% #1: random list id
% #2: max number to choose from
% #3: number of items
% #4: seq variable
\cs_new_protected:Npn \xsim_generate_random_list:nnnN #1#2#3#4
{
\bool_lazy_or:nnT
{ !\xsim_random_list_if_exist_p:n {#1} }
{ \xsim_random_list_if_empty_p:n {#1} }
{
\xsim_verbose:n
{Generating~ random~ list~ `#1'~ with~ #3~ out~ of~ #2~ items}
\seq_gclear:N #4
\int_compare:nNnF {#2} = 0
{
\int_do_until:nNnn { \seq_count:N #4 } = {#3}
{
\tl_set:Nx \l__xsim_tmpa_tl
{ \fp_eval:n { randint(#2) } }
\seq_if_in:NVF #4
\l__xsim_tmpa_tl
{ \seq_gput_right:NV #4 \l__xsim_tmpa_tl }
}
}
\bool_if:NT \l__xsim_sort_random_bool
{
\seq_gsort:Nn #4
{
\int_compare:nNnTF {##1} > {##2}
{ \sort_return_swapped: }
{ \sort_return_same: }
}
}
}
}
% #1: seq variable of ids
% #2: random list id
\cs_new_protected:Npn \xsim_print_random_exercises:Nn #1#2
{
\seq_if_empty:NF #1
{
\bool_lazy_and:nnT
{ \xsim_random_list_if_exist_p:n {#2} }
{ !\xsim_random_list_if_empty_p:n {#2} }
{
\xsim_verbose:x
{
Printing~
\str_case:Vn \l__xsim_print_random_choice_tl
{
{exercises} {exercises~}
{solutions} {solutions~}
{both} { exercises~ and~ solutions~ }
}
of~ random~ list~ `#2'.
}
\xsim_map_random_list:nn {#2}
{
\tl_set:Nx \l__xsim_tmpa_tl
{ \seq_item:Nn #1 {##1} }
\tl_set:Nx \l__xsim_tmpb_tl
{ \xsim_get_type_for_property:nV {id} \l__xsim_tmpa_tl }
\bool_set_false:N \l__xsim_tmpa_bool
\bool_set_false:N \l__xsim_tmpb_bool
\str_case:VnF \l__xsim_print_random_choice_tl
{
{exercises} { \bool_set_true:N \l__xsim_tmpa_bool }
{solutions} { \bool_set_true:N \l__xsim_tmpb_bool }
{both} {
\bool_set_true:N \l__xsim_tmpa_bool
\bool_set_true:N \l__xsim_tmpb_bool
}
}
{
\msg_warning:nnV {xsim}
{print-collection-choice}
\l__xsim_print_random_choice_tl
}
\bool_if:NT \l__xsim_tmpa_bool
{
\xsim_if_exercise_exist:VVT
\l__xsim_tmpb_tl
\l__xsim_tmpa_tl
{
\xsim_insert:VVnn
\l__xsim_tmpb_tl
\l__xsim_tmpa_tl
{}
{exercise}
}
}
\bool_if:NT \l__xsim_tmpb_bool
{
\xsim_if_solution_exist:VVT
\l__xsim_tmpb_tl
\l__xsim_tmpa_tl
{
\xsim_insert:VVnn
\l__xsim_tmpb_tl
\l__xsim_tmpa_tl
{}
{solution}
}
}
}
}
}
}
\keys_define:nn {xsim/random}
{
sort .bool_set:N = \l__xsim_sort_random_bool ,
sort .initial:n = true ,
collection .tl_set:N = \l_xsim_random_collection_tl ,
collection .initial:n = all~exercises ,
exclude .code:n = \__xsim_exclude_ids:n {#1} ,
print .tl_set:N = \l__xsim_print_random_choice_tl ,
print .initial:n = exercises
}
\cs_new_protected:Npn \__xsim_exclude_ids:n #1
{
\seq_clear:N \l__xsim_tmpa_seq
\clist_map_inline:nn {#1}
{
\tl_set:Nx \l__xsim_tmpa_tl
{ \xsim_get_id_for_property:nn {ID} {##1} }
\tl_if_blank:VTF \l__xsim_tmpa_tl
{ \seq_put_right:Nn \l__xsim_tmpa_seq {##1} }
{
\seq_put_right:Nx \l__xsim_tmpa_seq
{ \xsim_get_id_for_property:nn {ID} {##1} }
}
}
\seq_remove_duplicates:N \l__xsim_tmpa_seq
\clist_set_from_seq:NN
\l_xsim_random_exclude_list_clist
\l__xsim_tmpa_seq
}
\XSIMmoduleend
\XSIMmodule{translations}{language settings for XSIM}
\RequirePackage{translations}
\msg_new:nnn {xsim} {language-not-defined}
{
You~ chose~ the~ language~ `#1'~ which~ is~ not~ defined~ by~ xsim.~
`english'~ is~ used~ instead.~ If~ you~ just~ mistyped~ try~ again!~
Otherwise~ contact~ the~ author~ and~ he'll~ probably~ add~ your~
language.
}
\msg_new:nnn {xsim} {empty-translation}
{
No~ translation~ provided~ for~ key~ `#1'~ in~ language~ `#2'~
\msg_line_context: .
}
% --------------------------------------------------------------------------
\bool_new:N \l__xsim_language_auto_bool
\bool_set_true:N \l__xsim_language_auto_bool
% this token list will hold the chosen language for xsim; since the
% language is either chosen automatically or by option it is only available at
% begin document
\tl_new:N \l_xsim_language_tl
\tl_set:Nn \l_xsim_language_tl {english}
\tl_new:N \l__xsim_current_language_tl
\tl_const:Nn \c__xsim_keyword_prefix_tl {xsim-keyword-}
% ----------------------------------------------------------------------------
\prop_new:N \g_xsim_translations_prop
% translate the key #1
\cs_new:Npn \xsim_translate:n #1
{
\bool_if:NTF \l__xsim_language_auto_bool
{ \GetTranslation { \c__xsim_keyword_prefix_tl #1 } }
{
\GetTranslationFor
{ \l_xsim_language_tl }
{ \c__xsim_keyword_prefix_tl #1 }
}
}
\xsim_at_begin_document:n
{
\bool_if:NTF \l__xsim_language_auto_bool
{
\tl_set:Nx \l_xsim_language_tl
{ \@trnslt@language{\@trnslt@current@language} }
}
{
\tl_set_eq:NN
\l_xsim_language_tl
\l__xsim_current_language_tl
}
}
% ----------------------------------------------------------------------------
% #1: language
% #2: keyword
% #3: translation
\cs_new_protected:Npn \xsim_declare_translation:nnn #1#2#3
{
\xsim_verbose:n
{ Declaring~ `#1'~ tranlation~ of~ `#2':~ `#3'. }
\declaretranslation
{#1}
{ \c__xsim_keyword_prefix_tl #2 }
{#3}
\prop_gput:Nnn \g_xsim_translations_prop {#2(#1)} {#3}
}
\cs_generate_variant:Nn \xsim_declare_translation:nnn {V,VnV}
% #1: key
% #2: csv list: { <lang1> = <translation1> , <lang2> = <translation2> }
\cs_new_protected:Npn \xsim_declare_translations:nn #1#2
{
\cs_set_protected:Npn \__xsim_declare_translation:n ##1
{ \msg_warning:nnnn {xsim} {empty-translation} {#1} {##1} }
\cs_set_protected:Npn \__xsim_declare_translation:nn ##1##2
{ \xsim_declare_translation:nnn {##1} {#1} {##2} }
\keyval_parse:NNn
\__xsim_declare_translation:n
\__xsim_declare_translation:nn
{#2}
}
\cs_new:Npn \__xsim_parse_translate_list_entry:nnn #1#2#3 {}
\cs_new_protected:Npn \__xsim_parse_translate_list_entry:www #1(#2)\q_mark#3\q_stop
{ \__xsim_parse_translate_list_entry:nnn {#1} {#2} {#3} }
\cs_new_protected:Npn \xsim_for_all_translations_do:n #1
{
\cs_set:Npn \__xsim_parse_translate_list_entry:nnn ##1##2##3 {#1}
\prop_map_inline:Nn \g_xsim_translations_prop
{ \__xsim_parse_translate_list_entry:www ##1 \q_mark ##2 \q_stop }
}
% ----------------------------------------------------------------------------
\keys_define:nn {xsim}
{
language .value_required:n = true ,
language .code:n =
\tl_if_eq:nnTF {#1} {auto}
{ \bool_set_true:N \l__xsim_language_auto_bool }
{
\bool_set_false:N \l__xsim_language_auto_bool
\tl_set:Nn \l__xsim_current_language_tl {#1}
} ,
language .initial:n = auto
}
\XSIMmoduleend
\XSIMmodule{interface}{user interface}
\msg_new:nnn {xsim} {remove}
{
The~ command~ #2 is~ deprecated.~ As~ of~ version~ #1~ it~ serves~ no~
purpose~ and~ does~ nothing.
}
\msg_new:nnn {xsim} {deprecate}
{
The~ command~ #2 is~ deprecated.~ As~ of~ version~ #1~ it~ serves~ no~
purpose~ and~ does~ nothing.~ Use~ #3 instead.
}
\cs_new_protected:Npn \xsim_remove:nN #1#2
{ \msg_warning:nnnn {xsim} {remove} {#1} {#2} }
\cs_new_protected:Npn \xsim_deprecate:nNN #1#2#3
{ \msg_warning:nnnn {xsim} {remove} {#1} {#2} {#3} }
% ----------------------------------------------------------------------------
\NewDocumentCommand \DeclareExerciseEnvironmentTemplate {m+m+m}
{ \xsim_declare_environment_template:nnn {#1} {#2} {#3} }
\@onlypreamble \DeclareExerciseEnvironmentTemplate
\NewDocumentCommand \DeclareExerciseHeadingTemplate {m+m}
{ \xsim_declare_heading_template:nn {#1} {#2} }
\@onlypreamble \DeclareExerciseHeadingTemplate
\NewDocumentCommand \DeclareExerciseTableTemplate {m+m}
{ \xsim_declare_table_template:nn {#1} {#2} }
\@onlypreamble \DeclareExerciseTableTemplate
\NewDocumentCommand \UseExerciseTemplate {mm}
{ \xsim_use_template:nn {#1} {#2} }
% ----------------------------------------------------------------------------
\NewDocumentCommand \DeclareExerciseType {mm}
{ \xsim_declare_exercise_type:nn {#1} {#2} }
\@onlypreamble \DeclareExerciseType
\NewExpandableDocumentCommand \numberofusedexercises {}
{ \int_use:N \g_xsim_max_id_int }
% ----------------------------------------------------------------------------
\NewDocumentCommand \IfExistSolutionTF {+m+m}
{ \xsim_if_solution_exist:ooTF {\ExerciseType} {\ExerciseID} {#1} {#2} }
\NewDocumentCommand \IfExistSolutionT {+m}
{ \IfExistSolutionTF {#1} {} }
\NewDocumentCommand \IfExistSolutionF {+m}
{ \IfExistSolutionTF {} {#1} }
\NewExpandableDocumentCommand \IfInsideSolutionTF {+m+m}
{ \xsim_if_inside_solution:TF {#1} {#2} }
\NewExpandableDocumentCommand \IfInsideSolutionT {+m}
{ \IfInsideSolutionTF {#1} {} }
\NewExpandableDocumentCommand \IfInsideSolutionF {+m}
{ \IfInsideSolutionTF {} {#1} }
\NewExpandableDocumentCommand \IfSolutionPrintTF {+m+m}
{ \xsim_if_solution_print:nTF {\ExerciseType} {#1} {#2} }
\NewExpandableDocumentCommand \IfSolutionPrintT {+m}
{ \IfSolutionPrintTF {#1} {} }
\NewExpandableDocumentCommand \IfSolutionPrintF {+m}
{ \IfSolutionPrintTF {} {#1} }
% ----------------------------------------------------------------------------
\NewDocumentCommand \DeclareExerciseProperty {t!st-m}
{
\IfBooleanTF {#2}
{
\IfBooleanTF {#3}
{
\xsim_declare_property:nnnn
{ \c_false_bool }
{ \c_true_bool }
{ \c_true_bool }
{#4}
}
{
\xsim_declare_property:nnnn
{ \c_false_bool }
{ \c_true_bool }
{ \c_false_bool }
{#4}
}
}
{
\IfBooleanTF {#1}
{
\IfBooleanTF {#3}
{
\xsim_declare_property:nnnn
{ \c_true_bool }
{ \c_false_bool }
{ \c_true_bool }
{#4}
}
{
\xsim_declare_property:nnnn
{ \c_true_bool }
{ \c_false_bool }
{ \c_false_bool }
{#4}
}
}
{
\IfBooleanTF {#3}
{
\xsim_declare_property:nnnn
{ \c_false_bool }
{ \c_false_bool }
{ \c_true_bool }
{#4}
}
{
\xsim_declare_property:nnnn
{ \c_false_bool }
{ \c_false_bool }
{ \c_false_bool }
{#4}
}
}
}
}
\@onlypreamble \DeclareExerciseProperty
\NewDocumentCommand \DeclareExercisePropertyAlias {mm}
{ \xsim_make_property_alias:nn {#1} {#2} }
\@onlypreamble \DeclareExercisePropertyAlias
\NewDocumentCommand \SetExerciseProperty {m+m}
{ \xsim_set_property:eenn {\ExerciseType} {\ExerciseID} {#1} {#2} }
\NewDocumentCommand \SetExpandedExerciseProperty {m+m}
{ \xsim_set_property:eene {\ExerciseType} {\ExerciseID} {#1} {#2} }
\NewDocumentCommand \ExerciseSetProperty {mmm+m}
{ \xsim_set_property:nnnn {#1} {#2} {#3} {#4} }
\NewDocumentCommand \ExerciseSetExpandedProperty {mmm+m}
{ \xsim_set_property:nnne {#1} {#2} {#3} {#4} }
\NewExpandableDocumentCommand \IfExercisePropertyExistTF {+m+m+m}
{ \xsim_if_property_exist:nTF {#1} {#2} {#3} }
\NewExpandableDocumentCommand \IfExercisePropertyExistT {+m+m}
{ \IfExercisePropertyExistTF {#1} {#2} {} }
\NewExpandableDocumentCommand \IfExercisePropertyExistF {+m+m}
{ \IfExercisePropertyExistTF {#1} {} {#2} }
\NewExpandableDocumentCommand \IfExercisePropertySetTF {m+m+m}
{ \xsim_if_property_set:eenTF {\ExerciseType} {\ExerciseID} {#1} {#2} {#3} }
\NewExpandableDocumentCommand \IfExercisePropertySetT {m+m}
{ \IfExercisePropertySetTF {#1} {#2} {} }
\NewExpandableDocumentCommand \IfExercisePropertySetF {m+m}
{ \IfExercisePropertySetTF {#1} {} {#2} }
\NewExpandableDocumentCommand \GetExerciseProperty {m}
{ \xsim_get_property:oon {\ExerciseType} {\ExerciseID} {#1} }
\NewExpandableDocumentCommand \GetExerciseAliasProperty {m}
{
\xsim_get_property:oof
{\ExerciseType}
{\ExerciseID}
{ \xsim_property_alias:n {#1} }
}
\NewDocumentCommand \GetExercisePropertyTF {m+m+m}
{
\xsim_get_property_if_set:oonTF {\ExerciseType} {\ExerciseID} {#1}
{#2}
{#3}
}
\NewDocumentCommand \GetExercisePropertyT {m+m}
{ \GetExercisePropertyTF {#1} {#2} {} }
\NewDocumentCommand \GetExercisePropertyF {m+m+m}
{ \GetExercisePropertyTF {#1} {} {#2} }
\NewExpandableDocumentCommand \GetExerciseIdForProperty {mm}
{ \xsim_get_id_for_property:nn {#1} {#2} }
\NewExpandableDocumentCommand \GetExerciseTypeForProperty {mm}
{ \xsim_get_type_for_property:nn {#1} {#2} }
\NewExpandableDocumentCommand \IfExerciseBooleanPropertyTF {+m+m+m}
{
\xsim_if_boolean_property:oonTF {\ExerciseType} {\ExerciseID} {#1}
{#2}
{#3}
}
\NewExpandableDocumentCommand \IfExerciseBooleanPropertyT {+m+m}
{ \IfExerciseBooleanPropertyTF {#1} {#2} {} }
\NewExpandableDocumentCommand \IfExerciseBooleanPropertyF {+m+m}
{ \IfExerciseBooleanPropertyTF {#1} {} {#2} }
\NewDocumentCommand \SaveExerciseProperty {mm}
{ \xsim_save_property:xxnN {\ExerciseType} {\ExerciseID} {#1} #2 }
\NewDocumentCommand \GlobalSaveExerciseProperty {mm}
{ \xsim_gsave_property:xxnN {\ExerciseType} {\ExerciseID} {#1} #2 }
% ----------------------------------------------------------------------------
\NewDocumentCommand \DeclareExerciseParameter {st!m}
{
\IfBooleanTF {#1} % fixed
{
\IfBooleanTF {#2} % mandatory
{ \xsim_declare_parameter:nnn {true} {true} {#3} }
{ \xsim_declare_parameter:nnn {true} {false} {#3} }
}
{
\IfBooleanTF {#2} % mandatory
{ \xsim_declare_parameter:nnn {false} {true} {#3} }
{ \xsim_declare_parameter:nnn {false} {false} {#3} }
}
}
\NewExpandableDocumentCommand \GetExerciseParameter {m}
{ \xsim_get_parameter:on {\ExerciseType} {#1} }
\NewDocumentCommand \SetExerciseParameter {mmm}
{ \xsim_set_parameter:nnn {#1} {#2} {#3} }
\NewDocumentCommand \SetExerciseParameters {mm}
{ \xsim_set_parameters:nn {#1} {#2} }
\NewExpandableDocumentCommand \GetExerciseName {}
{
\IfInsideSolutionTF
{ \GetExerciseParameter {solution-name} }
{ \GetExerciseParameter {exercise-name} }
}
\NewExpandableDocumentCommand \GetExerciseHeadingF {m}
{
\IfInsideSolutionTF
{
\IfExerciseParameterSetTF {solution-heading}
{ \GetExerciseParameter {solution-heading} }
{#1}
}
{
\IfExerciseParameterSetTF {exercise-heading}
{ \GetExerciseParameter {exercise-heading} }
{#1}
}
}
\NewDocumentCommand \GetExerciseBody {m}
{ \xsim_input:oon { \ExerciseType } { \ExerciseID } {#1} }
\NewExpandableDocumentCommand \IfExerciseParameterSetTF {+m+m+m}
{ \xsim_if_parameter_set:onTF {\ExerciseType} {#1} {#2} {#3} }
\NewExpandableDocumentCommand \IfExerciseParameterSetT {+m+m}
{ \xsim_if_parameter_set:onT {\ExerciseType} {#1} {#2} }
\NewExpandableDocumentCommand \IfExerciseParameterSetF {+m+m}
{ \xsim_if_parameter_set:onF {\ExerciseType} {#1} {#2} }
\NewExpandableDocumentCommand \ExerciseParameterIfSetTF {+m+m+m+m}
{ \xsim_if_parameter_set:nnTF {#1} {#2} {#3} {#4} }
\NewExpandableDocumentCommand \ExerciseParameterIfSetT {+m+m+m}
{ \xsim_if_parameter_set:nnT {#1} {#2} {#3} }
\NewExpandableDocumentCommand \ExerciseParameterIfSetF {+m+m+m}
{ \xsim_if_parameter_set:nnF {#1} {#2} {#3} }
\NewDocumentCommand \GetExerciseParameterTF {m+m+m}
{ \xsim_get_parameter_if_set:onTF {\ExerciseType} {#1} {#2} {#3} }
\NewDocumentCommand \GetExerciseParameterT {m+m}
{ \GetExerciseParameterTF {#1} {#2} {} }
\NewDocumentCommand \GetExerciseParameterF {m+m+m}
{ \GetExerciseParameterTF {#1} {} {#2} }
% ----------------------------------------------------------------------------
\NewDocumentCommand \ExercisePropertyIfSetTF {mmm+m+m}
{ \xsim_if_property_set:nnnTF {#1} {#2} {#3} {#4} {#5} }
\NewDocumentCommand \ExercisePropertyIfSetT {mmm+m}
{ \ExercisePropertyIfSetTF {#1} {#2} {#3} {#4} {} }
\NewDocumentCommand \ExercisePropertyIfSetF {mmm+m}
{ \ExercisePropertyIfSetTF {#1} {#2} {#3} {} {#4} }
\NewExpandableDocumentCommand \ExercisePropertyGet {mmm}
{ \xsim_get_property:nnn {#1} {#2} {#3} }
\NewExpandableDocumentCommand \ExercisePropertyGetAlias {mm}
{ \xsim_get_property:nnf {#1} {#2} { \xsim_property_alias:n {#1} } }
\NewDocumentCommand \ExercisePropertySave {mmmm}
{ \xsim_save_property:nnnN {#1} {#2} {#3} #4 }
\NewDocumentCommand \ExercisePropertyGlobalSave {mmmm}
{ \xsim_gsave_property:nnnN {#1} {#2} {#3} #4 }
\NewExpandableDocumentCommand \ExerciseParameterGet {mm}
{ \xsim_get_parameter:nn {#1} {#2} }
% ----------------------------------------------------------------------------
\NewExpandableDocumentCommand \XSIMtranslate {m}
{ \xsim_translate:n {#1} }
\NewExpandableDocumentCommand \XSIMexpandcode {+m}
{ \use:e {#1} }
\NewExpandableDocumentCommand \XSIMmixedcase {m}
{ \text_titlecase:e {#1} }
\NewDocumentCommand \XSIMputright {mm}
{ \tl_put_right:Nn #1 {#2} }
\NewExpandableDocumentCommand \XSIMifeqTF {+m+m+m+m}
{ \tl_if_eq:eeTF {#1} {#2} {#3} {#4} }
\NewExpandableDocumentCommand \XSIMifeqT {+m+m+m}
{ \XSIMifeqTF {#1} {#2} {#3} {} }
\NewExpandableDocumentCommand \XSIMifeqF {+m+m+m}
{ \XSIMifeqTF {#1} {#2} {} {#3} }
\NewExpandableDocumentCommand \XSIMifblankTF {+m+m+m}
{ \tl_if_blank:eTF {#1} {#2} {#3} }
\NewExpandableDocumentCommand \XSIMifblankT {+m+m}
{ \XSIMifblankTF {#1} {#2} {} }
\NewExpandableDocumentCommand \XSIMifblankF {+m+m}
{ \XSIMifblankTF {#1} {} {#2} }
% ----------------------------------------------------------------------------
\NewDocumentCommand \DeclareExerciseGoal {m}
{ \xsim_declare_exercise_goal:n {#1} }
\@onlypreamble \DeclareExerciseGoal
\NewDocumentCommand \IfExerciseGoalTF {mm+m+m}
{
\xsim_if_goal_value:xxnnTF
{\ExerciseType} {\ExerciseID} {#1}
{#2}
{#3} {#4}
}
\NewDocumentCommand \IfExerciseGoalT {mm+m}
{ \IfExerciseGoalTF {#1} {#2} {#3} {} }
\NewDocumentCommand \IfExerciseGoalF {mm+m}
{ \IfExerciseGoalTF {#1} {#2} {} {#3} }
\NewDocumentCommand \IfExerciseGoalSingularTF {mmm}
{ \IfExerciseGoalTF {#1} {=1} {#2} {#3} }
\NewDocumentCommand \IfExerciseGoalSingularT {mm}
{ \IfExerciseGoalT {#1} {=1} {#2} }
\NewDocumentCommand \IfExerciseGoalSingularF {mm}
{ \IfExerciseGoalF {#1} {=1} {#2} }
\NewDocumentCommand \IfExerciseTypeGoalsSumTF {mmm+m+m}
{ \xsim_if_goals_sum:nnnTF {#1} {#2} {#3} {#4} {#5} }
\NewDocumentCommand \IfExerciseTypeGoalsSumT {mmm+m}
{ \IfExerciseTypeGoalsSumTF {#1} {#2} {#3} {#4} {} }
\NewDocumentCommand \IfExerciseTypeGoalsSumF {mmm+m}
{ \IfExerciseTypeGoalsSumTF {#1} {#2} {#3} {} {#4} }
\NewDocumentCommand \IfExerciseGoalsSumTF {mm+m+m}
{ \xsim_if_total_goals_sum:nnTF {#1} {#2} {#3} {#4} }
\NewDocumentCommand \IfExerciseGoalsSumT {mm+m}
{ \IfExerciseGoalsSumTF {#1} {#2} {#3} {} }
\NewDocumentCommand \IfExerciseGoalsSumF {mm+m}
{ \IfExerciseGoalsSumTF {#1} {#2} {} {#3} }
\NewDocumentCommand \TotalExerciseTypeGoal {mmmm}
{ \xsim_print_goal_sum:nnnn {#1} {#2} {#3} {#4} }
\NewDocumentCommand \TotalExerciseTypeGoals {mmmm}
{ \xsim_print_goals_sum:nnnn {#1} {#2} {#3} {#4} }
\NewDocumentCommand \TotalExerciseGoal {mmm}
{ \xsim_print_total_goal_sum:nnn {#1} {#2} {#3} }
\NewDocumentCommand \TotalExerciseGoals {mmm}
{ \xsim_print_total_goals_sum:nnn {#1} {#2} {#3} }
\NewDocumentCommand \AddtoExerciseTypeGoal {mmmm}
{ \xsim_addto_goal:nnnn {#1} {#2} {#3} {#4} }
\NewDocumentCommand \AddtoExerciseGoal {mm}
{ \xsim_addto_goal:xxnn {\ExerciseType} {\ExerciseID} {#1} {#2} }
\NewDocumentCommand \ExerciseGoalValuePrint {mmm}
{ \xsim_print_goal:nnn {#1} {#2} {#3} }
\NewDocumentCommand \AddtoExerciseTypeGoalPrint {mmmmmm}
{
\xsim_addto_goal:nnnn {#1} {#2} {#3} {#4}
\xsim_print_goal:nnn {#4} {#5} {#6}
}
\NewDocumentCommand \AddtoExerciseGoalPrint {mmmm}
{
\xsim_addto_goal:xxnn {\ExerciseType} {\ExerciseID} {#1} {#2}
\xsim_print_goal:nnn {#2} {#3} {#4}
}
% ----------------------------------------------------------------------------
\NewDocumentCommand \DeclareGradeDistribution {m}
{ \xsim_declare_relative_grades:n {#1} }
\NewDocumentCommand \GetGradeRequirementForGoal {mmmm}
{ \xsim_get_grade_goal:nnnn {#1} {#2} {#3} {#4} }
\NewDocumentCommand \GetGradeRequirementForGoals {mmmm}
{ \xsim_get_grade_requirement:nnnn {#1} {#2} {#3} {#4} }
\NewDocumentCommand \GetGradeRequirement {mmm}
{ \xsim_get_absolute_grade_requirement:nnn {#1} {#2} {#3} }
% ----------------------------------------------------------------------------
\NewDocumentCommand \DeclareExerciseTagging {m}
{ \xsim_new_tag_type:n {#1} }
\@onlypreamble \DeclareExerciseTagging
\NewDocumentCommand \ProvideExerciseTagging {m}
{
\xsim_if_tag_type_exist:nTF {#1}
{ \msg_warning:nnn {xsim} {tag-exists} {#1} }
{ \xsim_new_tag_type:n {#1} }
}
\NewDocumentCommand \ForEachExerciseTag {m+m}
{ \xsim_foreach_exercise_tag:oonn {\ExerciseType} {\ExerciseID} {#1} {#2} }
\NewDocumentCommand \ListExerciseTags {mm}
{ \xsim_exercise_tags_use:oonn {\ExerciseType} {\ExerciseID} {#1} {#2} }
\NewDocumentCommand \UseExerciseTags {mmmm}
{
\xsim_exercise_tags_use:oonnnn
{\ExerciseType}
{\ExerciseID}
{#1}
{#2}
{#3}
{#4}
}
\NewDocumentCommand \IfExerciseTagSetTF {m+m+m}
{ \xsim_if_tags_value:nTF {#1} {#2} {#3} }
\NewDocumentCommand \IfExerciseTagSetT {m+m}
{ \xsim_if_tags_value:nT {#1} {#2} }
\NewDocumentCommand \IfExerciseTagSetF {m+m}
{ \xsim_if_tags_value:nF {#1} {#2} }
\NewDocumentCommand \IfExerciseTopicSetTF {m+m+m}
{ \xsim_if_topic_value:nTF {#1} {#2} {#3} }
\NewDocumentCommand \IfExerciseTopicSetT {m+m}
{ \xsim_if_topic_value:nT {#1} {#2} }
\NewDocumentCommand \IfExerciseTopicSetF {m+m}
{ \xsim_if_topic_value:nF {#1} {#2} }
% ----------------------------------------------------------------------------
\NewDocumentCommand \XSIMatbegindocument {+m}
{ \xsim_at_begin_document:n {#1} }
\NewDocumentCommand \XSIMatenddocument {+m}
{ \xsim_at_end_document:n {#1} }
% ----------------------------------------------------------------------------
\NewDocumentCommand \ForEachPrintedExerciseByType {+m}
{ \xsim_foreach_exercise_type_id:nn {printed} {#1} }
\tl_new:N \XSIMtmp
\NewDocumentCommand \ForEachPrintedExerciseByID {+m}
{
\tl_set_eq:NN \XSIMtmp \ExerciseType
\xsim_foreach_exercise_id_type:nn {print} {#1}
\tl_set_eq:NN \ExerciseType \XSIMtmp
\tl_clear:N \XSIMtmp
}
\NewDocumentCommand \ForEachUsedExerciseByType {+m}
{
\tl_set_eq:NN \XSIMtmp \ExerciseType
\xsim_foreach_exercise_type_id:nn {used} {#1}
\tl_set_eq:NN \ExerciseType \XSIMtmp
\tl_clear:N \XSIMtmp
}
\NewDocumentCommand \ForEachUsedExerciseByID {+m}
{
\tl_set_eq:NN \XSIMtmp \ExerciseType
\xsim_foreach_exercise_id_type:nn {used} {#1}
\tl_set_eq:NN \ExerciseType \XSIMtmp
\tl_clear:N \XSIMtmp
}
\NewDocumentCommand \ForEachUsedExerciseByOrder {+m}
{
\tl_set_eq:NN \XSIMtmp \ExerciseType
\xsim_foreach_exercise_type_order:nn {used} {#1}
\tl_set_eq:NN \ExerciseType \XSIMtmp
\tl_clear:N \XSIMtmp
}
% ----------------------------------------------------------------------------
\NewDocumentCommand \DeclareExerciseTranslations {mm}
{ \xsim_declare_translations:nn {#1} {#2} }
\@onlypreamble \DeclareExerciseTranslations
\NewDocumentCommand \DeclareExerciseTranslation {mmm}
{ \xsim_declare_translation:nnn {#1} {#2} {#3} }
\@onlypreamble \DeclareExerciseTranslation
\NewDocumentCommand \ForEachExerciseTranslation {+m}
{ \xsim_for_all_translations_do:n {#1} }
% ----------------------------------------------------------------------------
\NewDocumentCommand \DeclareExerciseCollection {om}
{
\IfNoValueTF {#1}
{ \xsim_new_collection:nn {#2} {} }
{
\xsim_new_collection:nn {#2} {#1}
\xsim_activate_collection:n {#2}
}
}
\@onlypreamble \DeclareExerciseCollection
\NewDocumentCommand \activatecollection {m}
{ \xsim_activate_collection:n {#1} }
\NewDocumentCommand \deactivatecollection {m}
{ \xsim_deactivate_collection:n {#1} }
% \NewDocumentCommand \collectexercisestype {mm}
% { \xsim_collect_type_start:nn {#1} {#2} }
\NewDocumentCommand \collectexercises {m}
{ \xsim_collect_start:n {#1} }
\NewDocumentCommand \collectexercisesstop {m}
{ \xsim_collect_stop:n {#1} }
\NewDocumentCommand \printcollection {O{}m}
{ \xsim_print_collection:nn {#1} {#2} }
\NewDocumentCommand \printrandomexercises {O{}m}
{
\group_begin:
\keys_set:nn {xsim/random} {#1}
\xsim_print_random_list:VnN
\l_xsim_random_collection_tl
{#2}
\l_xsim_random_exclude_list_clist
\group_end:
}
% ----------------------------------------------------------------------------
\NewDocumentCommand \blank {som}
{
\group_begin:
\IfNoValueF {#2} { \keys_set:nn {xsim/blank} {#2} }
\mode_if_vertical:TF
{
\IfBooleanTF {#1}
{ \xsim_blank:n {#3} }
{
\bool_if:NT \l__xsim_blank_linespread_bool
{ \linespread { \l__xsim_blank_linespread_tl } \selectfont }
\noindent \null \xsim_blank:n {#3} \par
}
}
{ \xsim_blank:n {#3} }
\group_end:
}
\NewDocumentCommand \examspace { sm }
{
\IfBooleanTF {#1}
{ \xsim_examspace:nn { \c_true_bool } {#2} }
{ \xsim_examspace:nn { \c_false_bool } {#2} }
}
% ----------------------------------------------------------------------------
\NewDocumentCommand \gradingtable {O{}}
{
\group_begin:
\keys_set:nn {xsim/grading-table} {#1}
\xsim_setup_template:nVn {table} \l_xism_grading_table_template_tl
{
\providecommand* \ExerciseTableCode {}
\providecommand* \ExerciseTableType [1] {}
\providecommand* \ExerciseType {}
\tl_set_eq:NN \ExerciseType \l_xism_grading_table_exercise_type_tl
\renewcommand* \ExerciseTableCode {}
\renewcommand* \ExerciseTableType [1]
{
\XSIMifblankTF { \l_xism_grading_table_exercise_type_tl }
{##1}
{ \l_xism_grading_table_exercise_type_tl }
}
}
\xsim_use_template:nV {table} \l_xism_grading_table_template_tl
\group_end:
}
% ----------------------------------------------------------------------------
\NewDocumentCommand \XSIMprint {mO{}mm}
{ \xsim_insert:nenn {#3} { \xsim_normalize_id:n {#4} } {#2} {#1} }
\NewDocumentCommand \XSIMxprint {mO{}mm}
{ \xsim_insert:xxnn {#3} { \xsim_normalize_id:e {#4} } {#2} {#1} }
\NewDocumentCommand \printexercise {O{}mm}
{
\clist_map_inline:nn {#3}
{ \xsim_insert:nenn {#2} { \xsim_normalize_id:n {##1} } {#1} {exercise} }
}
\NewDocumentCommand \xprintexercise {O{}mm}
{
\clist_map_inline:nn {#3}
{ \xsim_insert:xxnn {#2} { \xsim_normalize_id:e {##1} } {#1} {exercise} }
}
\NewDocumentCommand \printsolution {O{}mm}
{
\clist_map_inline:nn {#3}
{ \xsim_insert:nenn {#2} { \xsim_normalize_id:n {##1} } {#1} {solution} }
}
\NewDocumentCommand \xprintsolution {O{}mm}
{
\clist_map_inline:nn {#3}
{ \xsim_insert:xxnn {#2} { \xsim_normalize_id:e {##1} } {#1} {solution} }
}
% ----------------------------------------------------------------------------
\NewDocumentCommand \printsolutionstype {sO{}m}
{
\IfBooleanTF {#1}
{ \xsim_print_type_solutions:nnn { \c_true_bool } {#2} {#3} }
{ \xsim_print_type_solutions:nnn { \c_false_bool } {#2} {#3} }
}
\NewDocumentCommand \printsolutions {sO{}}
{
\IfBooleanTF {#1}
{ \xsim_print_all_solutions_per_type:nn { \c_true_bool } {#2} }
{ \xsim_print_all_solutions_per_type:nn { \c_false_bool } {#2} }
}
\NewDocumentCommand \printallsolutions {sO{}}
{
\IfBooleanTF {#1}
{ \xsim_print_all_solutions_per_id:nn { \c_true_bool } {#2} }
{ \xsim_print_all_solutions_per_id:nn { \c_false_bool } {#2} }
}
% ----------------------------------------------------------------------------
\NewDocumentCommand \printforexercises {sO{}+mO{}}
{
\IfBooleanTF {#1}
{
\xsim_foreach_exercise_type:n
{ \xsim_print_type_code:nnnnn { \c_true_bool } {#2} {#4} {##1} {#3} }
}
{
\xsim_foreach_exercise_type:n
{ \xsim_print_type_code:nnnnn { \c_false_bool } {#2} {#4} {##1} {#3} }
}
}
% ----------------------------------------------------------------------------
\NewDocumentCommand \xsimsetup {+m}
{ \xsim_setup:n {#1} }
% ----------------------------------------------------------------------------
\NewExpandableDocumentCommand \XSIMifchapterTF {+m+m}
{ \xsim_if_chapter:TF {#1} {#2} }
\NewExpandableDocumentCommand \XSIMifchapterT {+m}
{ \xsim_if_chapter:T {#1} }
\NewExpandableDocumentCommand \XSIMifchapterF {+m}
{ \xsim_if_chapter:F {#1} }
\XSIMmoduleend
\XSIMmodule{definitions}{definition of user commands}
% not exactly a user choice: the `exercises' environments rely on them:
\DeclareExerciseParameter*!{exercise-env}
\DeclareExerciseParameter*!{solution-env}
\DeclareExerciseParameter !{exercise-name}
\DeclareExerciseParameter !{solution-name}
\DeclareExerciseParameter {exercises-name}
\DeclareExerciseParameter {solutions-name}
\DeclareExerciseParameter !{exercise-template}
\DeclareExerciseParameter !{solution-template}
\DeclareExerciseParameter* {counter}
\DeclareExerciseParameter* {solution-counter}
\DeclareExerciseParameter* {number}
\DeclareExerciseParameter {within}
\DeclareExerciseParameter {the-counter}
% these are additional - but are used in the `default' environment
% template:
\DeclareExerciseParameter {exercise-heading}
\DeclareExerciseParameter {solution-heading}
% ----------------------------------------------------------------------------
% not exactly a user choice, must be present at various places:
\DeclareExerciseProperty! {id}
\DeclareExerciseProperty! {ID}
\DeclareExerciseProperty {counter}
\DeclareExerciseProperty {counter-value}
\DeclareExerciseProperty * {solution}
\XSIMifchapterT{
\DeclareExerciseProperty {chapter-value}
\DeclareExerciseProperty {chapter}
}
\DeclareExerciseProperty {section-value}
\DeclareExerciseProperty {section}
\DeclareExerciseProperty {sectioning}
% those are additional and wouldn't *need* to be present except for
% pre-defined templates which make use of them (the page and page-value
% property actually needs to be defined for xsim to be able to save the
% corresponding values):
\DeclareExerciseProperty {subtitle}
\DeclareExerciseProperty {points}
\DeclareExerciseProperty {bonus-points}
\DeclareExerciseProperty {page-value}
\DeclareExerciseProperty {page}
\DeclareExercisePropertyAlias {ID} {id}
% ----------------------------------------------------------------------------
\DeclareExerciseTagging {tags}
\DeclareExerciseTagging {topics}
\xsimsetup{tags/ignore-untagged=false}
% ----------------------------------------------------------------------------
\DeclareExerciseGoal {points}
\DeclareExerciseGoal {bonus-points}
\NewDocumentCommand \printgoal {m}
{ \ExerciseGoalValuePrint {#1} {} {} }
\NewDocumentCommand \points {m}
{
\ExerciseGoalValuePrint {#1}
{ \, \XSIMtranslate {point} }
{ \, \XSIMtranslate {points} }
}
\NewDocumentCommand \addpoints {sm}
{
\AddtoExerciseGoal {points} {#2}
\IfBooleanF {#1} { \points {#2} }
}
\NewDocumentCommand \printpoints {m}
{
\TotalExerciseTypeGoal {#1} {points}
{ \, \XSIMtranslate {point} }
{ \, \XSIMtranslate {points} }
}
\NewDocumentCommand \printtotalpoints {}
{
\TotalExerciseGoal {points}
{ \, \XSIMtranslate {point} }
{ \, \XSIMtranslate {points} }
}
\NewDocumentCommand \addbonus {sm}
{
\AddtoExerciseGoal {bonus-points} {#2}
\IfBooleanF {#1} { \points {#2} }
}
\NewDocumentCommand \printbonus {m}
{
\TotalExerciseTypeGoal {#1} {bonus-points}
{ \, \XSIMtranslate {point} }
{ \, \XSIMtranslate {points} }
}
\NewDocumentCommand \printtotalbonus {}
{
\TotalExerciseGoal {bonus-points}
{ \, \XSIMtranslate {point} }
{ \, \XSIMtranslate {points} }
}
% ----------------------------------------------------------------------------
\NewDocumentCommand \pointsforgrade {m}
{
\GetGradeRequirementForGoal {#1} {points}
{ \, \XSIMtranslate {point} }
{ \, \XSIMtranslate {points} }
}
\NewDocumentCommand \goalsforgrade {mm}
{
\GetGradeRequirementForGoals {#2} {#1}
{ \, \XSIMtranslate {point} }
{ \, \XSIMtranslate {points} }
}
\NewDocumentCommand \totalgoalforgrade {m}
{
\GetGradeRequirement {#1}
{ \, \XSIMtranslate {point} }
{ \, \XSIMtranslate {points} }
}
% ----------------------------------------------------------------------------
\xsim_if_package_blank:F
{
\DeclareExerciseType {exercise} {
exercise-env = exercise ,
solution-env = solution ,
exercise-name = \XSIMtranslate {exercise} ,
exercises-name = \XSIMtranslate {exercises} ,
solution-name = \XSIMtranslate {solution} ,
solutions-name = \XSIMtranslate {solutions} ,
exercise-template = default ,
solution-template = default ,
exercise-heading = \subsection* ,
solution-heading = \subsection*
}
}
% ----------------------------------------------------------------------------
\DeclareExerciseEnvironmentTemplate {default}
{
\GetExerciseHeadingF { \subsection* }
{
\XSIMmixedcase { \GetExerciseName } \nobreakspace
\GetExerciseProperty {counter}
\IfInsideSolutionF
{
\IfExercisePropertySetT {subtitle}
{ ~ { \normalfont \itshape \GetExerciseProperty {subtitle} } }
}
}
\GetExercisePropertyT {points}
{
\marginpar
{
\IfInsideSolutionF { \rule {1.2cm} {1pt} \slash }
\printgoal {\PropertyValue}
\GetExercisePropertyT {bonus-points}
{ \nobreakspace ( + \printgoal {\PropertyValue} ) }
\nobreakspace\XSIMtranslate {point-abbr}
}
}
}
{ \par }
% ----------------------------------------------------------------------------
\DeclareExerciseHeadingTemplate {none} {}
\DeclareExerciseHeadingTemplate {default}
{ \section* { \XSIMtranslate {default-heading} } }
\DeclareExerciseHeadingTemplate {collection}
{ \section* { \XSIMtranslate {collection-heading} } }
\DeclareExerciseHeadingTemplate {per-section}
{ \section* { \XSIMtranslate {per-section-heading} } }
\DeclareExerciseHeadingTemplate {per-chapter}
{ \section* { \XSIMtranslate {per-chapter-heading} } }
% ----------------------------------------------------------------------------
\RequirePackage{array,booktabs}
\DeclareExerciseTableTemplate {default*}
{
\XSIMputright \ExerciseTableCode
{
\toprule
\XSIMifblankF { \ExerciseType }
{ \XSIMmixedcase { \GetExerciseParameter {exercise-name} } }
&
}
\ForEachUsedExerciseByOrder
{
\XSIMifeqT {#1} { \ExerciseTableType {#1} }
{
\XSIMifblankT { \ExerciseTableType {} }
{
\XSIMputright \ExerciseTableCode
{
\XSIMmixedcase
{ \ExerciseParameterGet {#1} {exercise-name} ~ }
}
}
\XSIMputright \ExerciseTableCode { #3 & }
}
}
\XSIMputright \ExerciseTableCode
{
\XSIMtranslate {total} \\
\midrule \XSIMmixedcase { \XSIMtranslate {points} } &
}
\ForEachUsedExerciseByOrder
{
\XSIMifeqT {#1} { \ExerciseTableType {#1} }
{
\XSIMputright \ExerciseTableCode
{ \XSIMifblankTF {#5} {\printgoal{0}} {\printgoal{#5}} & }
}
}
\XSIMputright \ExerciseTableCode
{
\XSIMifblankTF { \ExerciseType }
{ \TotalExerciseGoal {points} {} {} }
{ \TotalExerciseTypeGoal { \ExerciseType } {points} {} {} }
\\ \midrule
\XSIMtranslate {reached} &
}
\ForEachUsedExerciseByOrder
{
\XSIMifeqT {#1} { \ExerciseTableType {#1} }
{ \XSIMputright \ExerciseTableCode {&} }
}
\XSIMputright \ExerciseTableCode { \\ \bottomrule }
\edef \numberofcolumns
{
\XSIMifblankTF { \ExerciseType }
{\numberofusedexercises}
{\csname numberof \ExerciseType s\endcsname}
}
\XSIMifeqF {\numberofcolumns} {0}
{
\begin {tabular} {l*{\numberofcolumns}{c}c}
\ExerciseTableCode
\end {tabular}
}
}
\DeclareExerciseTableTemplate {default}
{
\XSIMputright \ExerciseTableCode
{
\toprule
\XSIMifblankF { \ExerciseType }
{ \XSIMmixedcase { \GetExerciseParameter {exercise-name} } }
&
\XSIMmixedcase { \XSIMtranslate {points} } &
\XSIMtranslate {reached} \\
\midrule
}
\ForEachUsedExerciseByOrder
{
\XSIMifeqT {#1} { \ExerciseTableType {#1} }
{
\XSIMifblankT { \ExerciseTableType {} }
{
\XSIMputright \ExerciseTableCode
{
\XSIMmixedcase
{ \ExerciseParameterGet {#1} {exercise-name} ~ }
}
}
\XSIMputright \ExerciseTableCode
{ #3 & \XSIMifblankTF {#5} {\printgoal{0}} {\printgoal{#5}} & \\ }
}
}
\XSIMputright \ExerciseTableCode
{
\midrule
\XSIMtranslate {total} &
\XSIMifblankTF { \ExerciseType }
{ \TotalExerciseGoal {points} {} {} }
{ \TotalExerciseTypeGoal { \ExerciseType } {points} {} {} } &
\\ \bottomrule
}
\XSIMexpandcode
{
\noexpand \begin {tabular} {\XSIMifblankTF{\ExerciseType}{l}{c}cc}
\noexpand \ExerciseTableCode
\noexpand \end {tabular}
}
}
% ----------------------------------------------------------------------------
\DeclareExerciseTranslations {exercise} {
Fallback = exercise ,
English = exercise ,
French = exercice ,
German = \"Ubung
}
\DeclareExerciseTranslations {exercises} {
Fallback = exercises ,
English = exercises ,
French = exercices ,
German = \"Ubungen
}
\DeclareExerciseTranslations {question} {
Fallback = question ,
English = question ,
French = question ,
German = Aufgabe
}
\DeclareExerciseTranslations {questions} {
Fallback = questions ,
English = questions ,
French = questions ,
German = Aufgaben
}
\DeclareExerciseTranslations {solution} {
Fallback = solution ,
English = solution ,
French = solution ,
German = L\"osung
}
\DeclareExerciseTranslations {solutions} {
Fallback = solutions ,
English = solutions ,
French = solutions ,
German = L\"osungen
}
\DeclareExerciseTranslations {point-abbr} {
Fallback = p. ,
English = p. ,
French = p. ,
German = P.
}
\DeclareExerciseTranslations {point} {
Fallback = point ,
English = point ,
French = point ,
German = Punkt
}
\DeclareExerciseTranslations {points} {
Fallback = points ,
English = points ,
French = points ,
German = Punkte
}
\DeclareExerciseTranslations {reached} {
Fallback = reached ,
English = reached ,
French = obtenus ,
German = erreicht
}
\DeclareExerciseTranslations {total} {
Fallback = total ,
English = total ,
French = total ,
German = insgesamt
}
\DeclareExerciseTranslations {default-heading} {
Fallback = \XSIMmixedcase { \GetExerciseParameter {solutions-name} }~
to~ the~ \XSIMmixedcase { \GetExerciseParameter {exercises-name} } ,
English = \XSIMmixedcase { \GetExerciseParameter {solutions-name} }~
to~ the~ \XSIMmixedcase { \GetExerciseParameter {exercises-name} } ,
French = \XSIMmixedcase { \GetExerciseParameter {solutions-name} ~
des~ \GetExerciseParameter {exercises-name} } ,
German = \XSIMmixedcase { \GetExerciseParameter {solutions-name} }~
zu~ den~ \XSIMmixedcase { \GetExerciseParameter {exercises-name} }
}
\DeclareExerciseTranslations {collection-heading} {
Fallback = \XSIMmixedcase { \GetExerciseParameter {exercises-name} } ,
English = \XSIMmixedcase { \GetExerciseParameter {exercises-name} } ,
French = \XSIMmixedcase { \GetExerciseParameter {exercises-name} } ,
German = \XSIMmixedcase { \GetExerciseParameter {exercises-name} }
}
\DeclareExerciseTranslations {per-section-heading} {
Fallback = \XSIMmixedcase { \GetExerciseParameter {solutions-name} } ~
to~ the~ \XSIMmixedcase { \GetExerciseParameter {exercises-name} } ~
of~ Section \nobreakspace \ExerciseSection ,
English = \XSIMmixedcase { \GetExerciseParameter {solutions-name} } ~
to~ the~ \XSIMmixedcase { \GetExerciseParameter {exercises-name} } ~
of~ Section \nobreakspace \ExerciseSection ,
French = \XSIMmixedcase { \GetExerciseParameter {solutions-name} ~
des~ \GetExerciseParameter {exercises-name} ~ de~ la~
section \nobreakspace \ExerciseSection } ,
German = \XSIMmixedcase { \GetExerciseParameter {solutions-name} } ~
zu~ den~ \XSIMmixedcase { \GetExerciseParameter {exercises-name} }~
in~ Abschnitt \nobreakspace \ExerciseSection
}
\DeclareExerciseTranslations {per-chapter-heading} {
Fallback = \XSIMmixedcase { \GetExerciseParameter {solutions-name} } ~
to~ the~ \XSIMmixedcase { \GetExerciseParameter {exercises-name} } ~
of~ Chapter \nobreakspace \ExerciseChapter ,
English = \XSIMmixedcase { \GetExerciseParameter {solutions-name} } ~
to~ the~ \XSIMmixedcase { \GetExerciseParameter {exercises-name} } ~
of~ Chapter \nobreakspace \ExerciseChapter ,
French = \XSIMmixedcase { \GetExerciseParameter {solutions-name} ~
des~ \GetExerciseParameter {exercises-name} ~
du~ chapitre \nobreakspace \ExerciseChapter } ,
German = \XSIMmixedcase { \GetExerciseParameter {solutions-name} } ~
zu~ den~ \XSIMmixedcase { \GetExerciseParameter {exercises-name} } ~
in~ Kapitel \nobreakspace \ExerciseChapter
}
\XSIMmoduleend
% finish package:
\hook_gput_code:nnn {enddocument} {toplevel} { \xsim_close_aux:\xsim_do_rerun: }
%----------------------------------------------------------------------------
\file_input_stop: