Überarbeitungsverlauf[Zurück]
|
10 |
|
|
Jedem ASCII-Zeichen (mit XeLaTeX und LuaLaTeX vermutlich jedem Unicode-Zeichen<sup>1</sup>) ist unter anderem ein Kategorie-Code oder _catcode_ zugeordnet. Es gibt 16 Kategoriecodes. Die folgende Tabelle listet sie auf zusammen mit LaTeX's Vorbelegung.
<table>
<tr><th>Nummer</th><th>Funktion</th><th>Zeichen</th></tr>
<tr><td>0</td><td>Escape-Zeichen, leitet eine Befehlssequenz ein</td><td> \ </td></tr>
<tr><td>1</td><td>Beginn einer Gruppe/eines Arguments</td><td> { </td></tr>
<tr><td>2</td><td>Ende einer Gruppe/eines Arguments</td><td> } </td></tr>
<tr><td>3</td><td>Wechsel in Mathemodus und zurück</td><td> $ </td></tr>
<tr><td>4</td><td>Ausrichtung</td><td> & </td></tr>
<tr><td>5</td><td>Ende einer Zeile</td><td> Return </td></tr>
<tr><td>6</td><td>Parameter</td><td> # </td></tr>
<tr><td>7</td><td>Tiefstellung</td><td> _ </td></tr>
<tr><td>8</td><td>Hochstellung</td><td> ^ </td></tr>
<tr><td>9</td><td>ignoriertes Zeichen</td><td></td></tr>
<tr><td>10</td><td>Leerzeichen</td><td>Leerzeichen</td></tr>
<tr><td>11</td><td>Buchstabe</td><td>a-z A-Z</td></tr>
<tr><td>12</td><td>anderes Zeichen</td><td>alle anderen</td></tr>
<tr><td>13</td><td>aktives Zeichen</td><td> ~ </td></tr>
<tr><td>14</td><td>Kommentar</td><td> % </td></tr>
<tr><td>15</td><td>ungültiges Zeichen</td><td></td></tr>
</table>
Die Kategoriecodes bestimmen, welches Zeichen eine Befehlssequenz einleitet, welche ein Argument beginnen und beenden, welche im Mathemodus Hoch- und Tiefstellung bedeuten usw.
Für den Anwender ist es in der Regel zweitrangig, darüber Bescheid zu wissen. Die wesentlichen Funktionen von ``\``, `{`, `}`, `$` usw kennt man ohnehin, ohne über Kategoriecodes etwas zu wissen. Wichtig ist vor allem die Unterscheidung zwischen _Buchstabe_ und _anderes Zeichen_, da Befehlsnamen (die einem ``\`` oder genauer: einem Zeichen mit Kategoriecode 0 folgen) entweder aus einer beliebigen Anzahl von Buchstaben (Kategoriecode 11) bestehen können oder aus _einem_ Nicht-Buchstaben (Kategoriecode ungleich 11). Nach ersteren werden Leerzeichen ignoriert, nach letzteren _nicht_!
\documentclass{article}
\newcommand*\amp{\&}
\begin{document}
+\amp +\par
+\& +
\end{document}
![alt text][1]
Der Unterschied zwischen Buchstaben und Nicht-Buchstaben wird auch bei der Funktion des `@` in internen Makronamen ausgenützt. Siehe dazu [was machen eigentlich `\\makeatletter` und `\\makeatother`?](http://texwelt.de/wissen/fragen/1/). Ähnliches gilt für expl3 (die LaTeX3-Programmierkonvention), wo `_` und `:` Buchstaben sind, Leerzeichen und Zeilenenden ignoriert werden und `~` ein normales Leerzeichen ausgibt.
Auch von Interesse ist vielleicht der Kategoriecode _aktiv_. Ein Zeichen, dessen Kategoriecode 13 ist, verhält sich wie eine Befehlssequenz. Man kennt hier üblicherweise `~`. Der LaTeX-Kernel enthält
\catcode`\~=13
\def~{\nobreakspace{}}
Grundsätzlich kann der Kategoriecode jedes Zeichens zu jeder Zeit geändert werden. Das verwenden z.B. die Befehle und Umgebungen für Verbatim-Text, die es ja ermöglichen, auch die Zeichen, die nicht Buchstabe oder anderes Zeichen sind, direkt auszugeben. Die Vorbelegung wird soweit ich weiß<sup>1</sup> teilweise vom Format und teilweise vom Kernel vorgenommen.
Der vorige Absatz stimmt nicht ganz: sobald ein Zeichen als Argument eines Befehls gelesen wurde, ist sein Kategoriecode fixiert. Daher müssen Befehle wie `\verb` auch erst die betreffenden Kategoriecodes ändern (man findet hier im LaTeX-Kernel die Anweisung `\let\do\@makeother \dospecials`) und dann einen weiteren Befehl aufrufen, der jetzt die Zeichen mit neuem Kategoriecode tatsächlich als Argument bekommt (im Fall von `\verb` selbst passiert das tatsächlich _nicht_, die Zeichen werden _gar nicht_ als Argument gelesen, es gibt aber andere Beispiele).
Die gerade erwähnte Fixierung in Argumenten von Befehlen ist übrigens der Grund, warum man Befehle wie `\verb` nicht in Argumenten von Befehlen einsetzen kann. Es gibt keine Möglichkeit, die Fixierung der Kategoriecodes zu verhindern. Mit e-TeXs `\scantokens` gibt es allerdings die Möglichkeit, die Zeichen erneut „einzulesen“. Mit TeXs `\string` oder [e-TeXs `\detokenize`][2] kann man Zeichen nachträglich noch Kategoriecode 12 zuweisen.
Der folgende Code zeigt jetzt noch ein Beispiel aus dem Kernel (Teil der Definition der `verbatim`-Umgebung), bei dem in einer Gruppe ``\``, `{` und `}` zu anderen Zeichen werden und `|`, `[` und `]` temporär ihre Rolle übernehmen.
\begingroup \catcode `|=0 \catcode `[= 1
\catcode`]=2 \catcode `\{=12 \catcode `\}=12
\catcode`\\=12 |gdef|@xverbatim#1\end{verbatim}[#1|end[verbatim]]
|gdef|@sxverbatim#1\end{verbatim*}[#1|end[verbatim*]]
|endgroup
----------
Meine Erfahrung und mein Wissen über `\lccode` und `\uccode` hält sich sehr in Grenzen: ich musste mich bislang noch nicht näher damit befassen. Sie bestimmen, was in den Argumenten von `\lowercase` und `\uppercase` passiert. Die Zeichen a--z haben _lccode_ = _Zeichencode_, die Zeichen A--Z _uccode_ = _Zeichencode_, Großbuchstaben haben den lccode der Kleinbuchstaben und die den uccode der Großbuchstaben. Andere Zeichen haben jeweils den Wert Null. Zum Beispiel hat »a« den Zeichencode 97, den lccode 97 und den uccode 65, »A« hingegen hat Zeichencode 65, lccode 97 und uccode 65. `\uppercase` und `\lowercase` gehen nun durch die Zeichen in ihrem Argument und ersetzen sie (wenn der lcode bzw uccode nicht Null ist) durch das Zeichen des entsprechenden lccodes bzw uccodes. Dabei ändert sich der Kategoriecode des Zeichens nicht.
\documentclass{article}
\usepackage{array}
\newcommand*\zeichen[1]{%
-- #1 --\par
Zeichencode: \number`#1 \par
uccode: \the\uccode`#1 \par
lccode: \the\lccode`#1 \par
Kategoriecode: \the\catcode`#1 \par
}
\begin{document}
\catcode`\A=12
\begin{tabular}{*2{p{.33\linewidth}}}
\zeichen{a} &
\zeichen{A} \\
\lowercase{\zeichen{A}} & % wie \zeichen{a}, auch der Kategoriecode stimmt
\uppercase{\zeichen{a}} % wie \zeichen{A}, auch der Kategoriecode stimmt
\end{tabular}
\end{document}
![alt text][3]
Als Anwendung ist mir vor allem der „`\lowercase`-Trick“ bekannt, den man anwenden kann, um einem Zeichen eine Definition zu geben, wenn es aktiv ist:
\documentclass{article}
\usepackage{xcolor}
\begingroup\lccode`~=`.
\lowercase{\endgroup\def~}#1{\color{red}{#1}}
\newenvironment{strange}{\catcode`\.=13 }{}
\begin{document}
.foo
\begin{strange}
.foo
\end{strange}
\end{document}
![alt text][4]
Man nützt hier aus, dass `~` bereits aktiv ist. Dann setzt man temporär den `\lccode` von `~` gleich dem des Zeichens, dem man eine Definition geben möchte. Innerhalb von `\lowercase` wird dann `~` wie eine aktive Version des gewünschten Zeichens behandelt, so dass man ihm eine Definition zuweisen kann. Da das alles in einer Gruppe geschieht, ist das Zeichen hinterher nicht aktiv und `~` hat seinen ursprünglichen `\lccode` wieder. Macht man nun später das betreffende Zeichen aktiv (gibt ihm also Kategoriecode 13), dann hat es die hier gegebene Definition.
`\lowercase` „behandelt“ die Zeichen in seinem Argument, _bevor_ die Anweisungen in seinem Argument ausgeführt werden. Man vermeidet damit, dass man die Definition global machen muss, da man die Gruppe schließen kann, bevor man die Definition vornimmt.
----------
1. Vielleicht kann das jemand bestätigen/verneinen?
[1]: http://texwelt.de/wissen/upfiles/befehlssequenz.png
[2]: http://texwelt.de/wissen/fragen/1893#1894
[3]: http://texwelt.de/wissen/upfiles/lcuccode.pnghttp://texwelt.de/wissen/upfiles/lcuccode.png
[4]: http://texwelt.de/wissen/upfiles/lccode.png
|
|
9 |
|
|
Jedem ASCII-Zeichen (mit XeLaTeX und LuaLaTeX vermutlich jedem Unicode-Zeichen<sup>1</sup>) ist unter anderem ein Kategorie-Code oder _catcode_ zugeordnet. Es gibt 16 Kategoriecodes. Die folgende Tabelle listet sie auf zusammen mit LaTeX's Vorbelegung.
<table>
<tr><th>Nummer</th><th>Funktion</th><th>Zeichen</th></tr>
<tr><td>0</td><td>Escape-Zeichen, leitet eine Befehlssequenz ein</td><td> \ </td></tr>
<tr><td>1</td><td>Beginn einer Gruppe/eines Arguments</td><td> { </td></tr>
<tr><td>2</td><td>Ende einer Gruppe/eines Arguments</td><td> } </td></tr>
<tr><td>3</td><td>Wechsel in Mathemodus und zurück</td><td> $ </td></tr>
<tr><td>4</td><td>Ausrichtung</td><td> & </td></tr>
<tr><td>5</td><td>Ende einer Zeile</td><td> Return </td></tr>
<tr><td>6</td><td>Parameter</td><td> # </td></tr>
<tr><td>7</td><td>Tiefstellung</td><td> _ </td></tr>
<tr><td>8</td><td>Hochstellung</td><td> ^ </td></tr>
<tr><td>9</td><td>ignoriertes Zeichen</td><td></td></tr>
<tr><td>10</td><td>Leerzeichen</td><td>Leerzeichen</td></tr>
<tr><td>11</td><td>Buchstabe</td><td>a-z A-Z</td></tr>
<tr><td>12</td><td>anderes Zeichen</td><td>alle anderen</td></tr>
<tr><td>13</td><td>aktives Zeichen</td><td> ~ </td></tr>
<tr><td>14</td><td>Kommentar</td><td> % </td></tr>
<tr><td>15</td><td>ungültiges Zeichen</td><td></td></tr>
</table>
Die Kategoriecodes bestimmen, welches Zeichen eine Befehlssequenz einleitet, welche ein Argument beginnen und beenden, welche im Mathemodus Hoch- und Tiefstellung bedeuten usw.
Für den Anwender ist es in der Regel zweitrangig, darüber Bescheid zu wissen. Die wesentlichen Funktionen von ``\``, `{`, `}`, `$` usw kennt man ohnehin, ohne über Kategoriecodes etwas zu wissen. Wichtig ist vor allem die Unterscheidung zwischen _Buchstabe_ und _anderes Zeichen_, da Befehlsnamen (die einem ``\`` oder genauer: einem Zeichen mit Kategoriecode 0 folgen) entweder aus einer beliebigen Anzahl von Buchstaben (Kategoriecode 11) bestehen können oder aus _einem_ anderen Nicht-Buchstaben (Kategoriecode 12) Zeichen. ungleich 11). Nach ersteren werden Leerzeichen ignoriert, nach letzteren _nicht_!
\documentclass{article}
\newcommand*\amp{\&}
\begin{document}
+\amp +\par
+\& +
\end{document}
![alt text][1]
Der Unterschied zwischen Buchstaben und anderen Zeichen Nicht-Buchstaben wird auch bei der Funktion des `@` in internen Makronamen ausgenützt. Siehe dazu [was machen eigentlich `\\makeatletter` und `\\makeatother`?](http://texwelt.de/wissen/fragen/1/). Ähnliches gilt für expl3 (die LaTeX3-Programmierkonvention), wo `_` und `:` Buchstaben sind, Leerzeichen und Zeilenenden ignoriert werden und `~` ein normales Leerzeichen ausgibt.
Auch von Interesse ist vielleicht der Kategoriecode _aktiv_. Ein Zeichen, dessen Kategoriecode 13 ist, verhält sich wie eine Befehlssequenz. Man kennt hier üblicherweise `~`. Der LaTeX-Kernel enthält
\catcode`\~=13
\def~{\nobreakspace{}}
Grundsätzlich kann der Kategoriecode jedes Zeichens zu jeder Zeit geändert werden. Das verwenden z.B. die Befehle und Umgebungen für Verbatim-Text, die es ja ermöglichen, auch die Zeichen, die nicht Buchstabe oder anderes Zeichen sind, direkt auszugeben. Die Vorbelegung wird soweit ich weiß<sup>1</sup> teilweise vom Format und teilweise vom Kernel vorgenommen.
Der vorige Absatz stimmt nicht ganz: sobald ein Zeichen als Argument eines Befehls gelesen wurde, ist sein Kategoriecode fixiert. Daher müssen Befehle wie `\verb` auch erst die betreffenden Kategoriecodes ändern (man findet hier im LaTeX-Kernel die Anweisung `\let\do\@makeother \dospecials`) und dann einen weiteren Befehl aufrufen, der jetzt die Zeichen mit neuem Kategoriecode tatsächlich als Argument bekommt (im Fall von `\verb` selbst passiert das tatsächlich _nicht_, die Zeichen werden _gar nicht_ als Argument gelesen, es gibt aber andere Beispiele).
Die gerade erwähnte Fixierung in Argumenten von Befehlen ist übrigens der Grund, warum man Befehle wie `\verb` nicht in Argumenten von Befehlen einsetzen kann. Es gibt keine Möglichkeit, die Fixierung der Kategoriecodes zu verhindern. Mit e-TeXs `\scantokens` gibt es allerdings die Möglichkeit, die Zeichen erneut „einzulesen“. Mit TeXs `\string` oder [e-TeXs `\detokenize`][2] kann man Zeichen nachträglich noch Kategoriecode 12 zuweisen.
Der folgende Code zeigt jetzt noch ein Beispiel aus dem Kernel (Teil der Definition der `verbatim`-Umgebung), bei dem in einer Gruppe ``\``, `{` und `}` zu anderen Zeichen werden und `|`, `[` und `]` temporär ihre Rolle übernehmen.
\begingroup \catcode `|=0 \catcode `[= 1
\catcode`]=2 \catcode `\{=12 \catcode `\}=12
\catcode`\\=12 |gdef|@xverbatim#1\end{verbatim}[#1|end[verbatim]]
|gdef|@sxverbatim#1\end{verbatim*}[#1|end[verbatim*]]
|endgroup
----------
Meine Erfahrung und mein Wissen über `\lccode` und `\uccode` hält sich sehr in Grenzen: ich musste mich bislang noch nicht näher damit befassen. Sie bestimmen, was in den Argumenten von `\lowercase` und `\uppercase` passiert. Die Zeichen a--z haben _lccode_ = _Zeichencode_, die Zeichen A--Z _uccode_ = _Zeichencode_, Großbuchstaben haben den lccode der Kleinbuchstaben und die den uccode der Großbuchstaben. Andere Zeichen haben jeweils den Wert Null. Zum Beispiel hat »a« den Zeichencode 97, den lccode 97 und den uccode 65, »A« hingegen hat Zeichencode 65, lccode 97 und uccode 65. `\uppercase` und `\lowercase` gehen nun durch die Zeichen in ihrem Argument und ersetzen sie (wenn der lcode bzw uccode nicht Null ist) durch das Zeichen des entsprechenden lccodes bzw uccodes. Dabei ändert sich der Kategoriecode des Zeichens nicht.
\documentclass{article}
\usepackage{array}
\newcommand*\zeichen[1]{%
-- #1 --\par
Zeichencode: \number`#1 \par
uccode: \the\uccode`#1 \par
lccode: \the\lccode`#1 \par
Kategoriecode: \the\catcode`#1 \par
}
\begin{document}
\catcode`\A=12
\begin{tabular}{*2{p{.33\linewidth}}}
\zeichen{a} &
\zeichen{A} \\
\lowercase{\zeichen{A}} & % wie \zeichen{a}, auch der Kategoriecode stimmt
\uppercase{\zeichen{a}} % wie \zeichen{A}, auch der Kategoriecode stimmt
\end{tabular}
\end{document}
![alt text][3]
Als Anwendung ist mir vor allem der „`\lowercase`-Trick“ bekannt, den man anwenden kann, um einem Zeichen eine Definition zu geben, wenn es aktiv ist:
\documentclass{article}
\usepackage{xcolor}
\begingroup\lccode`~=`.
\lowercase{\endgroup\def~}#1{\color{red}{#1}}
\newenvironment{strange}{\catcode`\.=13 }{}
\begin{document}
.foo
\begin{strange}
.foo
\end{strange}
\end{document}
Man nützt hier aus, dass `~` bereits aktiv ist. Dann setzt man temporär den `\lccode` von `~` gleich dem des Zeichens, dem man eine Definition geben möchte. Innerhalb von `\lowercase` wird dann `~` wie eine aktive Version des gewünschten Zeichens behandelt, so dass man ihm eine Definition zuweisen kann. Da das alles in einer Gruppe geschieht, ist das Zeichen hinterher nicht aktiv und `~` hat seinen ursprünglichen `\lccode` wieder. Macht man nun später das betreffende Zeichen aktiv (gibt ihm also Kategoriecode 13), dann hat es die hier gegebene Definition.
`\lowercase` „behandelt“ die Zeichen in seinem Argument, _bevor_ die Anweisungen in seinem Argument ausgeführt werden. Man vermeidet damit, dass man die Definition global machen muss, da man die Gruppe schließen kann, bevor man die Definition vornimmt.
----------
1. Vielleicht kann das jemand bestätigen/verneinen?
[1]: http://texwelt.de/wissen/upfiles/befehlssequenz.png
[2]: http://texwelt.de/wissen/fragen/1893#1894
[3]: http://texwelt.de/wissen/upfiles/lcuccode.png
|
|
8 |
|
|
Jedem ASCII-Zeichen (mit XeLaTeX und LuaLaTeX vermutlich jedem Unicode-Zeichen<sup>1</sup>) ist unter anderem ein Kategorie-Code oder _catcode_ zugeordnet. Es gibt 16 Kategoriecodes. Die folgende Tabelle listet sie auf zusammen mit LaTeX's Vorbelegung.
<table>
<tr><th>Nummer</th><th>Funktion</th><th>Zeichen</th></tr>
<tr><td>0</td><td>Escape-Zeichen, leitet eine Befehlssequenz ein</td><td> \ </td></tr>
<tr><td>1</td><td>Beginn einer Gruppe/eines Arguments</td><td> { </td></tr>
<tr><td>2</td><td>Ende einer Gruppe/eines Arguments</td><td> } </td></tr>
<tr><td>3</td><td>Wechsel in Mathemodus und zurück</td><td> $ </td></tr>
<tr><td>4</td><td>Ausrichtung</td><td> & </td></tr>
<tr><td>5</td><td>Ende einer Zeile</td><td> Return </td></tr>
<tr><td>6</td><td>Parameter</td><td> # </td></tr>
<tr><td>7</td><td>Tiefstellung</td><td> _ </td></tr>
<tr><td>8</td><td>Hochstellung</td><td> ^ </td></tr>
<tr><td>9</td><td>ignoriertes Zeichen</td><td></td></tr>
<tr><td>10</td><td>Leerzeichen</td><td>Leerzeichen</td></tr>
<tr><td>11</td><td>Buchstabe</td><td>a-z A-Z</td></tr>
<tr><td>12</td><td>anderes Zeichen</td><td>alle anderen</td></tr>
<tr><td>13</td><td>aktives Zeichen</td><td> ~ </td></tr>
<tr><td>14</td><td>Kommentar</td><td> % </td></tr>
<tr><td>15</td><td>ungültiges Zeichen</td><td></td></tr>
</table>
Die Kategoriecodes bestimmen, welches Zeichen eine Befehlssequenz einleitet, welche ein Argument beginnen und beenden, welche im Mathemodus Hoch- und Tiefstellung bedeuten usw.
Für den Anwender ist es in der Regel zweitrangig, darüber Bescheid zu wissen. Die wesentlichen Funktionen von ``\``, `{`, `}`, `$` usw kennt man ohnehin, ohne über Kategoriecodes etwas zu wissen. Wichtig ist vor allem die Unterscheidung zwischen _Buchstabe_ und _anderes Zeichen_, da Befehlsnamen (die einem ``\`` oder genauer: einem Zeichen mit Kategoriecode 0 folgen) entweder aus einer beliebigen Anzahl von Buchstaben (Kategoriecode 11) bestehen können oder aus _einem_ anderen (Kategoriecode 12) Zeichen. Nach ersteren werden Leerzeichen ignoriert, nach letzteren _nicht_!
\documentclass{article}
\newcommand*\amp{\&}
\begin{document}
+\amp +\par
+\& +
\end{document}
![alt text][1]
Der Unterschied zwischen Buchstaben und anderen Zeichen wird auch bei der Funktion des `@` in internen Makronamen ausgenützt. Siehe dazu [was machen eigentlich `\\makeatletter` und `\\makeatother`?](http://texwelt.de/wissen/fragen/1/). Ähnliches gilt für expl3 (die LaTeX3-Programmierkonvention), wo `_` und `:` Buchstaben sind, Leerzeichen und Zeilenenden ignoriert werden und `~` ein normales Leerzeichen ausgibt.
Auch von Interesse ist vielleicht der Kategoriecode _aktiv_. Ein Zeichen, dessen Kategoriecode 13 ist, verhält sich wie eine Befehlssequenz. Man kennt hier üblicherweise `~`. Der LaTeX-Kernel enthält
\catcode`\~=13
\def~{\nobreakspace{}}
Grundsätzlich kann der Kategoriecode jedes Zeichens zu jeder Zeit geändert werden. Das verwenden z.B. die Befehle und Umgebungen für Verbatim-Text, die es ja ermöglichen, auch die Zeichen, die nicht Buchstabe oder anderes Zeichen sind, direkt auszugeben. Die Vorbelegung wird soweit ich weiß<sup>1</sup> teilweise vom Format und teilweise vom Kernel vorgenommen.
Der vorige Absatz stimmt nicht ganz: sobald ein Zeichen als Argument eines Befehls gelesen wurde, ist sein Kategoriecode fixiert. Deaher Daher müssen Befehle wie `\verb` auch erst die betreffenden Kategoriecodes ändern (man findet hier im LaTeX-Kernel die Anweisung `\let\do\@makeother \dospecials`) und dann einen weiteren Befehl aufrufen, der jetzt die folgen Zeichen mit neuem Kategoriecode tatsächlich als Argument bekommt (im Fall von `\verb` selbst passiert das tatsächlich _nicht_, die Zeichen werden _gar nicht_ als Argument gelesen, es gibt aber andere Beispiele).
Die gerade erwähnte Fixierung in Argumenten von Befehlen ist übrigens der Grund, warum man Befehle wie `\verb` nicht in Argumenten von Befehlen einsetzen kann. Es gibt keine Möglichkeit, die Fixierung der Kategoriecodes zu verhindern. Mit e-TeXs `\scantokens` gibt es allerdings die Möglichkeit, die Zeichen erneut „einzulesen“. Mit TeXs `\string` oder [e-TeXs `\detokenize`][2] kann man Zeichen nachträglich noch Kategoriecode 12 zuweisen.
Der folgende Code zeigt jetzt noch ein Beispiel aus dem Kernel (Teil der Definition der `verbatim`-Umgebung), bei dem in einer Gruppe ``\``, `{` und `}` zu anderen Zeichen werden und `|`, `[` und `]` temporär ihre Rolle übernehmen.
\begingroup \catcode `|=0 \catcode `[= 1
\catcode`]=2 \catcode `\{=12 \catcode `\}=12
\catcode`\\=12 |gdef|@xverbatim#1\end{verbatim}[#1|end[verbatim]]
|gdef|@sxverbatim#1\end{verbatim*}[#1|end[verbatim*]]
|endgroup
----------
Meine Erfahrung und mein Wissen über `\lccode` und `\uccode` hält sich sehr in Grenzen: ich musste mich bislang noch nicht näher damit befassen. Sie bestimmen, was in den Argumenten von `\lowercase` und `\uppercase` passiert. Die Zeichen a--z haben _lccode_ = _Zeichencode_, die Zeichen A--Z _uccode_ = _Zeichencode_, Grußbuchstaben Großbuchstaben haben den lccode der Kleinbuchstaben und die den uccode der Großbuchstaben. Andere Zeichen haben jeweils den Wert Null. Zum Beispiel hat »a« den Zeichencode 97, den lccode 97 und den uccode 65, »A« hingegen hat Zeichencode 65, lccode 97 und uccode 65. `\uppercase` und `\lowercase` gehen nun durch die Zeichen in ihrem Argument und ersetzen sie (wenn der lcode bzw uccode nicht Null ist) durch das Zeichen des entsprechenden lccodes bzw uccodes. Dabei ändert sich der Kategoriecode des Zeichens nicht.
\documentclass{article}
\usepackage{array}
\newcommand*\zeichen[1]{%
-- #1 --\par
Zeichencode: \number`#1 \par
uccode: \the\uccode`#1 \par
lccode: \the\lccode`#1 \par
Kategoriecode: \the\catcode`#1 \par
}
\begin{document}
\catcode`\A=12
\begin{tabular}{*2{p{.33\linewidth}}}
\zeichen{a} &
\zeichen{A} \\
\lowercase{\zeichen{A}} & % wie \zeichen{a}, auch der Kategoriecode stimmt
\uppercase{\zeichen{a}} % wie \zeichen{A}, auch der Kategoriecode stimmt
\end{tabular}
\end{document}
![alt text][3]
Als Anwendung ist mir vor allem der „`\lowercase`-Trick“ bekannt, den man anwenden kann, um einem Zeichen eine Definition zu geben, wenn es aktiv ist:
\documentclass{article}
\usepackage{xcolor}
\begingroup\lccode`~=`.
\lowercase{\endgroup\def~}#1{\color{red}{#1}}
\newenvironment{strange}{\catcode`\.=13 }{}
\begin{document}
.foo
\begin{strange}
.foo
\end{strange}
\end{document}
Man nützt hier aus, dass `~` bereits aktiv ist. Dann setzt man temporär den `\lccode` von `~` gleich dem des Zeichens, dem man eine Definition geben möchte. Innerhalb von `\lowercase` wird dann `~` wie eine aktive Version des gewünschten Zeichens behandelt, so dass man ihm eine Definition zuweisen kann. Da das alles in einer Gruppe geschieht, ist das Zeichen hinterher nicht aktiv und `~` hat seinen ursprünglichen `\lccode` wieder. Macht man nun später das betreffende Zeichen aktiv (gibt ihm also Kategoriecode 13), dann hat es die hier gegebene Definition.
`\lowercase` „behandelt“ die Zeichen in seinem Argument, _bevor_ die Anweisungen in seinem Argument ausgeführt werden. Man vermeidet damit, dass man die Definition global machen muss, da man die Gruppe schließen kann, bevor man die Definition vornimmt.
----------
1. Vielleicht kann das jemand bestätigen/verneinen?
[1]: http://texwelt.de/wissen/upfiles/befehlssequenz.png
[2]: http://texwelt.de/wissen/fragen/1893#1894
[3]: http://texwelt.de/wissen/upfiles/lcuccode.png
|
|
7 |
|
|
Jedem ASCII-Zeichen (mit XeLaTeX und LuaLaTeX vermutlich jedem Unicode-Zeichen<sup>1</sup>) ist unter anderem ein Kategorie-Code oder _catcode_ zugeordnet. Es gibt 16 Kategoriecodes. Die folgende Tabelle listet sie auf zusammen mit LaTeX's Vorbelegung.
<table>
<tr><th>Nummer</th><th>Funktion</th><th>Zeichen</th></tr>
<tr><td>0</td><td>Escape-Zeichen, leitet eine Befehlssequenz ein</td><td> \ </td></tr>
<tr><td>1</td><td>Beginn einer Gruppe/eines Arguments</td><td> { </td></tr>
<tr><td>2</td><td>Ende einer Gruppe/eines Arguments</td><td> } </td></tr>
<tr><td>3</td><td>Wechsel in Mathemodus und zurück</td><td> $ </td></tr>
<tr><td>4</td><td>Ausrichtung</td><td> & </td></tr>
<tr><td>5</td><td>Ende einer Zeile</td><td> Return </td></tr>
<tr><td>6</td><td>Parameter</td><td> # </td></tr>
<tr><td>7</td><td>Tiefstellung</td><td> _ </td></tr>
<tr><td>8</td><td>Hochstellung</td><td> ^ </td></tr>
<tr><td>9</td><td>ignoriertes Zeichen</td><td></td></tr>
<tr><td>10</td><td>Leerzeichen</td><td>Leerzeichen</td></tr>
<tr><td>11</td><td>Buchstabe</td><td>a-z A-Z</td></tr>
<tr><td>12</td><td>anderes Zeichen</td><td>alle anderen</td></tr>
<tr><td>13</td><td>aktives Zeichen</td><td> ~ </td></tr>
<tr><td>14</td><td>Kommentar</td><td> % </td></tr>
<tr><td>15</td><td>ungültiges Zeichen</td><td></td></tr>
</table>
Die Kategoriecodes bestimmen, welches Zeichen eine Befehlssequenz einleitet, welche ein Argument beginnen und beenden, welche im Mathemodus Hoch- und Tiefstellung bedeuten usw.
Für den Anwender ist es in der Regel zweitrangig, darüber Bescheid zu wissen. Die wesentlichen Funktionen von ``\``, `{`, `}`, `$` usw kennt man ohnehin, ohne über Kategoriecodes etwas zu wissen. Wichtig ist vor allem die Unterscheidung zwischen _Buchstabe_ und _anderes Zeichen_, da Befehlsnamen (die einem ``\`` oder genauer: einem Zeichen mit Kategoriecode 0 folgen) entweder aus einer beliebigen Anzahl von Buchstaben (Kategoriecode 11) bestehen können oder aus _einem_ anderen (Kategoriecode 12) Zeichen. Nach ersteren werden Leerzeichen ignoriert, nach letzteren _nicht_!
\documentclass{article}
\newcommand*\amp{\&}
\begin{document}
+\amp +\par
+\& +
\end{document}
![alt text][1]
Der Unterschied zwischen Buchstaben und anderen Zeichen wird auch bei der Funktion des `@` in internen Makronamen ausgenützt. Siehe dazu [was machen eigentlich `\\makeatletter` und `\\makeatother`?](http://texwelt.de/wissen/fragen/1/). Ähnliches gilt für expl3 (die LaTeX3-Programmierkonvention), wo `_` und `:` Buchstaben sind, Leerzeichen und Zeilenenden ignoriert werden und `~` ein normales Leerzeichen ausgibt.
Auch von Interesse ist vielleicht der Kategoriecode _aktiv_. Ein Zeichen, dessen Kategoriecode 13 ist, verhält sich wie eine Befehlssequenz. Man kennt hier üblicherweise `~`. Der LaTeX-Kernel enthält
\catcode`\~=13
\def~{\nobreakspace{}}
Grundsätzlich kann der Kategoriecode jedes Zeichens zu jeder Zeit geändert werden. Das verwenden z.B. die Befehle und Umgebungen für Verbatim-Text, die es ja ermöglichen, auch die Zeichen, die nicht Buchstabe oder anderes Zeichen sind, direkt auszugeben. Die Vorbelegung wird soweit ich weiß<sup>1</sup> teilweise vom Format und teilweise vom Kernel vorgenommen.
Der vorige Absatz stimmt nicht ganz: sobald ein Zeichen als Argument eines Befehls gelesen wurde, ist sein Kategoriecode fixiert. Deaher müssen Befehle wie `\verb` auch erst die betreffenden Kategoriecodes ändern (man findet hier im LaTeX-Kernel die Anweisung `\let\do\@makeother \dospecials`) und dann einen weiteren Befehl aufrufen, der jetzt die folgen Zeichen mit neuem Kategoriecode tatsächlich als Argument bekommt (im Fall von `\verb` selbst passiert das tatsächlich _nicht_, die Zeichen werden _gar nicht_ als Argument gelesen, es gibt aber andere Beispiele).
Die gerade erwähnte Fixierung in Argumenten von Befehlen ist übrigens der Grund, warum man Befehle wie `\verb` nicht in Argumenten von Befehlen einsetzen kann. Es gibt keine Möglichkeit, die Fixierung der Kategoriecodes zu verhindern. Mit e-TeXs `\scantokens` gibt es allerdings die Möglichkeit, die Zeichen erneut „einzulesen“. Mit TeXs `\string` oder [e-TeXs `\detokenize`][2] kann man Zeichen nachträglich noch Kategoriecode 12 zuweisen.
Der folgende Code zeigt jetzt noch ein Beispiel aus dem Kernel (Teil der Definition der `verbatim`-Umgebung), bei dem in einer Gruppe ``\``, `{` und `}` zu anderen Zeichen werden und `|`, `[` und `]` temporär ihre Rolle übernehmen.
\begingroup \catcode `|=0 \catcode `[= 1
\catcode`]=2 \catcode `\{=12 \catcode `\}=12
\catcode`\\=12 |gdef|@xverbatim#1\end{verbatim}[#1|end[verbatim]]
|gdef|@sxverbatim#1\end{verbatim*}[#1|end[verbatim*]]
|endgroup
----------
Meine Erfahrung und mein Wissen über `\lccode` und `\uccode` hält sich sehr in Grenzen: ich musste mich bislang noch nicht näher damit befassen. Sie bestimmen, was in den Argumenten von `\lowercase` und `\uppercase` passiert. Die Zeichen a--z haben _lccode_ = _Zeichencode_, die Zeichen A--Z _uccode_ = _Zeichencode_, Grußbuchstaben haben den lccode der Kleinbuchstaben und umgekehrt, andere die den uccode der Großbuchstaben. Andere Zeichen haben jeweils null. den Wert Null. Zum Beispiel hat »a« den Zeichencode 97, den lccode 97 und den uccode 65, »A« hingegen hat Zeichencode 65, lccode 97 und uccode 65. `\uppercase` und `\lowercase` gehen nun durch die Zeichen in ihrem Argument und ersetzen sie (wenn der lcode bzw uccode nicht Null ist) durch das Zeichen des entsprechenden lccodes bzw uccodes. Dabei ändert sich der Kategoriecode des Zeichens nicht.
\documentclass{article}
\usepackage{array}
\newcommand*\zeichen[1]{%
-- #1 --\par
Zeichencode: \number`#1 \par
uccode: \the\uccode`#1 \par
lccode: \the\lccode`#1 \par
Kategoriecode: \the\catcode`#1 \par
}
\begin{document}
\catcode`\A=12
\begin{tabular}{*2{p{.33\linewidth}}}
\zeichen{a} &
\zeichen{A} \\
\lowercase{\zeichen{A}} & % wie \zeichen{a}, auch der Kategoriecode stimmt
\uppercase{\zeichen{a}} % wie \zeichen{A}, auch der Kategoriecode stimmt
\end{tabular}
\end{document}
![alt text][3]
Als Anwendung ist mir vor allem der „`\lowercase`-Trick“ bekannt, den man anwenden kann, um einem Zeichen eine Definition zu geben, wenn es aktiv ist:
\documentclass{article}
\usepackage{xcolor}
\begingroup\lccode`~=`.
\lowercase{\endgroup\def~}#1{\color{red}{#1}}
\newenvironment{strange}{\catcode`\.=13 }{}
\begin{document}
.foo
\begin{strange}
.foo
\end{strange}
\end{document}
Man nützt hier aus, dass `~` bereits aktiv ist. Dann setzt man temporär den `\lccode` von `~` gleich dem des Zeichens, dem man eine Definition geben möchte. Innerhalb von `\lowercase` wird dann `~` wie eine aktive Version des gewünschten Zeichens behandelt, so dass man ihm eine Definition zuweisen kann. Da das alles in einer Gruppe geschieht, ist das Zeichen hinterher nicht aktiv und `~` hat seinen ursprünglichen `\lccode` wieder. Macht man nun später das betreffende Zeichen aktiv (gibt ihm also Kategoriecode 13), dann hat es die hier gegebene Definition.
`\lowercase` „behandelt“ die Zeichen in seinem Argument, _bevor_ die Anweisungen in seinem Argument ausgeführt werden. Man vermeidet damit, dass man die Definition global machen muss, da man die Gruppe schließen kann, bevor man die Definition vornimmt.
----------
1. Vielleicht kann das jemand bestätigen/verneinen?
[1]: http://texwelt.de/wissen/upfiles/befehlssequenz.png
[2]: http://texwelt.de/wissen/fragen/1893#1894
[3]: http://texwelt.de/wissen/upfiles/lcuccode.png
|
|
6 |
|
|
Jedem ASCII-Zeichen (mit XeLaTeX und LuaLaTeX vermutlich jedem Unicode-Zeichen<sup>1</sup>) ist unter anderem ein Kategorie-Code oder _catcode_ zugeordnet. Es gibt 16 Kategoriecodes. Die folgende Tabelle listet sie auf zusammen mit LaTeX's Vorbelegung.
<table>
<tr><th>Nummer</th><th>Funktion</th><th>Zeichen</th></tr>
<tr><td>0</td><td>Escape-Zeichen, leitet eine Befehlssequenz ein</td><td> \ </td></tr>
<tr><td>1</td><td>Beginn einer Gruppe/eines Arguments</td><td> { </td></tr>
<tr><td>2</td><td>Ende einer Gruppe/eines Arguments</td><td> } </td></tr>
<tr><td>3</td><td>Wechsel in Mathemodus und zurück</td><td> $ </td></tr>
<tr><td>4</td><td>Ausrichtung</td><td> & </td></tr>
<tr><td>5</td><td>Ende einer Zeile</td><td> Return </td></tr>
<tr><td>6</td><td>Parameter</td><td> # </td></tr>
<tr><td>7</td><td>Tiefstellung</td><td> _ </td></tr>
<tr><td>8</td><td>Hochstellung</td><td> ^ </td></tr>
<tr><td>9</td><td>ignoriertes Zeichen</td><td></td></tr>
<tr><td>10</td><td>Leerzeichen</td><td>Leerzeichen</td></tr>
<tr><td>11</td><td>Buchstabe</td><td>a-z A-Z</td></tr>
<tr><td>12</td><td>anderes Zeichen</td><td>alle anderen</td></tr>
<tr><td>13</td><td>aktives Zeichen</td><td> ~ </td></tr>
<tr><td>14</td><td>Kommentar</td><td> % </td></tr>
<tr><td>15</td><td>ungültiges Zeichen</td><td></td></tr>
</table>
Die Kategoriecodes bestimmen, welches Zeichen eine Befehlssequenz einleitet, welche ein Argument beginnen und beenden, welche im Mathemodus Hoch- und Tiefstellung bedeuten usw.
Für den Anwender ist es in der Regel zweitrangig, darüber Bescheid zu wissen. Die wesentlichen Funktionen von ``\``, `{`, `}`, `$` usw kennt man ohnehin, ohne über Kategoriecodes etwas zu wissen. Wichtig ist vor allem die Unterscheidung zwischen _Buchstabe_ und _anderes Zeichen_, da Befehlsnamen (die einem ``\`` oder genauer: einem Zeichen mit Kategoriecode 0 folgen) entweder aus einer beliebigen Anzahl von Buchstaben (Kategoriecode 11) bestehen können oder aus _einem_ anderen (Kategoriecode 12) Zeichen. Nach ersteren werden Leerzeichen ignoriert, nach letzteren _nicht_!
\documentclass{article}
\newcommand*\amp{\&}
\begin{document}
+\amp +\par
+\& +
\end{document}
![alt text][1]
Der Unterschied zwischen Buchstaben und anderen Zeichen wird auch bei der Funktion des `@` in internen Makronamen ausgenützt. Siehe dazu [was machen eigentlich `\\makeatletter` und `\\makeatother`?](http://texwelt.de/wissen/fragen/1/). Ähnliches gilt für expl3 (die LaTeX3-Programmierkonvention), wo `_` und `:` Buchstaben sind, Leerzeichen und Zeilenenden ignoriert werden und `~` ein normales Leerzeichen ausgibt.
Auch von Interesse ist vielleicht der Kategoriecode _aktiv_. Ein Zeichen, dessen Kategoriecode 13 ist, verhält sich wie eine Befehlssequenz. Man kennt hier üblicherweise `~`. Der LaTeX-Kernel enthält
\catcode`\~=13
\def~{\nobreakspace{}}
Grundsätzlich kann der Kategoriecode jedes Zeichens zu jeder Zeit geändert werden. Das verwenden z.B. die Befehle und Umgebungen für Verbatim-Text, die es ja ermöglichen, auch die Zeichen, die nicht Buchstabe oder anderes Zeichen sind, direkt auszugeben. Die Vorbelegung wird soweit ich weiß<sup>1</sup> teilweise vom Format und teilweise vom Kernel vorgenommen.
Der vorige Absatz stimmt nicht ganz: sobald ein Zeichen als Argument eines Befehls gelesen wurde, ist sein Kategoriecode fixiert. Deaher müssen Befehle wie `\verb` auch erst die betreffenden Kategoriecodes ändern (man findet hier im LaTeX-Kernel die Anweisung `\let\do\@makeother \dospecials`) und dann einen weiteren Befehl aufrufen, der jetzt die folgen Zeichen mit neuem Kategoriecode tatsächlich als Argument bekommt (im Fall von `\verb` selbst passiert das tatsächlich _nicht_, die Zeichen werden _gar nicht_ als Argument gelesen, es gibt aber andere Beispiele).
Die gerade erwähnte Fixierung in Argumenten von Befehlen ist übrigens der Grund, warum man Befehle wie `\verb` nicht in Argumenten von Befehlen einsetzen kann. Es gibt keine Möglichkeit, die Fixierung der Kategoriecodes zu verhindern. Mit e-TeXs `\scantokens` gibt es allerdings die Möglichkeit, die Zeichen erneut „einzulesen“. Mit TeXs `\string` oder [e-TeXs `\detokenize`][2] kann man Zeichen nachträglich noch Kategoriecode 12 zuweisen.
Der folgende Code zeigt jetzt noch ein Beispiel aus dem Kernel (Teil der Definition der `verbatim`-Umgebung), bei dem in einer Gruppe ``\``, `{` und `}` zu anderen Zeichen werden und `|`, `[` und `]` temporär ihre Rolle übernehmen.
\begingroup \catcode `|=0 \catcode `[= 1
\catcode`]=2 \catcode `\{=12 \catcode `\}=12
\catcode`\\=12 |gdef|@xverbatim#1\end{verbatim}[#1|end[verbatim]]
|gdef|@sxverbatim#1\end{verbatim*}[#1|end[verbatim*]]
|endgroup
----------
Meine Erfahrung und mein Wissen über `\lccode` und `\uccode` hält sich sehr in Grenzen: ich musste mich bislang noch nicht näher damit befassen. Sie bestimmen, was in den Argumenten von `\lowercase` und `\uppercase` passiert. Die Zeichen a--z haben _lccode_ = _Zeichencode_, die Zeichen A--Z _uccode_ = _Zeichencode_, Grußbuchstaben haben den lccode der Kleinbuchstaben und umgekehrt, andere Zeichen haben jeweils null. Zum Beispiel hat »a« den Zeichencode 97, den lccode 97 und den uccode 65, »A« hingegen hat Zeichencode 65, lccode 97 und uccode 65. `\uppercase` und `\lowercase` gehen nun durch die Zeichen in ihrem Argument und ersetzen sie (wenn der lcode bzw uccode nicht Null ist) durch das Zeichen des entsprechenden lccodes bzw uccodes. Dabei ändert sich der Kategoriecode des Zeichens nicht.
\documentclass{article}
\usepackage{array}
\newcommand*\zeichen[1]{%
-- #1 --\par
Zeichencode: \number`#1 \par
uccode: \the\uccode`#1 \par
lccode: \the\lccode`#1 \par
Kategoriecode: \the\catcode`#1 \par
}
\begin{document}
\catcode`\A=12
\begin{tabular}{*2{p{.33\linewidth}}}
\zeichen{a} &
\zeichen{A} \\
\lowercase{\zeichen{A}} & % wie \zeichen{a}, auch der Kategoriecode stimmt
\uppercase{\zeichen{a}} % wie \zeichen{A}, auch der Kategoriecode stimmt
\end{tabular}
\end{document}
![alt text][3]
Als Anwendung ist mir vor allem der „`\lowercase`-Trick“ bekannt, den man anwenden kann, um einem Zeichen eine Definition zu geben, wenn es aktiv ist:
\documentclass{article}
\usepackage{xcolor}
\begingroup\lccode`~=`.
\lowercase{\endgroup\def~}#1{\color{red}{#1}}
\newenvironment{strange}{\catcode`\.=13 }{}
\begin{document}
.foo
\begin{strange}
.foo
\end{strange}
\end{document}
Man nützt hier aus, dass `~` bereits aktiv ist. Dann setzt man temporär den `\lccode` von `~` gleich dem des Zeichens, dem man eine Definition geben möchte. Innerhalb von `\lowercase` wird dann `~` wie eine aktive Version des gewünschten Zeichens behandelt, so dass man ihm eine Definition zuweisen kann. Da das alles in einer Gruppe geschieht, ist das Zeichen hinterher nicht aktiv und `~` hat seinen ursprünglichen `\lccode` wieder. Macht man nun später das betreffende Zeichen aktiv (gibt ihm also Kategoriecode 13), dann hat es die hier gegebene Definition.
`\lowercase` „behandelt“ die Zeichen in seinem Argument, _bevor_ die Anweisungen in seinem Argument ausgeführt werden. Man vermeidet damit, dass man die Definition global machen muss, da man die Gruppe schließen kann, bevor man die Definition vornimmt.
----------
1. Vielleicht kann das jemand bestätigen/verneinen?
[1]: http://texwelt.de/wissen/upfiles/befehlssequenz.png
[2]: http://texwelt.de/wissen/fragen/1893#1894
[3]: http://texwelt.de/wissen/upfiles/lcuccode.png
|
|
5 |
Weitere Informationen zu lccode und uccode
|
|
Jedem ASCII-Zeichen (mit XeLaTeX und LuaLaTeX vermutlich jedem Unicode-Zeichen<sup>1</sup>) ist unter anderem ein Kategorie-Code oder _catcode_ zugeordnet. Es gibt 16 Kategoriecodes. Die folgende Tabelle listet sie auf zusammen mit LaTeX's Vorbelegung.
<table>
<tr><th>Nummer</th><th>Funktion</th><th>Zeichen</th></tr>
<tr><td>0</td><td>Escape-Zeichen, leitet eine Befehlssequenz ein</td><td> \ </td></tr>
<tr><td>1</td><td>Beginn einer Gruppe/eines Arguments</td><td> { </td></tr>
<tr><td>2</td><td>Ende einer Gruppe/eines Arguments</td><td> } </td></tr>
<tr><td>3</td><td>Wechsel in Mathemodus und zurück</td><td> $ </td></tr>
<tr><td>4</td><td>Ausrichtung</td><td> & </td></tr>
<tr><td>5</td><td>Ende einer Zeile</td><td> Return </td></tr>
<tr><td>6</td><td>Parameter</td><td> # </td></tr>
<tr><td>7</td><td>Tiefstellung</td><td> _ </td></tr>
<tr><td>8</td><td>Hochstellung</td><td> ^ </td></tr>
<tr><td>9</td><td>ignoriertes Zeichen</td><td></td></tr>
<tr><td>10</td><td>Leerzeichen</td><td>Leerzeichen</td></tr>
<tr><td>11</td><td>Buchstabe</td><td>a-z A-Z</td></tr>
<tr><td>12</td><td>anderes Zeichen</td><td>alle anderen</td></tr>
<tr><td>13</td><td>aktives Zeichen</td><td> ~ </td></tr>
<tr><td>14</td><td>Kommentar</td><td> % </td></tr>
<tr><td>15</td><td>ungültiges Zeichen</td><td></td></tr>
</table>
Die Kategoriecodes bestimmen, welches Zeichen eine Befehlssequenz einleitet, welche ein Argument beginnen und beenden, welche im Mathemodus Hoch- und Tiefstellung bedeuten usw.
Für den Anwender ist es in der Regel zweitrangig, darüber Bescheid zu wissen. Die wesentlichen Funktionen von ``\``, `{`, `}`, `$` usw kennt man ohnehin, ohne über Kategoriecodes etwas zu wissen. Wichtig ist vor allem die Unterscheidung zwischen _Buchstabe_ und _anderes Zeichen_, da Befehlsnamen (die einem ``\`` oder genauer: einem Zeichen mit Kategoriecode 0 folgen) entweder aus einer beliebigen Anzahl von Buchstaben (Kategoriecode 11) bestehen können oder aus _einem_ anderen (Kategoriecode 12) Zeichen. Nach ersteren werden Leerzeichen ignoriert, nach letzteren _nicht_!
\documentclass{article}
\newcommand*\amp{\&}
\begin{document}
+\amp +\par
+\& +
\end{document}
![alt text][1]
Der Unterschied zwischen Buchstaben und anderen Zeichen wird auch bei der Funktion des `@` in internen Makronamen ausgenützt. Siehe dazu [was machen eigentlich `\\makeatletter` und `\\makeatother`?](http://texwelt.de/wissen/fragen/1/). Ähnliches gilt für expl3 (die LaTeX3-Programmierkonvention), wo `_` und `:` Buchstaben sind, Leerzeichen und Zeilenenden ignoriert werden und `~` ein normales Leerzeichen ausgibt.
Auch von Interesse ist vielleicht der Kategoriecode _aktiv_. Ein Zeichen, dessen Kategoriecode 13 ist, verhält sich wie eine Befehlssequenz. Man kennt hier üblicherweise `~`. Der LaTeX-Kernel enthält
\catcode`\~=13
\def~{\nobreakspace{}}
Grundsätzlich kann der Kategoriecode jedes Zeichens zu jeder Zeit geändert werden. Das verwenden z.B. die Befehle und Umgebungen für Verbatim-Text, die es ja ermöglichen, auch die Zeichen, die nicht Buchstabe oder anderes Zeichen sind, direkt auszugeben. Die Vorbelegung wird soweit ich weiß<sup>1</sup> teilweise vom Format und teilweise vom Kernel vorgenommen.
Der vorige Absatz stimmt nicht ganz: sobald ein Zeichen als Argument eines Befehls gelesen wurde, ist sein Kategoriecode fixiert. Deaher müssen Befehle wie `\verb` auch erst die betreffenden Kategoriecodes ändern (man findet hier im LaTeX-Kernel die Anweisung `\let\do\@makeother \dospecials`) und dann einen weiteren Befehl aufrufen, der jetzt die folgen Zeichen mit neuem Kategoriecode tatsächlich als Argument bekommt (im Fall von `\verb` selbst passiert das tatsächlich _nicht_, die Zeichen werden _gar nicht_ als Argument gelesen, es gibt aber andere Beispiele).
Die gerade erwähnte Fixierung in Argumenten von Befehlen ist übrigens der Grund, warum man Befehle wie `\verb` nicht in Argumenten von Befehlen einsetzen kann. Es gibt keine Möglichkeit, die Fixierung der Kategoriecodes zu verhindern. Mit e-TeXs `\scantokens` gibt es allerdings die Möglichkeit, die Zeichen erneut „einzulesen“. Mit TeXs `\string` oder [e-TeXs `\detokenize`][2] kann man Zeichen nachträglich noch Kategoriecode 12 zuweisen.
Der folgende Code zeigt jetzt noch ein Beispiel aus dem Kernel (Teil der Definition der `verbatim`-Umgebung), bei dem in einer Gruppe ``\``, `{` und `}` zu anderen Zeichen werden und `|`, `[` und `]` temporär ihre Rolle übernehmen.
\begingroup \catcode `|=0 \catcode `[= 1
\catcode`]=2 \catcode `\{=12 \catcode `\}=12
\catcode`\\=12 |gdef|@xverbatim#1\end{verbatim}[#1|end[verbatim]]
|gdef|@sxverbatim#1\end{verbatim*}[#1|end[verbatim*]]
|endgroup
----------
Meine Erfahrung und mein Wissen über `\lccode` und `\uccode` hält sich sehr in Grenzen: ich musste mich bislang noch nicht näher damit befassen. Sie bestimmen, was in den Argumenten von `\lowercase` und `\uppercase` passiert.
Mir bekannt passiert. Die Zeichen a--z haben _lccode_ = _Zeichencode_, die Zeichen A--Z _uccode_ = _Zeichencode_, andere Zeichen haben jeweils null. Zum Beispiel hat »a« den Zeichencode 97, den lccode 97 und den uccode 65, »A« hingegen hat Zeichencode 65, lccode 97 und uccode 65. `\uppercase` und `\lowercase` gehen nun durch die Zeichen in ihrem Argument und ersetzen sie (wenn der lcode bzw uccode nicht Null ist) durch das Zeichen des entsprechenden lccodes bzw uccodes. Dabei ändert sich der Kategoriecode des Zeichens nicht.
\documentclass{article}
\usepackage{array}
\newcommand*\zeichen[1]{%
-- #1 --\par
Zeichencode: \number`#1 \par
uccode: \the\uccode`#1 \par
lccode: \the\lccode`#1 \par
Kategoriecode: \the\catcode`#1 \par
}
\begin{document}
\catcode`\A=12
\begin{tabular}{*2{p{.33\linewidth}}}
\zeichen{a} &
\zeichen{A} \\
\lowercase{\zeichen{A}} & % wie \zeichen{a}, auch der Kategoriecode stimmt
\uppercase{\zeichen{a}} % wie \zeichen{A}, auch der Kategoriecode stimmt
\end{tabular}
\end{document}
![alt text][3]
Als Anwendung ist mir vor allem der „`\lowercase`-Trick“, „`\lowercase`-Trick“ bekannt, den man anwenden kann, um einem Zeichen eine Definition zu geben, wenn es aktiv ist:
\documentclass{article}
\usepackage{xcolor}
\begingroup\lccode`~=`.
\lowercase{\endgroup\def~}#1{\color{red}{#1}}
\newenvironment{strange}{\catcode`\.=13 }{}
\begin{document}
.foo
\begin{strange}
.foo
\end{strange}
\end{document}
Man nützt hier aus, dass `~` bereits aktiv ist. Dann setzt man temporär den `\lccode` von `~` gleich dem des Zeichens, dem man eine Definition geben möchte. Innerhalb von `\lowercase` wird dann `~` wie eine aktive Version des gewünschten Zeichens behandelt, so dass man ihm eine Definition zuweisen kann. Da das alles in einer Gruppe geschieht, ist das Zeichen hinterher nicht aktiv und `~` hat seinen ursprünglichen `\lccode` wieder. Macht man nun später das betreffende Zeichen aktiv (gibt ihm also Kategoriecode 13), dann hat es die hier gegebene Definition.
`\lowercase` „behandelt“ die Zeichen in seinem Argument, _bevor_ die Anweisungen in seinem Argument ausgeführt werden. Man vermeidet damit, dass man die Definition global machen muss, da man die Gruppe schließen kann, bevor man die Definition vornimmt.
----------
1. Vielleicht kann das jemand bestätigen/verneinen?
[1]: http://texwelt.de/wissen/upfiles/befehlssequenz.png
[2]: http://texwelt.de/wissen/fragen/1893#1894http://texwelt.de/wissen/fragen/1893#1894
[3]: http://texwelt.de/wissen/upfiles/lcuccode.png
|
|
4 |
|
|
Jedem ASCII-Zeichen (mit XeLaTeX und LuaLaTeX vermutlich jedem Unicode-Zeichen<sup>1</sup>) ist unter anderem ein Kategorie-Code oder _catcode_ zugeordnet. Es gibt 16 Kategoriecodes. Die folgende Tabelle listet sie auf zusammen mit LaTeX's Vorbelegung.
<table>
<tr><th>Nummer</th><th>Funktion</th><th>Zeichen</th></tr>
<tr><td>0</td><td>Escape-Zeichen, leitet eine Befehlssequenz ein</td><td> \ </td></tr>
<tr><td>1</td><td>Beginn einer Gruppe/eines Arguments</td><td> { </td></tr>
<tr><td>2</td><td>Ende einer Gruppe/eines Arguments</td><td> } </td></tr>
<tr><td>3</td><td>Wechsel in Mathemodus und zurück</td><td> $ </td></tr>
<tr><td>4</td><td>Ausrichtung</td><td> & </td></tr>
<tr><td>5</td><td>Ende einer Zeile</td><td> Return </td></tr>
<tr><td>6</td><td>Parameter</td><td> # </td></tr>
<tr><td>7</td><td>Tiefstellung</td><td> _ </td></tr>
<tr><td>8</td><td>Hochstellung</td><td> ^ </td></tr>
<tr><td>9</td><td>ignoriertes Zeichen</td><td></td></tr>
<tr><td>10</td><td>Leerzeichen</td><td>Leerzeichen</td></tr>
<tr><td>11</td><td>Buchstabe</td><td>a-z A-Z</td></tr>
<tr><td>12</td><td>anderes Zeichen</td><td>alle anderen</td></tr>
<tr><td>13</td><td>aktives Zeichen</td><td> ~ </td></tr>
<tr><td>14</td><td>Kommentar</td><td> % </td></tr>
<tr><td>15</td><td>ungültiges Zeichen</td><td></td></tr>
</table>
Die Kategoriecodes bestimmen, welches Zeichen eine Befehlssequenz einleitet, welche ein Argument beginnen und beenden, welche im Mathemodus Hoch- und Tiefstellung bedeuten usw.
Für den Anwender ist es in der Regel zweitrangig, darüber Bescheid zu wissen. Die wesentlichen Funktionen von ``\``, `{`, `}`, `$` usw kennt man ohnehin, ohne über Kategoriecodes etwas zu wissen. Wichtig ist vor allem die Unterscheidung zwischen _Buchstabe_ und _anderes Zeichen_, da Befehlsnamen (die einem ``\`` oder genauer: einem Zeichen mit Kategoriecode 0 folgen) entweder aus einer beliebigen Anzahl von Buchstaben (Kategoriecode 11) bestehen können oder aus _einem_ anderen (Kategoriecode 12) Zeichen. Nach ersteren werden Leerzeichen ignoriert, nach letzteren _nicht_!
\documentclass{article}
\newcommand*\amp{\&}
\begin{document}
+\amp +\par
+\& +
\end{document}
![alt text][1]
Der Unterschied zwischen Buchstaben und anderen Zeichen wird auch bei der Funktion des `@` in internen Makronamen ausgenützt. Siehe dazu [was machen eigentlich `\\makeatletter` und `\\makeatother`?](http://texwelt.de/wissen/fragen/1/). Ähnliches gilt für expl3 (die LaTeX3-Programmierkonvention), wo `_` und `:` Buchstaben sind, Leerzeichen und Zeilenenden ignoriert werden und `~` ein normales Leerzeichen ausgibt.
Auch von Interesse ist vielleicht der Kategoriecode _aktiv_. Ein Zeichen, dessen Kategoriecode 13 ist, verhält sich wie eine Befehlssequenz. Man kennt hier üblicherweise `~`. Der LaTeX-Kernel enthält
\catcode`\~=13
\def~{\nobreakspace{}}
Grundsätzlich kann der Kategoriecode jedes Zeichens zu jeder Zeit geändert werden. (Das Das verwenden z.B. die Befehle und Umgebungen für Verbatim-Text, die es ja ermöglichen, auch die Zeichen, die nicht Buchstabe oder anderes Zeichen sind, direkt auszugeben. Die Vorbelegung wird soweit ich weiß<sup>1</sup> teilweise vom Format und teilweise vom Kernel vorgenommen.
Der vorige Absatz stimmt nicht ganz: sobald ein Zeichen als Argument eines Befehls gelesen wurde, ist sein Kategoriecode fixiert.) Das verwenden z.B. die fixiert. Deaher müssen Befehle und Umgebungen für Verbatim-Text, die es ja ermöglichen, wie `\verb` auch die Zeichen, die nicht Buchstabe oder anderes Zeichen sind, direkt auszugeben. (Man erst die betreffenden Kategoriecodes ändern (man findet hier im LaTeX-Kernel die Anweisung `\let\do\@makeother \dospecials`. \dospecials`) und dann einen weiteren Befehl aufrufen, der jetzt die folgen Zeichen mit neuem Kategoriecode tatsächlich als Argument bekommt (im Fall von `\verb` selbst passiert das tatsächlich _nicht_, die Zeichen werden _gar nicht_ als Argument gelesen, es gibt aber andere Beispiele).
Die gerade erwähnte Fixierung in Argumenten von Befehlen ist übrigens der Grund, warum man Befehle wie `\verb` nicht in Argumenten von Bafehlen Befehlen einsetzen kann.) Die Vorbelegung wird soweit ich weiß<sup>1</sup> teilweise vom Format und teilweise vom Kernel vorgenommen.
kann. Es gibt keine Möglichkeit, die Fixierung der Kategoriecodes zu verhindern. Mit e-TeXs `\scantokens` gibt es allerdings die Möglichkeit, die Zeichen erneut „einzulesen“. Mit TeXs `\string` oder [e-TeXs `\detokenize`][2] kann man Zeichen nachträglich noch Kategoriecode 12 zuweisen.
Der folgende Code zeigt jetzt noch ein etwas sinnloses Beispiel, Beispiel aus dem Kernel (Teil der Definition der `verbatim`-Umgebung), bei dem in einer Gruppe ``\``, `{` und `}` zu anderen Zeichen werden und `|`, `[` und `]` temporär ihre Rolle übernehmen.
\documentclass{article}
\begin{document}
\begingroup
\catcode`|=0 \catcode`[= 1 \catcode`]=2
\begingroup \catcode `|=0 \catcode `[= 1
\catcode`]=2 \catcode `\{=12 \catcode `\}=12 \catcode`\\=12
|gdef|foo#1[+#1+]
`\}=12
\catcode`\\=12 |gdef|@xverbatim#1\end{verbatim}[#1|end[verbatim]]
|gdef|@sxverbatim#1\end{verbatim*}[#1|end[verbatim*]]
|endgroup
\foo{foo}
\end{document}
----------
Meine Erfahrung und mein Wissen über `\lccode` und `\uccode` hält sich sehr in Grenzen: ich musste mich bislang noch nicht näher damit befassen. Sie bestimmen, was in den Argumenten von `\lowercase` und `\uppercase` passiert.
Mir bekannt ist vor allem der „`\lowercase`-Trick“, den man anwenden kann, um einem Zeichen eine Definition zu geben, wenn es aktiv ist:
\documentclass{article}
\usepackage{xcolor}
\begingroup\lccode`~=`.
\lowercase{\endgroup\def~}#1{\color{red}{#1}}
\newenvironment{strange}{\catcode`\.=13 }{}
\begin{document}
.foo
\begin{strange}
.foo
\end{strange}
\end{document}
Man nützt hier aus, dass `~` bereits aktiv ist. Dann setzt man temporär den `\lccode` von `~` gleich dem des Zeichens, dem man eine Definition geben möchte. Innerhalb von `\lowercase` wird dann `~` wie eine aktive Version des gewünschten Zeichens behandelt, so dass man ihm eine Definition zuweisen kann. Da das alles in einer Gruppe geschieht, ist das Zeichen hinterher nicht aktiv und `~` hat seinen ursprünglichen `\lccode` wieder. Macht man nun später das betreffende Zeichen aktiv (gibt ihm also Kategoriecode 13), dann hat es die hier gegebene Definition.
`\lowercase` „behandelt“ die Zeichen in seinem Argument, _bevor_ die Anweisungen in seinem Argument ausgeführt werden. Man vermeidet damit, dass man die Definition global machen muss, da man die Gruppe schließen kann, bevor man die Definition vornimmt.
----------
1. Vielleicht kann das jemand bestätigen/verneinen?
[1]: http://texwelt.de/wissen/upfiles/befehlssequenz.png
[2]: http://texwelt.de/wissen/fragen/1893#1894
|
|
3 |
|
|
Jedem ASCII-Zeichen (mit XeLaTeX und LuaLaTeX vermutlich jedem Unicode-Zeichen<sup>1</sup>) ist unter anderem ein Kategorie-Code oder _catcode_ zugeordnet. Es gibt 16 Kategoriecodes. Die folgende Tabelle listet sie auf zusammen mit LaTeX's Vorbelegung.
<table>
<tr><th>Nummer</th><th>Funktion</th><th>Zeichen</th></tr>
<tr><td>0</td><td>Escape-Zeichen, leitet eine Befehlssequenz ein</td><td> \ </td></tr>
<tr><td>1</td><td>Beginn einer Gruppe/eines Arguments</td><td> { </td></tr>
<tr><td>2</td><td>Ende einer Gruppe/eines Arguments</td><td> } </td></tr>
<tr><td>3</td><td>Wechsel in Mathemodus und zurück</td><td> $ </td></tr>
<tr><td>4</td><td>Ausrichtung</td><td> & </td></tr>
<tr><td>5</td><td>Ende einer Zeile</td><td> Return </td></tr>
<tr><td>6</td><td>Parameter</td><td> # </td></tr>
<tr><td>7</td><td>Tiefstellung</td><td> _ </td></tr>
<tr><td>8</td><td>Hochstellung</td><td> ^ </td></tr>
<tr><td>9</td><td>ignoriertes Zeichen</td><td></td></tr>
<tr><td>10</td><td>Leerzeichen</td><td>Leerzeichen</td></tr>
<tr><td>11</td><td>Buchstabe</td><td>a-z A-Z</td></tr>
<tr><td>12</td><td>anderes Zeichen</td><td>alle anderen</td></tr>
<tr><td>13</td><td>aktives Zeichen</td><td> ~ </td></tr>
<tr><td>14</td><td>Kommentar</td><td> % </td></tr>
<tr><td>15</td><td>ungültiges Zeichen</td><td></td></tr>
</table>
Die Kategoriecodes bestimmen, welches Zeichen eine Befehlssequenz einleitet, welche ein Argument beginnen und beenden, welche im Mathemodus Hoch- und Tiefstellung bedeuten usw.
Für den Anwender ist es in der Regel zweitrangig, darüber Bescheid zu wissen. Die wesentlichen Funktionen von ``\``, `{`, `}`, `$` usw kennt man ohnehin, ohne über Kategoriecodes etwas zu wissen. Wichtig ist vor allem die Unterscheidung zwischen _Buchstabe_ und _anderes Zeichen_, da Befehlsnahmen Befehlsnamen (die einem ``\`` oder genauer: einem Zeichen mit Kategoriecode 0 folgen) entweder aus einer beliebigen Anzahl von Buchstaben (Kategoriecode 11) bestehen können oder aus _einem_ anderen (Kategoriecode 12) Zeichen. Nach ersteren werden Leerzeichen ignoriert, nach letzteren _nicht_!
\documentclass{article}
\newcommand*\amp{\&}
\begin{document}
+\amp +\par
+\& +
\end{document}
![alt text][1]
Der Unterschied zwischen Buchstaben und anderen Zeichen wird auch bei der Funktion des `@` in internen Makronamen ausgenützt. Siehe dazu [was machen eigentlich `\\makeatletter` und `\\makeatother`?](http://texwelt.de/wissen/fragen/1/). Ähnliches gilt für expl3 (die LaTeX3-Programmierkonvention), wo `_` und `:` Buchstaben sind, Leerzeichen und Zeilenenden ignoriert werden und `~` ein normales Leerzeichen ausgibt.
Auch von Interesse ist vielleicht der Kategoriecode _aktiv_. Ein Zeichen, dessen Kategoriecode `13` 13 ist, verhält sich wie eine Befehlssequenz. Man kennt hier üblicherweise `~`. Der LaTeX-Kernel enthält
\catcode`\~=13
\def~{\nobreakspace{}}
Grundsätzlich kann der Kategoriecode jedes Zeichens zu jeder Zeit geändert werden. (Das stimmt nicht ganz: sobald ein Zeichen als Argument eines Befehls gelesen wurde, ist sein Kategoriecode fixiert.) Das verwenden z.B. die Befehle und Umgebungen für Verbatim-Text, die es ja ermöglichen, auch die Zeichen, die nicht Buchstabe oder anderes Zeichen sind, direkt auszugeben. (Man findet hier im LaTeX-Kernel die Anweisung `\let\do\@makeother \dospecials`. Die gerade erwähnte Fixierung in Argumenten von Befehlen ist übrigens der Grund, warum man `\verb` nicht in Argumenten von Bafehlen einsetzen kann.) Die Vorbelegung wird soweit ich weiß<sup>1</sup> teilweise vom Format und teilweise vom Kernel vorgenommen.
Der folgende Code zeigt ein etwas sinnloses Beispiel, bei dem in einer Gruppe ``\``, `{` und `}` zu anderen Zeichen werden und `|`, `[` und `]` temporär ihre Rolle übernehmen.
\documentclass{article}
\begin{document}
\begingroup
\catcode`|=0 \catcode`[= 1 \catcode`]=2
\catcode `\{=12 \catcode `\}=12 \catcode`\\=12
|gdef|foo#1[+#1+]
|endgroup
\foo{foo}
\end{document}
----------
Meine Erfahrung und mein Wissen über `\lccode` und `\uccode` hält sich sehr in Grenzen: ich musste mich bislang noch nicht näher damit befassen. Sie bestimmen, was in den Argumenten von `\lowercase` und `\uppercase` passiert.
Mir bekannt ist vor allem der „`\lowercase`-Trick“, den man anwenden kann, um einem Zeichen eine Definition zu geben, wenn es aktiv ist:
\documentclass{article}
\usepackage{xcolor}
\begingroup\lccode`~=`.
\lowercase{\endgroup\def~}#1{\color{red}{#1}}
\newenvironment{strange}{\catcode`\.=13 }{}
\begin{document}
.foo
\begin{strange}
.foo
\end{strange}
\end{document}
Man nützt hier aus, dass `~` bereits aktiv ist. Dann setzt man temporär den `\lccode` von `~` gleich dem des Zeichens, dem man eine Definition geben möchte. Innerhalb von `\lowercase` wird dann `~` wie eine aktive Version des gewünschten Zeichens behandelt, so dass man ihm eine Definition zuweisen kann. Da das alles in einer Gruppe geschieht, ist das Zeichen hinterher nicht aktiv und `~` hat seinen ursprünglichen `\lccode` wieder. Macht man nun später das betreffende Zeichen aktiv (gibt ihm also Kategoriecode 13), dann hat es die hier gegebene Definition.
`\lowercase` „behandelt“ die Zeichen in seinem Argument, _bevor_ die Anweisungen in seinem Argument ausgeführt werden. Man vermeidet damit, dass man die Definition globel global machen muss, da man die Gruppe schließen kann, bevor man die Definition vornimmt.
----------
1. Vielleicht kann das jemand bestätigen/verneinen?
[1]: http://texwelt.de/wissen/upfiles/befehlssequenz.png
|
|
2 |
|
|
Jedem ASCII-Zeichen (mit XeLaTeX und LuaLaTeX vermutlich jedem Unicode-Zeichen<sup>1</sup>) ist unter anderem ein Kategorie-Code oder _catcode_ zugeordnet. Es gibt 16 Kategoriecodes. Die folgende Tabelle listet sie auf zusammen mit LaTeX's Vorbelegung.
<table>
<tr><th>Nummer</th><th>Funktion</th><th>Zeichen</th></tr>
<tr><td>0</td><td>Escape-Zeichen, leitet eine Befehlssequenz ein</td><td> \ </td></tr>
<tr><td>1</td><td>Beginn einer Gruppe/eines Arguments</td><td> { </td></tr>
<tr><td>2</td><td>Ende einer Gruppe/eines Arguments</td><td> } </td></tr>
<tr><td>3</td><td>Wechsel in Mathemodus und zurück</td><td> $ </td></tr>
<tr><td>4</td><td>Ausrichtung</td><td> & </td></tr>
<tr><td>5</td><td>Ende einer Zeile</td><td> Return </td></tr>
<tr><td>6</td><td>Parameter</td><td> # </td></tr>
<tr><td>7</td><td>Tiefstellung</td><td> _ </td></tr>
<tr><td>8</td><td>Hochstellung</td><td> ^ </td></tr>
<tr><td>9</td><td>ignoriertes Zeichen</td><td></td></tr>
<tr><td>10</td><td>Leerzeichen</td><td>Leerzeichen</td></tr>
<tr><td>11</td><td>Buchstabe</td><td>a-z A-Z</td></tr>
<tr><td>12</td><td>anderes Zeichen</td><td>alle anderen</td></tr>
<tr><td>13</td><td>aktives Zeichen</td><td> ~ </td></tr>
<tr><td>14</td><td>Kommentar</td><td> % </td></tr>
<tr><td>15</td><td>ungültiges Zeichen</td><td></td></tr>
</table>
Die Kategoriecodes bestimmen, welches Zeichen eine Befehlssequenz einleitet, welche ein Argument beginnen und beenden, welche im Mathemodus Hoch- und Tiefstellung bedeuten usw.
Für den Anwender ist es in der Regel zweitrangig, darüber Bescheid zu wissen. Die wesentlichen Funktionen von ``\``, `{`, `}`, `$` usw kennt man ohnehin, ohne über Kategoriecodes etwas zu wissen. Wichtig ist vor allem die Unterscheidung zwischen _Buchstabe_ und _anderes Zeichen_, da Befehlsnahmen (die einem ``\`` folgen) entweder aus einer beliebigen Anzahl von Buchstaben bestehen können oder aus _einem_ anderen Zeichen. Nach ersteren werden Leerzeichen ignoriert, nach letzteren _nicht_!
\documentclass{article}
\newcommand*\amp{\&}
\begin{document}
+\amp +\par
+\& +
\end{document}
![alt text][1]
Der Unterschied zwischen Buchstaben und anderen Zeichen wird auch bei der Funktion des `@` in internen Makronamen ausgenützt. Siehe dazu [was machen eigentlich `\makeatletter` und `\makeatother`?](http://texwelt.de/wissen/fragen/1/). `\\makeatletter` und `\\makeatother`?](http://texwelt.de/wissen/fragen/1/). Ähnliches gilt für expl3 (die LaTeX3-Programmierkonvention), wo `_` und `:` Buchstaben sind, Leerzeichen und Zeilenenden ignoriert werden und `~` ein normales Leerzeichen ausgibt.
Auch von Interesse ist vielleicht der Kategoriecode _aktiv_. Ein Zeichen, dessen Kategoriecode `13` ist, verhält sich wie eine Befehlssequenz. Man kennt hier üblicherweise `~`. Der LaTeX-Kernel enthält
\catcode`\~=13
\def~{\nobreakspace{}}
Grundsätzlich kann der Kategoriecode jedes Zeichens zu jeder Zeit geändert werden. (Das stimmt nicht ganz: sobald ein Zeichen als Argument eines Befehls gelesen wurde, ist sein Kategoriecode fixiert.) Das verwenden z.B. die Befehle und Umgebungen für Verbatim-Text, die es ja ermöglichen, auch die Zeichen, die nicht Buchstabe oder anderes Zeichen sind, direkt auszugeben. (Man findet hier im LaTeX-Kernel die Anweisung `\let\do\@makeother \dospecials`. Die gerade erwähnte Fixierung in Argumenten von Befehlen ist übrigens der Grund, warum man `\verb` nicht in Argumenten von Bafehlen einsetzen kann.) Die Vorbelegung wird soweit ich weiß<sup>1</sup> teilweise vom Format und teilweise vom Kernel vorgenommen.
Der folgende Code zeigt ein etwas sinnloses Beispiel, bei dem in einer Gruppe ``\``, `{` und `}` zu anderen Zeichen werden und `|`, `[` und `]` temporär ihre Rolle übernehmen.
\documentclass{article}
\begin{document}
\begingroup
\catcode`|=0 \catcode`[= 1 \catcode`]=2
\catcode `\{=12 \catcode `\}=12 \catcode`\\=12
|gdef|foo#1[+#1+]
|endgroup
\foo{foo}
\end{document}
----------
Meine Erfahrung und mein Wissen über `\lccode` und `\uccode` hält sich sehr in Grenzen: ich musste mich bislang noch nicht näher damit befassen. Sie bestimmen, was in den Argumenten von `\lowercase` und `\uppercase` passiert.
Mir bekannt ist vor allem der „`\lowercase`-Trick“, den man anwenden kann, um einem Zeichen eine Definition zu geben, wenn es aktiv ist:
\documentclass{article}
\usepackage{xcolor}
\begingroup\lccode`~=`.
\lowercase{\endgroup\def~}#1{\color{red}{#1}}
\newenvironment{strange}{\catcode`\.=13 }{}
\begin{document}
.foo
\begin{strange}
.foo
\end{strange}
\end{document}
Man nützt hier aus, dass `~` bereits aktiv ist. Dann setzt man temporär den `\lccode` von `~` gleich dem des Zeichens, dem man eine Definition geben möchte. Innerhalb von `\lowercase` wird dann `~` wie eine aktive Version des gewünschten Zeichens behandelt, so dass man ihm eine Definition zuweisen kann. Da das alles in einer Gruppe geschieht, ist das Zeichen hinterher nicht aktiv und `~` hat seinen ursprünglichen `\lccode` wieder. Macht man nun später das betreffende Zeichen aktiv (gibt ihm also Kategoriecode 13), dann hat es die hier gegebene Definition.
`\lowercase` „behandelt“ die Zeichen in seinem Argument, _bevor_ die Anweisungen in seinem Argument ausgeführt werden. Man vermeidet damit, dass man die Definition globel machen muss, da man die Gruppe schließen kann, bevor man die Definition vornimmt.
----------
1. Vielleicht kann das jemand bestätigen/verneinen?
[1]: http://texwelt.de/wissen/upfiles/befehlssequenz.png
|
|
1 |
|
|
Jedem ASCII-Zeichen (mit XeLaTeX und LuaLaTeX vermutlich jedem Unicode-Zeichen<sup>1</sup>) ist unter anderem ein Kategorie-Code oder _catcode_ zugeordnet. Es gibt 16 Kategoriecodes. Die folgende Tabelle listet sie auf zusammen mit LaTeX's Vorbelegung.
<table>
<tr><th>Nummer</th><th>Funktion</th><th>Zeichen</th></tr>
<tr><td>0</td><td>Escape-Zeichen, leitet eine Befehlssequenz ein</td><td> \ </td></tr>
<tr><td>1</td><td>Beginn einer Gruppe/eines Arguments</td><td> { </td></tr>
<tr><td>2</td><td>Ende einer Gruppe/eines Arguments</td><td> } </td></tr>
<tr><td>3</td><td>Wechsel in Mathemodus und zurück</td><td> $ </td></tr>
<tr><td>4</td><td>Ausrichtung</td><td> & </td></tr>
<tr><td>5</td><td>Ende einer Zeile</td><td> Return </td></tr>
<tr><td>6</td><td>Parameter</td><td> # </td></tr>
<tr><td>7</td><td>Tiefstellung</td><td> _ </td></tr>
<tr><td>8</td><td>Hochstellung</td><td> ^ </td></tr>
<tr><td>9</td><td>ignoriertes Zeichen</td><td></td></tr>
<tr><td>10</td><td>Leerzeichen</td><td>Leerzeichen</td></tr>
<tr><td>11</td><td>Buchstabe</td><td>a-z A-Z</td></tr>
<tr><td>12</td><td>anderes Zeichen</td><td>alle anderen</td></tr>
<tr><td>13</td><td>aktives Zeichen</td><td> ~ </td></tr>
<tr><td>14</td><td>Kommentar</td><td> % </td></tr>
<tr><td>15</td><td>ungültiges Zeichen</td><td></td></tr>
</table>
Die Kategoriecodes bestimmen, welches Zeichen eine Befehlssequenz einleitet, welche ein Argument beginnen und beenden, welche im Mathemodus Hoch- und Tiefstellung bedeuten usw.
Für den Anwender ist es in der Regel zweitrangig, darüber Bescheid zu wissen. Die wesentlichen Funktionen von ``\``, `{`, `}`, `$` usw kennt man ohnehin, ohne über Kategoriecodes etwas zu wissen. Wichtig ist vor allem die Unterscheidung zwischen _Buchstabe_ und _anderes Zeichen_, da Befehlsnahmen (die einem ``\`` folgen) entweder aus einer beliebigen Anzahl von Buchstaben bestehen können oder aus _einem_ anderen Zeichen. Nach ersteren werden Leerzeichen ignoriert, nach letzteren _nicht_!
\documentclass{article}
\newcommand*\amp{\&}
\begin{document}
+\amp +\par
+\& +
\end{document}
![alt text][1]
Der Unterschied zwischen Buchstaben und anderen Zeichen wird auch bei der Funktion des `@` in internen Makronamen ausgenützt. Siehe dazu [was machen eigentlich `\makeatletter` und `\makeatother`?](http://texwelt.de/wissen/fragen/1/). Ähnliches gilt für expl3 (die LaTeX3-Programmierkonvention), wo `_` und `:` Buchstaben sind, Leerzeichen und Zeilenenden ignoriert werden und `~` ein normales Leerzeichen ausgibt.
Auch von Interesse ist vielleicht der Kategoriecode _aktiv_. Ein Zeichen, dessen Kategoriecode `13` ist, verhält sich wie eine Befehlssequenz. Man kennt hier üblicherweise `~`. Der LaTeX-Kernel enthält
\catcode`\~=13
\def~{\nobreakspace{}}
Grundsätzlich kann der Kategoriecode jedes Zeichens zu jeder Zeit geändert werden. (Das stimmt nicht ganz: sobald ein Zeichen als Argument eines Befehls gelesen wurde, ist sein Kategoriecode fixiert.) Das verwenden z.B. die Befehle und Umgebungen für Verbatim-Text, die es ja ermöglichen, auch die Zeichen, die nicht Buchstabe oder anderes Zeichen sind, direkt auszugeben. (Man findet hier im LaTeX-Kernel die Anweisung `\let\do\@makeother \dospecials`. Die gerade erwähnte Fixierung in Argumenten von Befehlen ist übrigens der Grund, warum man `\verb` nicht in Argumenten von Bafehlen einsetzen kann.) Die Vorbelegung wird soweit ich weiß<sup>1</sup> teilweise vom Format und teilweise vom Kernel vorgenommen.
Der folgende Code zeigt ein etwas sinnloses Beispiel, bei dem in einer Gruppe ``\``, `{` und `}` zu anderen Zeichen werden und `|`, `[` und `]` temporär ihre Rolle übernehmen.
\documentclass{article}
\begin{document}
\begingroup
\catcode`|=0 \catcode`[= 1 \catcode`]=2
\catcode `\{=12 \catcode `\}=12 \catcode`\\=12
|gdef|foo#1[+#1+]
|endgroup
\foo{foo}
\end{document}
----------
Meine Erfahrung und mein Wissen über `\lccode` und `\uccode` hält sich sehr in Grenzen: ich musste mich bislang noch nicht näher damit befassen. Sie bestimmen, was in den Argumenten von `\lowercase` und `\uppercase` passiert.
Mir bekannt ist vor allem der „`\lowercase`-Trick“, den man anwenden kann, um einem Zeichen eine Definition zu geben, wenn es aktiv ist:
\documentclass{article}
\usepackage{xcolor}
\begingroup\lccode`~=`.
\lowercase{\endgroup\def~}#1{\color{red}{#1}}
\newenvironment{strange}{\catcode`\.=13 }{}
\begin{document}
.foo
\begin{strange}
.foo
\end{strange}
\end{document}
Man nützt hier aus, dass `~` bereits aktiv ist. Dann setzt man temporär den `\lccode` von `~` gleich dem des Zeichens, dem man eine Definition geben möchte. Innerhalb von `\lowercase` wird dann `~` wie eine aktive Version des gewünschten Zeichens behandelt, so dass man ihm eine Definition zuweisen kann. Da das alles in einer Gruppe geschieht, ist das Zeichen hinterher nicht aktiv und `~` hat seinen ursprünglichen `\lccode` wieder. Macht man nun später das betreffende Zeichen aktiv (gibt ihm also Kategoriecode 13), dann hat es die hier gegebene Definition.
`\lowercase` „behandelt“ die Zeichen in seinem Argument, _bevor_ die Anweisungen in seinem Argument ausgeführt werden. Man vermeidet damit, dass man die Definition globel machen muss, da man die Gruppe schließen kann, bevor man die Definition vornimmt.
----------
1. Vielleicht kann das jemand bestätigen/verneinen?
[1]: http://texwelt.de/wissen/upfiles/befehlssequenz.png
