new generic package yax (17jun10)

git-svn-id: svn://tug.org/texlive/trunk@19036 c570f23f-e606-0410-a88d-b1316a301751

9 files changed, 1494 insertions, 0 deletions

diff --git a/Master/texmf-dist/doc/generic/yax/README b/Master/texmf-dist/doc/generic/yax/README
new file mode 100644
index 00000000000..21040a05a00
--- /dev/null
+++ b/Master/texmf-dist/doc/generic/yax/README
@@ -0,0 +1,25 @@
+This is the README file for the YaX package.
+Author: Paul Isambert.
+E-mail: zappathustra AT free DOT fr
+Comments and suggestions are welcome.
+Date: June 2010.
+
+The package is a format-independent key system,
+with some peculiarities.
+It is format-independent and based on texapi
+(and thus requires e-TeX at least).
+Relevant information can be found in yax-doc.pdf
+
+Files in this distributions:
+
+yax.tex     => The bulk of the code.
+t-yax.tex   => A wrapper file for ConTeXt.
+yax.sty     => A wrapper file for LaTeX.
+yax-doc.tex => The source of the documentation.
+yax-doc.pdf => The typeset documentation.
+
+To process the documentation source, you need the 
+piTeX files (available on CTAN) on top of plain TeX
+with LuaTeX at least v.0.6. Non-free fonts are used.
+
+Licensing of this package is covered by LPPL.
\ No newline at end of file
diff --git a/Master/texmf-dist/doc/generic/yax/yax-doc.pdf b/Master/texmf-dist/doc/generic/yax/yax-doc.pdf
new file mode 100644
index 00000000000..23eef84a30c
--- /dev/null
+++ b/Master/texmf-dist/doc/generic/yax/yax-doc.pdf
diff --git a/Master/texmf-dist/doc/generic/yax/yax-doc.tex b/Master/texmf-dist/doc/generic/yax/yax-doc.tex
new file mode 100644
index 00000000000..45ce047d1ee
--- /dev/null
+++ b/Master/texmf-dist/doc/generic/yax/yax-doc.tex
@@ -0,0 +1,894 @@
+\input pitex % which \input's YaX
+
+\setparameter document:
+  author   = "Paul Isambert"
+  title    = \yax
+  pdftitle = YaX
+  version  = 1.0
+  date     = "\the\month/\the\day/\the\year"
+  display  = outlines
+  subject  = "The YaX documentation."
+
+\setparameter page:
+  left       = 5cm
+  right      = 3cm
+  pageheight = 26cm
+
+\setparameter font :
+  command = \mainfont
+  name    = ChaparralPro-
+  roman   = Regular
+  italic  = Italic
+  bold    = Bold
+
+\setparameter font :
+  command = \sectionfont
+  size    = 13pt
+  name    = ChaparralPro-
+  roman   = Regular
+  italic  = Italic
+
+\setparameter font :
+  command = \titlefont
+  size    = 26pt
+  name    = ChaparralPro-
+  roman   = Regular
+
+\setparameter font:
+  command  = \codefont
+  name     = ltype
+  size     = 8.1pt
+  type     = ttf
+  roman    = {}
+  bold     = b
+  italic   = o
+  features = "\usevalue metafont:features -trep;"
+
+\setparameter section:
+  font   = \sectionfont
+  number = none
+  color  = ".8 0 0"
+
+\def\yax{%
+  Y\kern-.1em \raise.15em\hbox{\sc a}\kern-.1em \lower.15em\hbox{X}%
+  \ifcatnext a { }{\iffnext({ }}%
+  }
+\def\defarg#1#2{%
+  \def#1{\arg{#2}\kern1pt\antigobblespace}%
+  }
+\defarg\param{parameter} \defarg\paralist{list of parameters}
+\defarg\attr{attribute} \def\paramatt{\param\kern-1pt\tcode:\attr\antigobblespace}
+\defarg\attrlist{list of attributes} \defarg\vallist{list of values}
+\defarg\value{value} \defarg\ospace{optional space}
+\defarg\andvalue{value exists} \defarg\orvalue{no value}
+\defarg\true{true} \defarg\false{false}
+\defarg\codarg{code} \defarg\comarg{command}
+\def\describe{%
+  \ifnext!{\gobbleoneand{\let\COM\ecom\Describe}}
+          {\let\COM\com\Describe}%
+  }
+\def\ecom#1{{\mainfont\char"E01F}\com{#1}}
+\long\def\Describe#1#2.{%
+  \ifvmode \vskip\baselineskip \fi
+  \noindent\llap{\color{.8 0 0}{\COM#1}\iffemptystring{#2}{\kern1em}}#2%
+  \reverse\iffemptystring{#2}{\par\noindent}\ignorespaces
+  }
+
+\newblock*\syntax{\vskip\baselineskip\codefont\setcatcodes{\^^M=13}\obeylines}
+                 {\vskip\baselineskip}
+\extraboxspace=10pt
+
+\newbox\codebox
+\newbox\processbox
+\newdimen\prevcodedepth
+\def\processexample{%
+  \setbox\codebox=\vtop{%
+    \let\exampleskip\relax
+    \parindent0pt
+    \hsize.75\hsize
+    \typesetexample
+    \par
+    \global\prevcodedepth=\prevdepth
+    }%
+  \setbox\processbox=\vtop{%
+    \parindent0pt
+    \hsize.5\hsize
+    \doexample
+    }%
+  \exampleskip\exampleskip
+  \moveleft .25\hsize\hbox{\colorbox{.9 .9 .9}{\copy\codebox\copy\processbox}}%
+  \exampleskip\exampleskip
+  \prevdepth=\prevcodedepth
+  }
+
+
+\output{%
+  \shipout\vbox to\dimexpr(\vsize+3\baselineskip){%
+    \box255
+    \vfil
+    \hbox to\hsize{\mainfont\hfil\the\pageno\hfil}%
+    }
+  \advancepageno
+  }
+
+
+
+\vbox to 2\baselineskip{%
+  \vfil
+  \hbox to\hsize{\hfil\titlefont \usevalue document : title }
+  \vfil}
+
+\vskip\baselineskip
+\it
+\hfill \usevalue document : author \par
+\hfill \usevalue document : date \par
+\hfill v.\usevalue document : version \par
+
+\rm
+
+\vskip2\baselineskip
+
+
+\noindent\yax is Yet Another Key System, or \yax Ain't Keys, however you want it.
+It has some peculiarities. First, keys are not keys, but attributes,
+which means they depend on a parameter. You don't set key individually
+in \yax (although you can do it), you define parameters, which have
+attributes, which have values. Second, parameters can have definitions,
+so that when you set it you can also execute a command, or execute it
+later; thus, \yax is halfway between key management and macro definition.
+Finally, the syntax of \yax is not traditional: there are as few braces
+as possible, which you can find tremendously annoying, but it can be
+changed.
+
+And, of course, \yax is format-independant. Files are provided for 
+La\TeX\ and Con\TeX t, so you can input it with \verb/\usepackage{yax}/
+or \verb/\usemodule[yax]/ respectively; anywhere else just use \verb/\input yax/.
+
+
+
+
+\section{Setting parameters}
+
+\noindent Here's an example of how values are set:
+
+\example
+\setparameter Zappa :
+  firstname = Frank
+  motto     = "Music is the best"
+  hairstyle = \moustache
+\example/
+
+\noindent Here we have defined a \ital{parameter}, `\verb/Zappa/', which
+has \ital{attributes} `\verb/firstname/', `\verb/motto/' and `\verb/hairstyle/'
+with \ital{values} `\verb/Frank/', `\verb/Music is the best/' and `\verb/\moustache/'
+respectively. 
+
+\describe\setparameter.
+Here's how you set parameters more precisely. This command is the only way to set values.
+Its simplified syntax is as follows:
+
+\syntax
+\noindent\com\setparameter \paralist\ :
+  \attr\ = \value
+  \attr\ = \value
+  ...
+\noindent\com\par
+\syntax/
+
+\noindent First, the \com\par command that terminates the declaration:
+it was not chosen simply because it echoes \ital{parameter}, but above
+all because it can be implicit in a blank line, i.e. \com\setparameter
+can be delimited by a blank line. That's why in the first example there
+seemed to be nothing delimitating \com\setparameter: it is supposed to
+be followed by a blank line. I will regularly display parameter setting in this
+fashion, even though the following would be equally legitimate:
+
+\example
+\setparameter Zappa : firstname = Frank ... \par
+\example/
+
+\noindent barring readibility, obviously.
+
+As for the detail, \paralist is a list of space-delimited parameters,
+followed by a colon. Any space before the colon is removed, that's why
+
+\example
+\setparameter Zappa Boulez:  ... \par
+\setparameter Zappa Boulez : ... \par
+\example/
+
+\noindent set the attributes of the same \verb/Zappa/ and \verb/Boulez/ parameters.
+Which means, of course, that you can set the attributes of as many parameters
+as you wish by doing so. 
+
+The name of each parameter should be fully expandable. It can contain spaces,
+but then it should be enclosed between braces, since space delimits parameters
+in \paralist.
+
+Finally, you can use \com\setparameter several times on the same parameter(s),
+by default it does the same thing as using one big \com\setparameter. I say
+\ital{by default}, because things might occur between the two calls, e.g. the
+parameter might be active and have deleted its own attributes after the first
+call, which anyway is something we'll see later.
+
+Each \attr is made of the same thing as \param: i.e. anything expandable.
+However, an \attr cannot have a name beginning with the strings \verb/e:/,
+\verb/g:/ and \verb/x:/. Indeed, these prefixes are used to specify
+how an attribute is to be defined, and they are similar to \com\edef,
+\com\gdef and \com\xdef (with no prefix meaning \com\def), i.e.:
+
+\example
+\setparameter foo :
+     one   = \whatever
+  e: two   = \whatever
+  g: three = \whatever
+  x: four  = \whatever
+\example/
+
+\noindent defines, for the parameter \verb/foo/, the attributes \verb/one/
+and \verb/three/ as \com\whatever and the attributes \verb/two/ and \verb/four/
+as the full expansion of \com\whatever; moreover, \verb/one/ and \verb/two/
+are locally defined, whereas \verb/three/ and \verb/four/ are globally
+defined. The space between the prefix and the name of the parameter is
+optional.
+
+Finally, \value may be given in three ways. First, it can be delimited by
+a space, e.g.:
+
+\example
+\setparameter Zappa :
+  first name = Frank
+  motto      = {Music is the best}
+  ...
+\example/
+
+\noindent here the space is simply the end of the line. The spaces in
+\verb/Music is the best/ aren't seen, because of the braces (which will
+be removed from the value). Don't forget that control sequences eats
+the subsequent space, hence a control sequence can't be at the end of
+a value supposedly delimited by space without braces. Actually, it can't be at
+the beginning either (see below).
+
+Otherwise, \arg{value} can be given between double quotes:
+
+\example
+\setparameter Zappa :
+  first name = "Frank"
+  motto      = "Music is the best"
+  hairstyle  = "\mustache"
+\example/
+
+\noindent which basically act as braces. The space inserted here by the
+end of the line is optional and the following can be done:
+
+\example
+\setparameter Zappa:first name="Frank"motto="Music is the best"...\par
+\example/
+
+\noindent Finally, there's a special rule. Control sequences gobble the
+next space, but a \value can be made of one and only one control sequence,
+e.g.:
+
+\example
+\setparameter Zappa :
+  hairstyle  = \mustache
+  ...
+\example/
+
+\noindent i.e. if \yax sees a control sequence at the beginning of a value
+it will take this control sequence only as \arg{value}, which means that
+anything thereafter will be considered as belonging to the next \param
+name. Hence, all the following are bad ideas:
+
+\example
+\setparameter bad values :
+            % the space stops the value to "bad"
+  one   = bad space
+            % the control sequence is taken as the only token
+  two   = \control sequence 
+            % "\sequence" eats the delimitating space
+  three = control\sequence
+...
+\example/
+
+\noindent but they'd all be ok with quotes or braces (which
+still require a space after):
+
+\example
+\setparameter good values :
+  one   = "bad space"
+  two   = "\control sequence"
+  three = {control\sequence}
+  four  = \LonelyCommand
+  five  = "\Command\Command"
+...
+\example/
+
+\noindent Finally, they are some exceptions to this rule: first,
+always put \com\par between braces, otherwise it will be seen
+as the end of the parameter. Second, always put a character denotation
+between either braces or quotes, even if it's the only control sequence.
+If you don't know what character denotation means, never mind. Just remember
+that \com\bgroup and \com\egroup are character denotations.
+
+Now I'm sure you ask: what is this lousy syntax? An answer is I don't
+like braces. Another answer is \yax is not designed to store complicated
+strings, although it can do it. Instead it aims at setting simple values
+in an orderly fasion, e.g.:
+
+\example
+\setparameter page :
+  pagewidth    = 32cm
+  pageheight   = 30cm
+  lines        = 45
+  whatever     = \foo
+...
+\example/
+
+\noindent in which case it is very handy, especially when you're in a hurry:
+
+\example
+\setparameter page: pagewidth=32cm pageheight=30cm whatever=\foo...\par
+\example/
+
+\noindent Thus, I find commas to delimit values equally superfluous and find
+the odd quote better. Anyway setting parameters is far from the whole story.
+
+
+
+
+
+
+
+\sectioncommand{section}{The meta attribute}{The \ital{meta} attribute}
+\noindent You can give any attribute to any parameter (unless they're restricted,
+but that's not the point for the time being).
+However, there's one particular attribute which has a special meaning: \verb/meta/.
+The value of \verb/meta/ should be another parameter. Then, when querying
+the value of an attribute, say \verb/attr/, for a given parameter, say \verb/param/,
+\yax will do the following: if \verb/param/ has \verb/attr/, it is returned.
+Otherwise, if \verb/param/ has a \verb/meta/ attribute, whose value is for instance
+\verb/metaparam/, then \verb/attr/ is queried for the value of \verb/metaparam/.
+And if \verb/metaparam/ has no \verb/attr/ but has a \verb/meta/ attribute,
+this process continues, until either a parameter is found with \verb/attr/
+or there are no new \verb/meta/. For instance:
+
+\example
+\setparameter A : attr = value ... \par
+\setparameter B : meta = A ... \par
+\setparameter C : meta = B ... \par
+\example/
+
+\noindent If parameter \verb/C/ has no \verb/attr/, then it retrieves it
+from parameter \verb/A/ via \verb/B/ (or from \verb/B/ if it has one). On
+the other hand, if \verb/C/ has \verb/attr/, then its own value is returned.
+You can also query the value of an attribute for a parameter and forbid the
+search for \verb/meta/'s, as explained in the next section.
+
+Don't be afraid to create loop with \verb/meta/. The following is perfectly
+legitimate:
+
+\example
+\setparameter A : meta = C ... \par
+\setparameter B : meta = A ... \par
+\setparameter C : meta = B ... \par
+\example/
+
+\noindent and it can even be useful. \yax detects loops when searching
+\verb/meta/ paths and stops in time (with no value, obviously). Finally,
+you can set \verb/meta/ to a parameter that doesn't exist. It will simply
+return no value. 
+
+The use of \verb/meta/ is useful to create families
+of parameters and/or to set default values, e.g.:
+
+\example
+\setparameter mammal :
+  egg = no
+  fur = yes
+  ...
+\setparameter cat whale :
+  meta = mammal
+  ...
+\setparameter cat :     \setparameter whale :
+  foot  = clawed          fur   = no
+  tooth = fang            foot  = flipper
+  ...                     tooth = baleen
+                          ...
+\setparameter tiger mykitty : 
+  meta     = cat
+  stripped = yes
+  ...
+\setparameter tiger :       \setparameter mykitty :
+  foot = "very bad news"      foot = "bad news"
+  ...                         ...
+\example/
+
+Apart from that, \verb/meta/ behaves as any other attribute, i.e. it can
+be freely set and queried.
+
+
+
+
+
+
+
+
+\section{Using values}
+
+\noindent Once attributes have been set, they can be queried by the macros
+that follow. But first, one last bit of odd syntax: \paramatt means anything
+up to the colon as the \param and then anything up to the next space as 
+the \attr. That's the reason why space in attribute names is a bad idea:
+the space is the main delimitator when using attributes. It is gobbled
+in the process. On the other hand,
+any space surrounding the colon is removed, so that `\verb/zappa:hairstyle/ '
+and `\verb/zappa : hairstyle/ ' denote the same attribute of the same parameter.
+Good news, though: if you don't like that syntax, the next section explains
+how to create commands with the same meaning but a different syntax.
+
+In what follows, fully expandable commands are marked with \color{.8 0 0}{\char"E01F}.
+
+\describe!\nometa\arg{command}.
+All the commands that follow can be prefixed with \com\nometa, except
+\com\deleteattribute. In this case,
+\yax will return the value of the attribute for the specified parameter,
+as usual, or return no value, i.e. it will not search \verb/meta/ parameters.	
+So, in what follows, `\paramatt is defined' means two things. If \com\nometa
+isn't used, it means that \param has \attr or it has a metaparameter with
+\attr; on the other hand, if \com\nometa is used, it means that \param has
+\attr, end of story.
+
+\describe!\ifattribute\paramatt\true\false.
+This returns \true if \paramatt is defined, \false otherwise. Since all
+commands below always check whether \paramatt is defined before trying
+to do anything with the value, this command can be avoided most of the
+time.
+
+\setparameter musician :
+  job = music
+
+\setparameter Zappa :
+  meta      = musician
+  firstname = Frank
+
+
+\Example
+\setparameter musician : job = music\par
+\setparameter Zappa :
+  meta      = musician
+  firstname = Frank
+
+                       % See this space?
+\ifattribute Zappa : job {Good, it is.}{...}\par
+\nometa\ifattribute Zappa : job {...}{Too bad.}
+\Example/
+
+
+
+
+
+\describe!\usevalue\paramatt.
+\describe!\usevalueor\paramatt\orvalue.
+\describe!\usevalueand\paramatt\andvalue\orvalue.
+The first macro returns the value of \paramatt if it exists, or
+does nothing otherwise. Like all the \verb/-or/ and \verb/-and/
+variants below, \com\usevalueor executes \orvalue in case 
+\paramatt doesn't exist, while \com\usevalueand returns
+the value of \paramatt immediately followed by \andvalue
+(no brace added) if \paramatt exists, otherwise it executes
+\orvalue.
+
+\Example
+Zappa's job was \usevalueand Zappa : job 
+                             { (and then some!)}
+                             {unknown}
+and he played the \usevalueor Zappa : instrument 
+                              {guitar}.
+\Example/
+
+
+\describe!\passvalue\codarg\paramatt.
+\describe!\passvalueor\codarg\paramatt\orvalue.
+\describe!\passvalueand\codarg\paramatt\andvalue\orvalue.
+These return \codarg\barg{value} if \paramatt is defined,
+with the \verb/-or/ and \verb/-and/ variants as above.
+
+\Example
+\def\whichwas#1{(which was #1)}
+Zappa's job \passvalue\whichwas Zappa : job \ took
+most of his time, because it's a time-consuming
+occupation \nometa\passvalueor\whichwas Zappa : job
+                               {(you know which)}.
+\Example/
+
+\describe!\passvaluenobraces\codarg\paramatt.
+\describe!\passvaluenobracesor\codarg\paramatt\orvalue.
+\describe!\passvaluenobracesand\codarg\paramatt\andvalue\orvalue.
+These are the same as \com\passvalue and variants except the
+value of the attribute is concatenated to \codarg without braces
+(which means that no braces are added in the process, not that
+braces are removed from the value if it has any).
+
+\describe\settovalue\arg{dimen or count}\paramatt.
+\describe\settovalueor\arg{dimen or count}\paramatt\orvalue.
+\describe\settovalueand\arg{dimen or count}\paramatt\andvalue\orvalue.
+This sets the first argument to the value of \paramatt if it exists.
+If the first argument is more than one token (e.g. \verb/\count0/
+vs. \verb/\parindent/), it must be surrounded by braces; and actually
+it can even be something like \verb/\advance\count0/. Of course
+\arg{dimen or count} must be a dimension or a count, and the value 
+of \paramatt must be accordingly a dimension
+or a number (\yax doesn't check either of them).
+
+\Example
+\setparameter para  : parskip = 2pt \par
+Note that 
+\settovalueor\parskip para : parskip
+                      {\parskip=1pt\relax}
+(\the\parskip) is basically the same thing as
+\parskip=\usevalueor para : foo {1pt\relax}
+(\the\parskip).
+\Example/
+
+What the previous example shows is that since \com\usevalue
+is thoroughly expandable one can say:
+
+\example
+\mydimen=\usevalueor parameter : attribute {0pt}
+\example/
+
+\noindent and it will set \com\mydimen to the value
+of \paramatt or to \verb/0pt/. The difference with \com\settovalueor
+is that in the construction with \com\usevalueor the assignement
+is obligatorily made (hence the \verb/-or/ variant), whereas
+with \com\settovalueor the or-clause can do something else
+(e.g. send an error message). And \com\settovalue insert a
+prophylactic \com\relax.
+
+
+
+
+\describe\storevalue\comarg\paramatt.
+\describe\storevalueor\comarg\paramatt\orvalue.
+\describe\storevalueand\comarg\paramatt\andvalue\orvalue.
+These define \comarg as the value of \paramatt if it exists.
+
+\Example
+\setparameter Zappa : hairstyle = \moustache\par
+\storevalue\beard Zappa : hairstyle
+\meaning\beard
+\Example/
+
+
+
+\describe!\ifvalue\paramatt=\value\ \true\false.
+This returns \true if the value of \paramatt is \value
+and \false otherwise (including unexisting \paramatt).
+Note that when comparing the value of \paramatt with
+\value, catcodes aren't part of the picture.
+Here \value is delimited by the following space, but
+there might be optional space after the `\verb/=/' sign.
+Because of this, it is not possible to test for the
+emptyness of a value with \com\ifvalue, i.e.
+
+\example
+\ifvalue foo : bar = {} {true}{false}
+\example/
+
+\noindent won't work. Instead, either use \com\ifcasevalue below or \com\passvalue
+with an emptyness-tester (e.g. \verb/texapi/'s
+\com\ifemptystring, since \yax is based on \verb/texapi/
+(what, me, self-advertising?)).
+
+\Example
+\bgroup \catcode`\Z=13
+\setparameter foo :
+  g: bar = Z \par
+\egroup
+\edef\foobar{%
+  \ifvalue foo : bar = Z {yes}{no},
+  even though catcodes are different.}
+\meaning\foobar
+\Example/
+
+
+
+
+\describe!\ifcasevalue\paramatt.
+  \describe\val\value\ \codarg.
+  \describe\val\value\ \codarg.
+          \verb/.../ \par\noindent
+  \describe\elseval \codarg.
+  \describe\endval\relax.
+This executes \codarg following \value matching
+the value of \paramatt. If \paramatt doesn't exist, or
+matches no \value, then \com\elseval is executed. Once again
+catcodes aren't taken into account when values are compared.
+The exact syntax is: \value is anything from \com\val to the
+next space, and \codarg is anything that follows up to the next
+\com\val, \com\elseval or \com\endval (any space on the right
+is removed, so no need to stick \com\val to \codarg).
+Apart from \com\endval, everything here is optional: there might
+be as many \com\val-clauses as needed, including none, and the
+\com\elseval-clause need not be present (in which case, if no
+match occurs, nothing happens). Finally, although this is
+similar to \TeX's primitive \com\ifcase, there's no need
+to jump before anything with \com\expandafter to avoid
+bumping into conditional structure. 
+
+\Example
+\def\doitalic#1{{\it#1}}
+\setparameter type : font = italic \par
+\ifcasevalue type : font
+  \val italic \doitalic
+  \val bold   \dobold
+\endval{Some text.}
+
+\edef\foo{%
+  \ifcasevalue type : font
+    \val bold This is bold
+    \elseval  This is something else
+  \endval}
+\meaning\foo
+\Example/
+
+
+\describe\deleteattribute\paramatt.
+This deletes \paramatt, which now responds negatively
+to all previous commands, as if it was never defined.
+If \paramatt doesn't exist, and if \param has \verb/meta/-parameters
+with \attr, those are not deleted. Hence \com\nometa can't be
+prefixed to \com\deleteattribute, because it doesn't make sense.
+
+
+
+
+
+\section{Using another syntax}
+
+\noindent If you don't like \yax's native syntax, and want for instance
+good old braces to delimit \param and \attr, you might be tempted
+to do something like:
+
+\example
+\def\myusevalue#1#2{\usevalue #1:#2 }
+\example/
+
+\noindent On the other hand, if you don't mind \yax's syntax
+but want other names for the commands, then you'll probably go:
+
+\example
+\let\myusevalue\usevalue
+\example/
+
+\noindent Both are bad ideas. Indeed, in neither example will
+\com\myusevalue work properly with \com\nometa. Besides, you
+have to create the \verb/-or/ and \verb/-and/ variants by hand.
+Not to mention that in the first example \com\myusevalue wastes
+time calling \com\usevalue (and what if it is redefined?) when
+it could be in direct relation with internal code. So here's how
+to circumvent \yax's syntax and/or create new names.
+
+\describe\newsyntax\arg{syntax}\barg{prefix}.
+This creates commands whose names are \verb/\/\arg{prefix}\comarg
+and whose syntax for arguments is \arg{syntax}. The latter is
+a parameter text which must contain \verb/#1/ and \verb/#2/ (for
+\param and \attr respectively) with whatever to delimit them.
+For instance:
+
+\example
+\newsyntax#1#2{x}
+\newsyntax#1 #2!{y}
+\example/
+
+\noindent will create among others an \com\xusevalue command whose usage is
+\com\xusevalue\param\attr and a \com\yusevalue command whose
+usage is \com\yusevalue\param\ \attr\tcode! and both will do the
+same thing as \com\usevalue. There must be braces around \arg{prefix}
+and none around \arg{syntax} (i.e. the latter is delimited by
+the left brace of the former). If \arg{prefix} is empty,
+you redefine the default commands, which is dangerous.
+
+To be precise, the commands copied are (omitting the \verb/-or/
+and \verb/-and/ variants, which are created too, if any):
+\com\ifattribute, \com\usevalue, \com\passvalue, \com\passvaluenobraces,
+\com\settovalue, \com\storevalue, \com\ifvalue, \com\ifcasevalue,
+\com\deleteattribute and \com\restrictattribute (which you'll learn
+about in the next section).
+
+\describe\copysyntax\arg{prefix1}\arg{prefix2}.
+This defines all the commands above with \arg{prefix1} as
+those same commands with \arg{prefix2}.
+
+\describe\letyaxcommand\arg{command1}\arg{command2}.
+This at the very least \com\let \arg{command1} to \arg{command2}.
+Besides, if \arg{command2} can take a \com\nometa prefix,
+\arg{command1} can too. Finally, if \arg{command2} has 
+\verb/-or/ and \verb/-and/ variants, these are created with
+\arg{command1}. E.g.:
+
+\example
+\letyaxcommand\defval\storevalue
+\example/
+
+\noindent defines \com\defval, \com\defvalor and \com\defvaland
+as \com\storevalue and its variants. If \arg{command2} has been
+created with \com\newsyntax or \com\copysyntax, \arg{command1}
+of course has the same syntax.
+
+
+\Example
+\newsyntax#1#2{x}
+\letyaxcommand\uv\xusevalue
+\uvand{noparameter}{noattribute}{yes}{no}
+\Example/
+
+
+\section{Restrictions on parameters and attributes}
+
+
+\describe\restrictparameter\paralist:\attrlist\tcode{\char`\\par}.
+After this declaration, the \param's in \paralist (where they are separated
+by space as in \com\setparameter) can take only those \attr's in
+\attrlist (which are also separated by space). It affects \com\setparameter
+only, producing an error message when an \attr not belonging to
+\attrlist is given a value (and the assignment isn't made, of course).
+Even if it doesn't belong to \attrlist, the \verb/meta/ attribute is
+always allowed. Several \com\restrictparameter declarations on the
+same parameter(s) actually accumulate the allowed attributes in \paralist, 
+e.g. after
+
+\example
+\restrictparameter foo : one two three\par
+\restrictparameter foo : four\par
+\example/
+
+\noindent one can set the attributes \verb/one/, \verb/two/, \verb/three/
+and \verb/four/ for \verb/foo/, and not only \verb/four/. The idea behind
+\com\restrictparameter is not so much hiding attributes from the user
+as making the use of a parameter clearer by indicating which attributes
+are in use with it, especially if it can be executed (see below).
+
+\describe\restrictattribute\paramatt\ \vallist\tcode{\char`\\par}.
+This restricts \paramatt to take only the values in \vallist (separated
+by space).
+
+\describe\restrictallattributes\attr\ \vallist\tcode{\char`\\par}.
+This restricts \attr, whatever the \param in which it appears, to
+take only the values in \vallist. In this command, \attr is
+found as anything before the first space, e.g.:
+
+\example
+\restrictallattributes attribute value1 value2 value3\par
+\restrictallattributes {attri bute} value1 value2 value3\par
+\example/
+
+\noindent (the second example if you want to have space in attribute
+names). Note that if an attribute is restricted with both
+\com\restrictattribute and \com\restrictallattributes, 
+only the former restriction holds. E.g.:
+
+\example
+\restrictattribute foo:bar one\par
+\restrictallattributes bar two three\par
+\setparameter foo: 
+  bar = two % Will produce an error message.
+  ...
+\example/
+
+
+
+
+\section{Defining parameters}
+
+\describe\defparameter\paralist\barg{definition}.
+Parameters aren't just a way of organizing attributes. They
+can have a definition and act as commands whose arguments
+are the values of their attributes. The \paralist (with
+parameters once again separated by space) must be
+braceless, whereas \arg{definition} must be enclosed in
+braces (like a real definition). No parameter text is
+allowed. However, \arg{definition} can contain `\verb/#1/',
+which doesn't refer to any argument but to the parameter
+being defined instead, so that one can use the commands
+defined in the previous section without specifying the name
+of the parameter. E.g.
+
+\example
+\defparameter foo bar {%
+  \usevalue #1 : one
+  \passvalueor\mycomm #1 : whatever {...}%
+  ...}
+\example/
+
+\noindent defines \verb/foo/ and \verb/bar/ respectively
+to
+
+\example
+\usevalue foo : one
+\passvalueor\mycomm foo : whatever {...}%
+...
+\usevalue bar : one
+\passvalueor\mycomm bar : whatever {...}%
+...
+\example/
+
+\describe!\executeparameter\param:.
+This executes the definition of \param with the the latest values
+of its attributes. If \param hasn't been defined, nothing happens.
+
+\Example
+\defparameter foo {The value is \usevalue#1:bar }
+\setparameter foo : bar = whatever\par
+\executeparameter foo:
+\Example/
+
+
+\describe\defactiveparameter\paralist\barg{definition}.
+This does the same thing as \com\defparameter, i.e. define the 
+parameters in \paralist, but it also set them as `active,'
+which means that they're automatically executed each time
+their attributes are defined with \com\setparameter. You
+can still use \com\executeparameter.
+
+\Example
+\setparameter metasection : skip = 2 font = \it\par
+\setparameter mysection : % not yet active
+  meta = metasection\par
+\defactiveparameter mysection {%
+  \vskip \usevalueor #1 : skip 0\baselineskip
+  {\usevalue #1 : font \usevalue #1 : title }%
+  \par}  
+
+And now we're going to have a new section.
+\setparameter mysection : title = "A new section"\par
+Fascinating. Once again?
+\setparameter mysection : title = "Once again"\par
+Cool.  
+\Example/
+
+\vskip-2\baselineskip
+\Example
+\setparameter metasection : 
+  skip   = 2
+  inline = false
+  font = \it
+
+\setparameter mysection mysubsection :
+  meta = metasection
+
+\setparameter mysection :
+  font = \sc
+
+\setparameter mysubsection :
+  skip   = 1
+  inline = true
+
+\defparameter mysection mysubsection {%
+  \vskip \usevalueor #1 : skip 0\baselineskip
+  {\usevalue #1 : font \usevalue #1 : title }%
+  \ifvalue #1 : inline = true {. \ignorespaces}%
+                              \par}%  
+
+\def\section#1{%
+  \setparameter mysection : title = {#1}\par
+  \executeparameter mysection :}
+
+\def\subsection#1{%
+  \setparameter mysubsection : title = {#1}\par
+  \executeparameter mysubsection :}
+
+
+... and this is the end of our paragraph.
+\section{New ideas}
+Here we are going to expose bold new ideas.
+\subsection{First bold new idea}
+Lore, aim, hip, sum... what do you think about
+it? Pig latin, you say?
+\subsection{Second bold new idea}
+Perhaps Do lore, aim... then, huh?
+\section{New new ideas}
+Etc.
+\Example/
+\bye
\ No newline at end of file
diff --git a/Master/texmf-dist/tex/generic/yax/t-yax.tex b/Master/texmf-dist/tex/generic/yax/t-yax.tex
new file mode 100644
index 00000000000..49d6af4a0b5
--- /dev/null
+++ b/Master/texmf-dist/tex/generic/yax/t-yax.tex
@@ -0,0 +1,24 @@
+% This is t-yax.tex, a third-party file to load
+% the YaX package in ConTeXt. Useful information
+% can be found in yax-doc.pdf
+% 
+% Author: Paul Isambert.
+% E-mail: zappathustra AT free DOT fr
+% Comments and suggestions are welcome.
+% Date: June 2010.
+%
+%D \module
+%D   [     file=t-yax,
+%D      version=2010.06.17,
+%D        title=\CONTEXT\ User Module,
+%D     subtitle=YaX,
+%D       author=Paul Isambert,
+%D         date=\currentdate,
+%D    copyright=Paul Isambert,
+%D        email=zappathustra@free.fr,
+%D      license=LaTeX Project Public License]
+
+\writestatus{loading}{ConTeXt User Module / yax}
+\chardef\formatnumber=3
+\input yax.tex
+\endinput
diff --git a/Master/texmf-dist/tex/generic/yax/yax.sty b/Master/texmf-dist/tex/generic/yax/yax.sty
new file mode 100644
index 00000000000..58477727ee7
--- /dev/null
+++ b/Master/texmf-dist/tex/generic/yax/yax.sty
@@ -0,0 +1,14 @@
+% This is yax.sty, a style file to load
+% the YaX package in LaTeX. Useful information
+% can be found in yax-doc.pdf
+% 
+% Author: Paul Isambert.
+% E-mail: zappathustra AT free DOT fr
+% Comments and suggestions are welcome.
+% Date: June 2010.
+
+\NeedsTeXFormat{LaTeX2e}
+\ProvidesPackage{yax}[2010/06/17 v.1.0 Yet Another Key System.]
+\chardef\formatnumber=4
+\input yax.tex
+\endinput
\ No newline at end of file
diff --git a/Master/texmf-dist/tex/generic/yax/yax.tex b/Master/texmf-dist/tex/generic/yax/yax.tex
new file mode 100644
index 00000000000..f799557634d
--- /dev/null
+++ b/Master/texmf-dist/tex/generic/yax/yax.tex
@@ -0,0 +1,535 @@
+% This is the YaX package.
+% Relevant information can be found in yax-doc.pdf
+%
+% Author: Paul Isambert.
+% E-mail: zappathustra AT free DOT fr
+% Comments and suggestions are welcome.
+% Date: June 2010.
+%
+\input texapi % Everything I need. It figures: I wrote it for this.
+
+\setcatcodes{@_=11}
+\def\yax@error{\senderror{YAX}}
+
+%
+% Retrieval of parameter and attribute.
+%
+\def\yax@getparameter#1#2:{%
+  \passtrim{#2}{#1}%
+  }
+\def\yax@defparameter#1#2{%
+  \def\yax@parameter{#2}#1
+  }
+% #1 and #2 are thing_to_do and parameter.
+\def\yax@getattribute#1#2#3 {%
+  \ifemptystring{#3}{\yax@getattribute{#1}{#2}}
+                    {#1{#2}{#3}}%
+  }
+% \yax@getall\foo
+% => \foo{<parameter>}{<attribute>}
+\def\yax@getall#1{%
+  \yax@getparameter{\yax@getattribute{#1}}%
+  }
+%
+\long\def\yax@get_topar#1#2\par{%
+  #1{#2}%
+  }
+%
+%
+%
+%
+% SETTING PARAMETERS
+%
+% The crux of the biscuit.
+%
+% \setparameter <list of parameters> :
+%   <prefix><attribute1> = <value1>
+%   <prefix><attribute2> = <value2>
+%   ...
+%   <prefix><attributeN> = <valueN>
+% \par
+%
+% A generic loop for space-delimited lists.
+% The the texapi documentation for the information on the \newfor loop.
+%
+\newfornoempty\yax@space_loop{1}#2 {#1{#2}}%
+%
+\pdef\setparameter{%
+  \yax@getparameter\yax@setparameter_getattributes
+  }
+\long\def\yax@setparameter_getattributes#1#2\par{%
+  \yax@space_loop{\yax@setparameter{#2}}{#1 }%
+  }
+\long\def\yax@setparameter#1#2{%
+  \deftrim\yax@parameter{#2}%
+  \yax@setattributes_loop{#1 }% The space at the end delimits the last value if needed.
+  }
+\newfor\yax@setattributes_loop#1={%
+  \passtrim{#1}\yax@setattributes_checkprefix
+  \pausefor\yax@setattributes_howgiven
+  }[\iffcs{yax@\yax@parameter @active}
+      {\usecs{yax@\yax@parameter @def}}]
+\def\yax@setattributes_checkprefix#1{%
+  \ifprefix{e:}{#1}
+      {\let\yax@dodef\edefcs \removeprefixand{e:}{#1}{\deftrim\yax@attribute}}
+      {\ifprefix{g:}{#1}
+           {\let\yax@dodef\gdefcs \removeprefixand{g:}{#1}{\deftrim\yax@attribute}}
+           {\ifprefix{x:}{#1}
+                {\let\yax@dodef\xdefcs \removeprefixand{x:}{#1}{\deftrim\yax@attribute}}
+                {\let\yax@dodef\defcs \def\yax@attribute{#1}}}}%
+  }
+\def\yax@setattributes_howgiven{%
+  \ifnextnospace"
+      \yax@setattributes_getquote
+       % No need for a new nospace: it has been removed
+      {\ifcatnext\foo
+           \yax@setattributes_do % Since one visible \cs is supposed to be the only token in value.
+           \yax@setattributes_getspace}%
+  }
+\long\def\yax@setattributes_getquote"#1"{%
+  \yax@setattributes_do{#1}%
+  }
+\long\def\yax@setattributes_getspace#1 {%
+  \yax@setattributes_do{#1}%
+  }
+\newif\ifyax@makedef
+\long\def\yax@setattributes_do#1{%
+  \yax@makedeftrue
+  \iffcs{yax@\yax@parameter @restricted}% Parameter restricted.
+        {\reverse\iffcs{yax@\yax@parameter:\yax@attribute @allowed}% Attribute not allowed.
+                      {\yax@makedeffalse
+                       \yax@error{Attribute `\unexpandedcs{yax@attribute}'
+                         is not allowed in parameter `\yax@parameter'.
+                         Authorized attributes are `\unexpandedcs{yax@\yax@parameter @restricted}'}}}%
+  \ifcs{yax@\yax@parameter:\yax@attribute @restricted}% Attribute restricted in this parameter.
+       {\reverse\iffcs{yax@\yax@parameter:\yax@attribute:\detokenize{#1}@allowed}% Value not allowed.
+                      {\yax@makedeffalse
+                       \yax@error{Value `\detokenize{#1}'
+                         is not allowed in attribute `\yax@parameter:\yax@attribute'.
+                         Authorized values are `\unexpandedcs{yax@\yax@parameter:\yax@attribute @restricted}'}}}%
+        {\iffcs{yax@attribute@\yax@attribute @restricted}% Attribute restricted in all parameters.
+               {\reverse\iffcs{yax@attribute@\yax@attribute:\detokenize{#1}@allowed}% Value not allowed.
+                              {\yax@makedeffalse
+                                \yax@error{Value `\detokenize{#1}'
+                                  is not allowed in attribute `\yax@attribute'.
+                                  Authorized values are `\unexpandedcs{yax@attribute@\yax@attribute @restricted}'}}}}%
+  \ifyax@makedef
+    \yax@dodef{yax@\yax@parameter:\yax@attribute}{#1}%
+  \fi
+  \resumefor\yax@setattributes_loop% Better not to forget this!
+  }
+%
+%
+%
+%
+% \restrictparameter <list of parameters> : 
+%   <attribute1>
+%   <attribute2>
+%   ...
+%   <attributeN>
+% \par
+%
+\pdef\restrictparameter{%
+  \yax@getparameter\yax@restrictparameter_getrestrictions
+  }%
+\long\def\yax@restrictparameter_getrestrictions#1#2\par{%
+  \yax@space_loop{\yax@restrictparameter{#2 meta }}{#1 }% Meta is always allowed.
+  }
+\long\def\yax@restrictparameter#1#2{%
+  \def\yax@parameter{#2}%
+  \yax@space_loop\yax@restrictparameter_readrestrictions{#1}%
+  }
+\long\def\yax@restrictparameter_readrestrictions#1{%
+  \letcs{yax@\yax@parameter :#1@allowed}\relax
+  \ifcs{yax@\yax@parameter @restricted}
+        {\addrightcs{yax@\yax@parameter @restricted}{, #1}}
+        {\defcs{yax@\yax@parameter @restricted}{#1}}%
+  }
+%
+% \restrictattribute <parameter>:<attribute>
+%   <value1>
+%   <value2>
+%   ...
+%   <valueN>
+%\par
+%
+\pdef\restrictattribute{%
+  \yax@getall\yax@restrictattribute_getrestrictions
+  }
+\long\def\yax@restrictattribute_getrestrictions#1#2#3\par{%
+  \yax@space_loop{\yax@restrictattribute_readrestrictions{#1}{#2}}{#3 }%
+  }
+\long\def\yax@restrictattribute_readrestrictions#1#2#3{%
+  \letcs{yax@#1:#2:\detokenize{#3}@allowed}\relax
+  \ifcs{yax@#1:#2@restricted}
+        {\addrightcs{yax@#1:#2@restricted}{, #3}}
+        {\defcs{yax@#1:#2@restricted}{#3}}%
+  }
+%
+% \restrictallattributes <attribute>
+%   <value1>
+%   <value2>
+%   ...
+%   <valueN>
+%\par
+%
+\long\pdef\restrictallattributes#1 #2\par{%
+  \yax@space_loop{\yax@restrictallattributes_readrestrictions{#1}}{#2 }%
+  }
+\long\def\yax@restrictallattributes_readrestrictions#1#2{%
+  \letcs{yax@attribute@#1:\detokenize{#2}@allowed}\relax
+  \ifcs{yax@attribute@#1@restricted}
+        {\addrightcs{yax@attribute@#1@restricted}{, #2}}
+        {\defcs{yax@attribute@#1@restricted}{#2}}%
+  }
+%
+%
+%
+%
+% \defparameter<list of parameters>{<definition>}
+% \defactiveparameter<list of parameters>{<definition>}
+% \executeparameter <parameter> : 
+% 
+\newif\ifyax@activeparameter
+\def\defparameter#1#{%
+  \def\yax@parameter{#1 }%
+  \afterassignment\yax@defparameter_do
+  \def\yax@temp##1%
+  }%
+\def\yax@defparameter_do{%
+  \passexpanded{\yax@space_loop\yax@defparameter_def}\yax@parameter
+  }
+
+\def\defactiveparameter{%
+  \yax@activeparametertrue\defparameter
+  }%
+\long\def\yax@defparameter_def#1{%
+  \edefcs{yax@#1@def}{\unexpanded\expandafter{\yax@temp{#1}}}%
+  \ifyax@activeparameter
+    \yax@activeparameterfalse
+    \letcs{yax@#1@active}\relax
+  \fi
+  }
+\def\executeparameter{%
+  \yax@getparameter\yax@executeparameter
+  }
+\def\yax@executeparameter#1{%
+  \iffcs{yax@#1@def}{\csname yax@#1@def\endcsname}%
+  }
+%
+%
+%
+%
+% \deleteattribute <parameter> : <attribute>
+%
+\def\deleteattribute{%
+  \yax@getall\yax@deleteattribute
+  }
+\def\yax@deleteattribute#1#2{%
+  \letcs{yax@#1:#2}\yax@undefined
+  }
+%
+%
+%
+%
+% USING VALUES
+%
+% These are the loops used to check whether <parameter>:<attribute> exists,
+% and if not to search the meta-parameters. They are used of course in
+% \usevalue and associates.
+% I could use one loop only for all macros, but then I should have used more
+% internal code to pass arguments here and there.
+%
+% #1 = list of parameters already checked (used to spot loops in meta-search)
+%    => becomes {#1{#3}} on each iteration.
+% #2 = command executed on yax@<parameter>:<attribute> if it exists.
+%    => doesn't change from one iteration to the next.
+% #3 = <parameter>
+%    => becomes \usecs{yax@<parameter>:<meta>} on each iteration, thus
+%    returning a new <parameter> to be searched.
+% #4 = <attribute>
+%    => doesn't change from one iteration to the next.
+% #5 = <or> if alone, <and> when #6 exists.
+% #6 = <and>.
+%    => neither change.
+%
+% The loop does the following:
+% If <parameter>:<attribute> exists, then execute #2 on it followed by <and> if any.
+% Or, if <parameter> has a meta attribute, it calls
+% the \yax@ifattribute_checkmeta subloop with <or> and <parameter>
+% as passed arguments and <list of previous parameters> as the list argumen.
+% This command compare each item in the list with <parameter>, and if they
+% have the same meta, it means we're in a meta-loop, we break and execute <or>.
+% If no match obtains, we rerun the original loop (with #3 turned to its meta).
+% Or, if <parameter> had no meta in the first place, we break and execute <or>.
+%
+\newwhile\yax@ifattribute_noarg4{#1{#3}}{#2}{\usecs{yax@#3:meta}}{#4}{%
+  \ifcs{yax@#3:#4}
+       {\breakwhile{#2{yax@#3:#4}}}
+       {\ifcs{yax@#3:meta}% <parameter> has no <attribute>.
+             {\yax@ifattribute_checkmeta{}{#3}{#1}}% It has a meta, though. We do some testing (see next macro).
+             {\breakwhile{}}}% No meta, we break the loop, gobble <true> and release <false>  
+  }
+\newwhile\yax@ifattribute_or5{#1{#3}}{#2}{\usecs{yax@#3:meta}}{#4}{#5}{%
+  \ifcs{yax@#3:#4}
+       {\breakwhile{#2{yax@#3:#4}}}
+       {\ifcs{yax@#3:meta}
+             {\yax@ifattribute_checkmeta{#5}{#3}{#1}}
+             {\breakwhile{#5}}}%
+  }
+\newwhile\yax@ifattribute_and6{#1{#3}}{#2}{\usecs{yax@#3:meta}}{#4}{#5}{#6}{%
+  \ifcs{yax@#3:#4}
+       {\breakwhile{#2{yax@#3:#4}#5}}
+       {\ifcs{yax@#3:meta}
+             {\yax@ifattribute_checkmeta{#6}{#3}{#1}}
+             {\breakwhile{#6}}}%
+  }
+% The _if version pass <or> to the execution of the parameter,
+% since a test is supposed to happen.
+\newwhile\yax@ifattribute_if6{#1{#3}}{#2}{\usecs{yax@#3:meta}}{#4}{#5}{#6}{%
+  \ifcs{yax@#3:#4}
+       {\breakwhile{#2{yax@#3:#4}{#5}{#6}}}
+       {\ifcs{yax@#3:meta}
+             {\yax@ifattribute_checkmeta{#6}{#3}{#1}}
+             {\breakwhile{#6}}}%
+  }
+\newfor\yax@ifattribute_checkmeta{2}#3{%
+  \iffxcscs{yax@#2:meta}{yax@#3:meta}% Both parameters have the same meta. So we're in a meta-loop, and we break.
+           {\breakfor{\breakwhile{#1}}}%
+  }
+%
+% The  nometa version are definitely simpler.
+%
+\long\def\yax@ifattributenometa_and#1#2#3#4#5{%
+  \ifcs{yax@#2:#3}{#1{yax@#2:#3}#4}{#5}%
+  }
+\long\def\yax@ifattributenometa_or#1#2#3#4{%
+  \ifcs{yax@#2:#3}{#1{yax@#2:#3}}{#4}%
+  }
+\def\yax@ifattributenometa_noarg#1#2#3{%
+  \iffcs{yax@#2:#3}{#1{yax@#2:#3}}%
+  }
+%
+%
+%
+%
+% \nometa
+%
+\def\nometa#1{%
+  \ifcs{yax@\commandtoname#1_nometa}
+       {\usecs{yax@\commandtoname#1_nometa}}
+       {\yax@error{You can't use \noexpand\nometa before \string#1}}%
+  }
+%
+%
+%
+% Defining \<com>, \<com>or and \<com>and at once, 
+% with the \nometa-variant.
+%
+\def\yax@def_noarg#1#2{%
+  \def#1{\yax@getall{\yax@ifattribute_noarg{}{#2}}}%
+  \defcs{\commandtoname#1or}{\yax@getall{\yax@ifattribute_or{}{#2}}}%
+  \defcs{\commandtoname#1and}{\yax@getall{\yax@ifattribute_and{}{#2}}}%
+%
+  \defcs{yax@\commandtoname#1_nometa}{\yax@getall{\yax@ifattributenometa_noarg{#2}}}%
+  \defcs{yax@\commandtoname#1or_nometa}{\yax@getall{\yax@ifattributenometa_or{#2}}}%
+  \defcs{yax@\commandtoname#1and_nometa}{\yax@getall{\yax@ifattributenometa_and{#2}}}%
+  }
+\def\yax@def_onearg#1#2{%
+  \def#1##1{\yax@getall{\yax@ifattribute_noarg{}{#2{##1}}}}%
+  \defcs{\commandtoname#1or}##1{\yax@getall{\yax@ifattribute_or{}{#2{##1}}}}%
+  \defcs{\commandtoname#1and}##1{\yax@getall{\yax@ifattribute_and{}{#2{##1}}}}%
+%
+  \defcs{yax@\commandtoname#1_nometa}##1{\yax@getall{\yax@ifattributenometa_noarg{#2{##1}}}}%
+  \defcs{yax@\commandtoname#1or_nometa}##1{\yax@getall{\yax@ifattributenometa_or{#2{##1}}}}%
+  \defcs{yax@\commandtoname#1and_nometa}##1{\yax@getall{\yax@ifattributenometa_and{#2{##1}}}}%
+  }
+%
+%
+%
+%
+% \ifattribute
+%
+\def\ifattribute{%
+  \yax@getall{\yax@ifattribute_and{}\gobbleone}%
+  }%
+\def\yax@ifattribute_nometa{%
+  \yax@getall{\yax@ifattributenometa_and\gobbleone}%
+  }
+%
+%
+%
+%
+% \passvalue
+%
+\yax@def_onearg\passvalue\yax@passvalue
+\def\yax@passvalue#1#2{%
+  \passexpandedcs{#1}{#2}%
+  }
+\yax@def_onearg\passvaluenobraces\yax@passvalue_nobrace
+\def\yax@passvalue_nobrace#1#2{%
+  \passexpandedcs\swapargs{#2}{#1}%
+  }
+%
+%
+%
+%
+% \usevalue 
+%
+\yax@def_noarg\usevalue\usecs
+%
+%
+%
+%
+% \settovalue (not expandable, obviously,
+% although it leaves nothing in the input but
+% the assignment.
+%
+\yax@def_onearg\settovalue\yax@settovalue
+\def\yax@settovalue#1#2{%
+  #1 \usecs{#2}\relax
+  }
+%
+%
+%
+%
+% \storevalue  (like \settovalue, basically).
+%
+\yax@def_onearg\storevalue\yax@storevalue
+\def\yax@storevalue#1#2{%
+  \lettocs#1{#2}%
+  }%
+%
+%
+%
+%
+% \ifvalue 
+%
+\def\ifvalue{%
+  \yax@getall{\yax@ifvalue_removesign\yax@ifvalue_getvalue}%
+  }%
+
+\def\yax@ifvalue_nometa{%
+  \yax@getall{\yax@ifvalue_removesign\yax@ifvaluenometa_getvalue}%
+  }%
+\def\yax@ifvalue_removesign#1#2#3#4={#1{#2}{#3}}%
+\long\def\yax@ifvalue_getvalue#1#2#3 {%
+  \ifemptystring{#3}
+                {\yax@ifvalue_getvalue{#1}{#2}}
+                {\yax@ifattribute_if{}{\passexpandedcs{\ifstring{#3}}}{#1}{#2}}%
+  }
+\def\yax@ifvaluenometa_getvalue#1#2#3 {%
+  \ifemptystring{#3}
+                {\yax@ifvaluenometa_getvalue{#1}{#2}}
+                {\ifcs{yax@#1:#2}{\passexpandedcs{\ifstring{#3}}{yax@#1:#2}}\secondoftwo}%
+  }
+%
+%
+%
+%
+% \ifcasevalue
+%
+\let\yax@ifcasevalue_passvalueor\passvalueor % just in case \passvalue is redefined by a \newsyntax.
+\let\yax@yax@ifcasevalue_passvalueor_nometa\yax@passvalueor_nometa
+\letcstocs{yax@yax@ifcasevalue_passvalueor_nometa}{yax@passvalueor_nometa}
+
+\def\ifcasevalue{%
+  \yax@getall\yax@ifcasevalue_getvalue
+  }
+\def\yax@ifcasevalue_nometa{%
+  \yax@getall{\expandafter\nometa\yax@ifcasevalue_getvalue}%
+  }
+\def\yax@ifcasevalue_getvalue#1#2{%
+  \yax@ifcasevalue_passvalueor\yax@ifcasevalue_scan#1:#2 \yax@ifcasevalue_novalue
+  }
+\newstring\val \newstring\elseval
+\long\def\yax@ifcasevalue_novalue#1\endval{%
+  \iffcontains{\elseval}{#1}{\splitstring{\elseval}{#1}\yax@ifcasevalue_doelse}%
+  }
+\def\yax@ifcasevalue_doelse#1#2{\trim{#2}}
+\def\yax@ifcasevalue_scan#1#2\endval{%
+  \ifcontains{\elseval}{#2}
+             {\splitstring{\elseval}{#2}\yax@ifcasevalue_dotest{#1}}
+             {\yax@ifcasevalue_dotest{#2}{}{#1}}%
+  }
+\def\yax@ifcasevalue_dotest#1#2#3{%
+  \yax@ifcasevalue_loop{#3}{#2}{{yax@dummy_value} #1\val}%
+  }
+\newfor\yax@ifcasevalue_loop{2}#3 #4\val{%
+  \iffstring{#1}{#3}{\passtrim{#4}\breakfor}%
+  }[\passtrim{#2}\unbrace]
+%
+%
+%
+%
+% \newsyntax
+%
+\long\def\yax@newsyntax_noarg#1#2#3{%
+  \defcs{#1}#2{\yax@ifattribute_noarg{}{#3}{##1}{##2}}%
+  \defcs{#1or}#2{\yax@ifattribute_or{}{#3}{##1}{##2}}%
+  \defcs{#1and}#2{\yax@ifattribute_and{}{#3}{##1}{##2}}%
+%
+  \defcs{yax@#1_nometa}#2{\yax@ifattributenometa_noarg{#3}{##1}{##2}}%
+  \defcs{yax@#1or_nometa}#2{\yax@ifattributenometa_or{#3}{##1}{##2}}%
+  \defcs{yax@#1and_nometa}#2{\yax@ifattributenometa_and{#3}{##1}{##2}}%
+  }
+\long\def\yax@newsyntax_onearg#1#2#3{%
+  \defcs{#1}##1#2{\yax@ifattribute_noarg{}{#3{##1}}{##2}{##3}}%
+  \defcs{#1or}##1#2{\yax@ifattribute_or{}{#3{##1}}{##2}{##3}}%
+  \defcs{#1and}##1#2{\yax@ifattribute_and{}{#3{##1}}{##2}{##3}}%
+%
+  \defcs{yax@#1_nometa}##1#2{\yax@ifattributenometa_noarg{#3{##1}}{##2}{##3}}%
+  \defcs{yax@#1or_nometa}##1#2{\yax@ifattributenometa_or{#3{##1}}{##2}{##3}}%
+  \defcs{yax@#1and_nometa}##1#2{\yax@ifattributenometa_and{#3{##1}}{##2}{##3}}%
+  }
+\long\def\newsyntax#1#{%
+  \yax@newsyntax{#1}%
+  }
+\long\def\yax@newsyntax#1#2{%
+  \defcs{#2restrictattribute}#1{\yax@restrictattribute_getrestrictions{##1}{##2}}%
+  \defcs{#2deleteattribute}#1{\letcs{yax@##1:##2}\yax@undefined}%
+  \defcs{#2ifattribute}#1{\yax@ifattribute_and{}\gobbleone{##1}{##2}}%
+  \defcs{yax@#2ifattribute_nometa}#1{\yax@ifattributenometa_and\gobbleone{##1}{##2}}%
+  \yax@newsyntax_noarg{#2usevalue}{#1}\usecs
+  \def\yax@temp##1##2{#1}%
+  \passexpanded{\yax@newsyntax_onearg{#2passvalue}}{\yax@temp{##2}{##3}}\yax@passvalue
+  \passexpanded{\yax@newsyntax_onearg{#2passvaluenobraces}}{\yax@temp{##2}{##3}}\yax@passvalue_nobrace
+  \passexpanded{\yax@newsyntax_onearg{#2settovalue}}{\yax@temp{##2}{##3}}\yax@settovalue
+  \passexpanded{\yax@newsyntax_onearg{#2storevalue}}{\yax@temp{##2}{##3}}\yax@storevalue
+  \defcs{#2ifvalue}#1{\yax@ifvalue_removesign\yax@ifvalue_getvalue{##1}{##2}}%
+  \defcs{yax@#2ifvalue_nometa}#1{\yax@ifvalue_removesign\yax@ifvaluenometa_getvalue{##1}{##2}}%
+  \defcs{#2ifcasevalue}#1{\yax@ifcasevalue_getvalue{##1}{##2}}%
+  \defcs{yax@#2ifcasevalue_nometa}#1{\expandafter\nometa\yax@ifcasevalue_getvalue{##1}{##2}}%
+  }
+
+\def\yax@let#1#2#3{%
+  \letcstocs{#2#1}{#3#1}%
+  \letcstocs{yax@#2#1_nometa}{yax@#3#1_nometa}%
+  }
+\def\yax@let_all#1#2#3{%
+  \yax@let{#1}{#2}{#3}\yax@let{#1or}{#2}{#3}\yax@let{#1and}{#2}{#3}%
+  }
+\def\copysyntax#1#2{%
+  \letcstocs{#1restrictattribute}{#2restrictattribute}%
+  \letcstocs{#1deleteattribute}{#2deleteattribute}%
+  \yax@let{ifattribute}{#1}{#2}%
+  \yax@let_all{usevalue}{#1}{#2}\yax@let_all{passvalue}{#1}{#2}\yax@let_all{passvaluenobraces}{#1}{#2}%
+  \yax@let_all{settovalue}{#1}{#2}\yax@let_all{storevalue}{#1}{#2}%
+  \yax@let{ifvalue}{#1}{#2}%
+  \yax@let{ifcasevalue}{#1}{#2}%
+  }
+
+\def\letyaxcommand#1#2{%
+  \let#1#2% Base \let.
+  \ifcs{yax@\commandtoname#2and_nometa} % #2 is a YaX command with -and -or variants.
+       {\letcstocs{\commandtoname#1or}{\commandtoname#2or}%
+        \letcstocs{\commandtoname#1and}{\commandtoname#2and}%
+        \letcstocs{yax@\commandtoname#1_nometa}{yax@\commandtoname#2_nometa}%
+        \letcstocs{yax@\commandtoname#1or_nometa}{yax@\commandtoname#2or_nometa}%
+        \letcstocs{yax@\commandtoname#1and_nometa}{yax@\commandtoname#2and_nometa}}%
+       {\iffcs{yax@\commandtoname#2_nometa}% #2 is a YaX command without variants but with \nometa (i.e. the \if...).
+              {\letcstocs{yax@\commandtoname#1_nometa}{yax@\commandtoname#2_nometa}}}%
+  }
+
+\restorecatcodes
+\endinput
\ No newline at end of file
diff --git a/Master/tlpkg/libexec/ctan2tds b/Master/tlpkg/libexec/ctan2tds
index 12900331313..dbc1a32f352 100755
--- a/Master/tlpkg/libexec/ctan2tds
+++ b/Master/tlpkg/libexec/ctan2tds
@@ -1016,6 +1016,7 @@ $standardtex='\.(.bx|cfg|sty|clo|ldf|cls|def|fd|cmap|4ht)$';
  'xwatermark',	'\.sty',		# no .cfg
  'xlop',	'xlop\.(tex|sty)',	# no manual.sty
  'xstring',	'xstring\.tex|' . $standardtex,
+ 'yax',		'(t-)?yax\.(sty|tex)|' . $standardtex,
  'zefonts',	'\.sty|\.fd',
 );
 
diff --git a/Master/tlpkg/tlpsrc/collection-genericextra.tlpsrc b/Master/tlpkg/tlpsrc/collection-genericextra.tlpsrc
index a9e350d80b0..9caaf9ed728 100644
--- a/Master/tlpkg/tlpsrc/collection-genericextra.tlpsrc
+++ b/Master/tlpkg/tlpsrc/collection-genericextra.tlpsrc
@@ -30,4 +30,5 @@ depend texapi
 depend vrb
 depend vtex
 depend xlop
+depend yax
 depend collection-basic
diff --git a/Master/tlpkg/tlpsrc/yax.tlpsrc b/Master/tlpkg/tlpsrc/yax.tlpsrc
new file mode 100644
index 00000000000..e69de29bb2d
--- /dev/null
+++ b/Master/tlpkg/tlpsrc/yax.tlpsrc