<html><head><meta name="color-scheme" content="light dark"></head><body><pre style="word-wrap: break-word; white-space: pre-wrap;">% ======================================================================
% scrbase-de.tex
% Copyright (c) Markus Kohm, 2002-2022
%
% This file is part of the LaTeX2e KOMA-Script bundle.
%
% This work may be distributed and/or modified under the conditions of
% the LaTeX Project Public License, version 1.3c of the license.
% The latest version of this license is in
%   http://www.latex-project.org/lppl.txt
% and version 1.3c or later is part of all distributions of LaTeX 
% version 2005/12/01 or later and of this work.
%
% This work has the LPPL maintenance status "author-maintained".
%
% The Current Maintainer and author of this work is Markus Kohm.
%
% This work consists of all files listed in MANIFEST.md.
% ======================================================================
%
% Package scrbase for Package and Class Authors
% Maintained by Markus Kohm
%
% ======================================================================

\KOMAProvidesFile{scrbase-de.tex}
                 [$Date: 2022-06-05 12:40:11 +0200 (So, 05. Jun 2022) $
                  KOMA-Script package scrbase]

\chapter{Grundlegende Funktionen im Paket \Package{scrbase}}
\labelbase{scrbase}
\BeginIndexGroup
\BeginIndex{Package}{scrbase}%

Das Paket \Package{scrbase} stellt einige grundlegende Funktionen bereit, die
sich an Autoren von Paketen und Klassen richten. Dabei kann es nicht nur fÃ¼r
Wrapper-Klassen genutzt werden, die ihrerseits eine \KOMAScript-Klasse
laden. Auch Autoren von Klassen, die ansonsten nichts mit \KOMAScript{} zu tun
haben, kÃ¶nnen von der FunktionalitÃ¤t von \Package{scrbase} profitieren.

\section{Laden des Pakets}
\seclabel{loadit}

WÃ¤hrend Anwender ein Paket mit Hilfe von \Macro{usepackage} laden, verwenden
Paket- und Klassenautoren
\Macro{RequirePackage}\IndexCmd{RequirePackage}. Autoren von Wrapper-Paketen
nutzen auch
\Macro{RequirePackageWithOptions}\IndexCmd{RequirePackageWithOptions}. Bei
Verwendung von \Macro{RequirePackage} kÃ¶nnen wie bei
\Macro{usepackage}\IndexCmd{usepackage} Optionen angegeben
werden. DemgegenÃ¼ber erhÃ¤lt das Paket bei \Macro{RequirePackageWithOptions}
alle Optionen, mit denen zuvor das Wrapper-Paket geladen wurde. NÃ¤heres zu
diesen Anweisungen ist \cite{latex:clsguide} zu entnehmen.

Das Paket \Package{scrbase} benÃ¶tigt intern die FunktionalitÃ¤t des Pakets
\Package{keyval}\IndexPackage{keyval}\important{\Package{keyval}}. Diese kann
auch vom Paket \Package{xkeyval} zur VerfÃ¼gung gestellt werden. Bei Bedarf
lÃ¤dt \Package{scrbase} selbst \Package{keyval}. NÃ¤heres zu dem Paket is
\cite{package:keyval} zu entnehmen.

Das Paket \Package{keyval} erlaubt es, SchlÃ¼ssel zu definieren und diesen
Werte zuzuweisen.  Auch die Optionen, die \Package{scrbase} bereitstellt,
verwenden die \Package{keyval}-Syntax: \OptionVName{\PName{SchlÃ¼ssel}}{Wert}%
\important{\OptionVName{\PName{SchlÃ¼ssel}}{Wert}}.


\section{SchlÃ¼ssel als Eigenschaften von Familien und deren Mitgliedern}
\seclabel{keyvalue}

Wie bereits in \autoref{sec:scrbase.loadit} erwÃ¤hnt, setzt \Package{scrbase}
bei SchlÃ¼sseln und deren Werten auf das Paket \Package{keyval}. Allerdings
erweitert es dessen FunktionalitÃ¤t. WÃ¤hrend bei \Package{keyval} ein SchlÃ¼ssel
einer Familie gehÃ¶rt, kennt \Package{scrbase} zu jeder Familie auch noch
Familienmitglieder. Ein SchlÃ¼ssel kann dann sowohl einer Familie als auch
einem oder mehreren Familienmitgliedern gehÃ¶ren. AuÃŸerdem kann ein Wert einem
SchlÃ¼ssel eines Familienmitglieds, einem SchlÃ¼ssel einer Familie oder einem
SchlÃ¼ssel aller Familienmitglieder zugewiesen werden.

\begin{Declaration}
  \Macro{DefineFamily}\Parameter{Familienname}
  \Macro{DefineFamilyMember}\OParameter{Mitglied}\Parameter{Familienname}
\end{Declaration}
\Package{scrbase} muss aus verschiedenen GrÃ¼nden die Mitglieder einer Familie
kennen. Daher ist es notwendig, eine neue Familie zunÃ¤chst mit
\Macro{DefineFamily} zu definieren und so eine leere Mitgliederliste zu
erzeugen. Ist die Familie bereits definiert, so geschieht schlicht nichts. Es
wird also auch nicht eine bereits existierende Mitgliederliste Ã¼berschrieben.

Ein neues Mitglied wird der Familie dann mit der Anweisung
\Macro{DefineFamilyMember} bekannt gegeben. Existiert die Familie nicht, so
fÃ¼hrt dies zu einer Fehlermeldung. Existiert das Mitglied bereits, so
geschieht nichts. Wird kein Mitglied angegeben, so bleibt das Mitglied nicht
etwa leer, sondern es wird
Â»\texttt{.}\Macro{@currname}\texttt{.}\Macro{@currext}Â« angenommen. WÃ¤hrend
des Ladens einer Klasse oder eines Pakets sind \Macro{@currname} und
\Macro{@currext} zusammen der Dateiname.

Theoretisch wÃ¤re es mÃ¶glich, mit einem leeren optionalen Argument
\PName{Mitglied} auch ein Mitglied ohne Name zu definieren. Dies wÃ¼rde jedoch
der Familie selbst entsprechen. Es wird empfohlen, als \PName{Familienname} nur
Buchstaben und Ziffern zu verwenden und das \PName{Mitglied} immer mit einem
anderen Zeichen, vorzugsweise einem Punkt, zu beginnen. Anderenfalls kÃ¶nnte
es passieren, dass sich Mitglieder einer Familie mit Mitgliedern anderer
Familien Ã¼berdecken.

\Package{scrbase} definiert selbst bereits die Familie Â»\PValue{KOMA}Â« und
fÃ¼gt ihr das Mitglied Â»\PValue{.scrbase.sty}Â« hinzu. GrundsÃ¤tzlich sind die
Familien Â»\PValue{KOMA}Â« und Â»\PValue{KOMAarg}Â« \KOMAScript{} vorbehalten. Es
wird empfohlen, fÃ¼r eigene Pakete den Namen des Gesamtpakets als Familie und
den Namen einzelner Pakete im Gesamtpaket als Mitglied zu verwenden.
%
\begin{Example}
  Angenommen, Sie schreiben ein neues Gesamtpaket Â»FleischermeisterÂ«. Darin
  befinden sich die Pakete \File{Salami.sty}, \File{Mettwurst.sty} und
  \File{Krakauer.sty}. Daher entscheiden Sie sich fÃ¼r den Familienname
  Â»\PValue{Fleischermeister}Â« und fÃ¼gen in jedem der Pakete die Zeilen
\begin{lstcode}
  \DefineFamily{Fleischermeister}
  \DefineFamilyMember{Fleischermeister}
\end{lstcode}
  ein. Dadurch wird beim Laden der drei genannten Pakete der Familie
  Â»\PValue{Fleischermeister}Â« je nach Paket eines der drei Mitglieder
  Â»\PValue{.Salami.sty}Â«, Â»\PValue{.Mettwurst.sty}Â« und
  Â»\PValue{.Krakauer.sty}Â« zugefÃ¼gt. Am Ende sind dann alle drei Mitglieder
  definiert.
\end{Example}
%
\EndIndexGroup
\ExampleEndFix


\begin{Declaration}
  \Macro{DefineFamilyKey}\OParameter{Mitglied}\Parameter{Familie}%
                         \Parameter{SchlÃ¼ssel}
                         \OParameter{SÃ¤umniswert}\Parameter{Aktion}
  \Macro{FamilyKeyState}
  \Macro{FamilyKeyStateUnknown}
  \Macro{FamilyKeyStateProcessed}
  \Macro{FamilyKeyStateUnknownValue}
  \Macro{FamilyKeyStateNeedValue}
\end{Declaration}
Mit dieser Anweisung wird ein \PName{SchlÃ¼ssel} definiert. Ist ein
\PName{Mitglied} angegeben, so ist der \PName{SchlÃ¼ssel} eine Eigenschaft
dieses Mitglieds der angegebenen \PName{Familie}. Ist\textnote{Hinweis}
\OParameter{Mitglied} nicht angegeben, so wird wieder das Mitglied
Â»\texttt{.}\Macro{@currname}\texttt{.}\Macro{@currext}Â« angenommen. Ist das
\PName{Mitglied} hingegen leer, so wird ein FamilienschlÃ¼ssel anstelle eines
MitgliederschlÃ¼ssels definiert.

Wird spÃ¤ter dem \PName{SchlÃ¼ssel} ein Wert zugewiesen, so wird \PName{Aktion}
ausgefÃ¼hrt, wobei der Wert als Parameter Ã¼bergeben wird. Innerhalb von
\PName{Aktion} steht also Â»\lstinline{#1}Â« fÃ¼r den Ã¼bergebenen Wert. Wurde
kein Wert Ã¼bergeben, so wird stattdessen der \PName{SÃ¤umniswert}
eingesetzt. Falls kein \PName{SÃ¤umniswert} angegeben wird, kann spÃ¤ter der
\PName{SchlÃ¼ssel} nur mit WertÃ¼bergabe verwendet werden.

%\begin{Explain}
  \phantomsection\label{explain:scrbase.macro.DefineFamilyKey}%
  Letztlich fÃ¼hrt
\begin{lstcode}[escapeinside=&gt;&lt;]
  \DefineFamilyKey[&gt;\PName{Mitglied}&lt;]{&gt;\PName{Familie}&lt;}{&gt;\PName{SchlÃ¼ssel}&lt;}
                  [&gt;\PName{SÃ¤umniswert}&lt;]{&gt;\PName{Aktion}&lt;}
\end{lstcode}
  zu dem Aufruf
\begin{lstcode}[moretexcs={define@key},escapeinside=&gt;&lt;]
  \define@key{&gt;\PName{Familie\,Mitglied}&lt;}{&gt;\PName{SchlÃ¼ssel}&lt;}
             [&gt;\PName{SÃ¤umniswert}&lt;]{&gt;\PName{erweiterte Aktion}&lt;}
\end{lstcode}
  wobei \Macro{define@key} im \Package{keyval}-Paket\IndexPackage{keyval}
  definiert ist (siehe \cite{package:keyval}). Allerdings kommen zu dem Aufruf
  von \Macro{define@key} noch einige zusÃ¤tzliche Vorkehrungen und auch die
  \PName{Aktion} wird automatisch um einige interne Aktionen erweitert.
%\end{Explain}

Erfolg\ChangedAt{v3.12}{\Package{scrbase}} oder Misserfolg der AusfÃ¼hrung
der \PName{Aktion} werden Ã¼ber \Macro{FamilyKeyState} an \Package{scrbase}
zurÃ¼ckgemeldet, damit dieses je nach Bedarf und Verwendung des SchlÃ¼ssels
weitere MaÃŸnahmen ergreifen kann. Das kann beispielsweise eine Fehlermeldung
aber auch nur die Signalisierung einer unbekannten Option sein.

Der Zustand\textnote{unbekannt} \Macro{FamilyKeyState} ist in der
Voreinstellung identisch mit dem Zustand \Macro{FamilyKeyStateUnknown}. Das
bedeutet, dass es nicht sicher ist, ob der SchlÃ¼ssel korrekt verarbeitet
werden konnte. Findet \Package{scrbase} nach AusfÃ¼hrung der \PName{Aktion}
noch immer diesen Zustand vor, so wird ein Hinweis in die \File{log}-Datei
geschrieben und im weiteren der Zustand \Macro{FamilyKeyStateProcessed}
angenommen.

Der Zustand\textnote{Erfolg} \Macro{FamilyKeyStateProcessed} signalisiert,
dass der SchlÃ¼ssel und die Wertzuweisung an den SchlÃ¼ssel vollstÃ¤ndig
abgeschlossen wurde und alles in Ordnung ist. Auf den Zustand kann einfach
durch Aufruf von \Macro{FamilyKeyStateProcessed} selbst umgeschaltet werden.

Der Zustand\textnote{unbekannter Wert} \Macro{FamilyKeyStateUnknownValue}
signalisiert, dass der SchlÃ¼ssel zwar verarbeitet wurde, ihm jedoch ein Wert
zugewiesen werden sollte, der nicht erlaubt ist. Diesen Zustand meldet
beispielsweise \hyperref[cha:typearea]{\Package{typearea}}, wenn versucht
wird, an Option \DescRef{typearea.option.twoside} den Wert \PValue{unbekannt}
zuzuweisen. Die Umschaltung auf den Zustand erfolgt einfach durch Aufruf von
\Macro{FamilyKeyStateUnknownValue} selbst.

Der Zustand\textnote{fehlender Wert}
\Macro{FamilyKeyStateNeedValue}
signalisiert, dass der SchlÃ¼ssel nicht verarbeitet werden konnte, weil er
zwingend einen Wert erwartet, er aber ohne Wertzuweisung aufgerufen
wurde. Dieser Zustand wird automatisch gesetzt, wenn ein SchlÃ¼ssel, der keinen
\PName{SÃ¤umniswert} besitzt, ohne Wertzuweisung verwendet wird. Theoretisch
wÃ¤re aber auch eine explizite Umschaltung darauf durch Aufruf von
\Macro{FamilyKeyStateNeedValue} selbst mÃ¶glich.

Des Weiteren kÃ¶nnen zusÃ¤tzliche\textnote{Fehler} FehlerzustÃ¤nde definiert
werden, indem man \Macro{FamilyKeyState} auf eine kurze Meldung
umdefiniert. In der Regel sollten jedoch die vier vordefinierten ZustÃ¤nde
verwendet werden.

\begin{Example}
  Nehmen wir an, jedes der drei Pakete aus dem letzten Beispiel soll einen
  SchlÃ¼ssel \PValue{Aufschnitt} erhalten. Wird dieser aufgerufen, so soll in
  jedem der Pakete entsprechend dem Aufrufwert ein Schalter gesetzt
  werden. FÃ¼r das Paket \Package{Salami} kÃ¶nnte das beispielsweise so
  aussehen:
\begin{lstcode}
  \newif\if@Salami@Aufschnitt
  \DefineFamilyKey{Fleischermeister}%
                  {Aufschnitt}[true]{%
    \expandafter\let
    \expandafter\if@Salami@Aufschnitt
    \csname if#1\endcsname
    \FamilyKeyStateProcessed
  }
\end{lstcode}
  Als Wert ist daher beim Aufruf \PValue{true} oder \PValue{false}
  erlaubt. Ein Test auf unerlaubte Werte existiert in diesem Beispiel
  nicht. Stattdessen wird immer zurÃ¼ckgemeldet, dass der SchlÃ¼ssel vollstÃ¤ndig
  und korrekt verarbeitet wurde. Wird der SchlÃ¼ssel spÃ¤ter verwendet, so muss
  entweder einer der erlaubten Werte zugewiesen oder ein Aufruf ohne
  Wertzuweisung verwendet werden. In letzterem Fall kommt der SÃ¤umniswert
  \PName{true} zum Einsatz.

  FÃ¼r die anderen beiden Pakete kann das fast identisch definiert
  werden. Lediglich die Zeichenfolge Â»\texttt{Salami}Â« ist jeweils zu
  ersetzen.
\end{Example}
%
\EndIndexGroup
\ExampleEndFix


\begin{Declaration}
  \Macro{RelaxFamilyKey}\OParameter{Mitglied}\Parameter{Familie}
                        \Parameter{SchlÃ¼ssel}
\end{Declaration}
Wurde\ChangedAt{v3.15}{\Package{scrbase}} zuvor \PName{SchlÃ¼ssel} fÃ¼r das
\PName{Mitglied} der \PName{Familie} definiert, so wird diese Definition
quasi aufgehoben. Der \PName{SchlÃ¼ssel} ist dann fÃ¼r dieses \PName{Mitglied}
der \PName{Familie} nicht mehr definiert. Die Verwendung fÃ¼r einen
\PName{SchlÃ¼ssel}, der fÃ¼r dieses \PName{Mitglied} der \PName{Familie} gar
nicht definiert ist, ist ebenfalls zulÃ¤ssig und bleibt wirkungslos.

Ist kein \PName{Mitglied} angegeben, so wird genau wie bei Anweisung
\DescRef{\LabelBase.cmd.DefineFamilyKey} wieder das Mitglied
Â»\texttt{.}\Macro{@currname}\texttt{.}\Macro{@currext}Â« angenommen. Allerdings
wird \Macro{RelaxFamilyKey} selten wÃ¤hrend des Ladens eines Pakets,
sondern hÃ¤ufiger zur Laufzeit verwendet. Daher ist \PName{Mitglied} in der
Regel auch explizit anzugeben.%
\EndIndexGroup


\begin{Declaration}
  \Macro{FamilyProcessOptions}\OParameter{Mitglied}\Parameter{Familie}
\end{Declaration}
GrundsÃ¤tzlich ist die Erweiterung der SchlÃ¼ssel von Familien auf Familien und
Familienmitglieder dazu gedacht, dass SchlÃ¼ssel beziehungsweise die
Wertzuweisung an SchlÃ¼ssel als ganz normale Klassen- oder Paketoptionen
verwendet werden kÃ¶nnen. Diese Anweisung stellt daher eine Erweiterung von
\Macro{ProcessOptions*}\IndexCmd{ProcessOptions*}%
\important{\Macro{ProcessOption*}} aus dem \LaTeX-Kern dar (siehe
\cite{latex:clsguide}). Dabei verarbeitet die Anweisung nicht nur Optionen,
die mit \Macro{DeclareOption}\IndexCmd{DeclareOption}%
\important{\Macro{DeclareOption}} definiert wurden. Es werden auch alle
SchlÃ¼ssel eines angegebenen Familienmitglieds abgearbeitet. Wird das optionale
Argument \PName{Mitglied} nicht angegeben, so wird wieder das Mitglied
Â»\texttt{.}\Macro{@currname}\texttt{.}\Macro{@currext}Â« verwendet.

Eine Besonderheit sind SchlÃ¼ssel, die nicht einem Familienmitglied, sondern
der Familie selbst zugeordnet sind, bei der also das Mitglied leer geblieben
ist. Diese werden ebenfalls gesetzt und zwar noch bevor der SchlÃ¼ssel des
Mitglieds gesetzt wird.
\begin{Example}
  Wenn in den Paketen aus den zurÃ¼ckliegenden Beispielen nach der Definition
  der SchlÃ¼ssel die Zeile
\begin{lstcode}
  \FamilyProcessOptions{Fleischermeister}
\end{lstcode}
  ergÃ¤nzt wird, so kann der Anwender bereits beim Laden der Pakete mit
  \Macro{usepackage} die Eigenschaft \Option{Aufschnitt} als Option
  angeben. Wird die Option bei \Macro{documentclass} und damit global
  angegeben, so wird die Eigenschaft automatisch bei allen drei Paketen
  gesetzt, wenn alle drei Pakete einzeln geladen werden.
\end{Example}
Es\textnote{Achtung!} wird darauf hingewiesen, dass bei Paketen globale
Optionen vor den lokal dem Paket zugewiesenen Optionen ausgefÃ¼hrt
werden. WÃ¤hrend bei der Abarbeitung der globalen Optionen unbekannte Werte fÃ¼r
Optionen dazu fÃ¼hren, dass darÃ¼ber lediglich in der \File{log}-Datei
informiert und die Option ansonsten ignoriert wird, fÃ¼hrt dies bei lokalen
Optionen zu einer Fehlermeldung.

Man kann \Macro{FamilyProcessOptions} wahlweise als Erweiterung von
\Macro{ProcessOption*} oder als Erweiterung des
\PName{SchlÃ¼ssel=Wert}-Mechanismus von \Package{keyval} verstehen. Letztlich
werden mit Hilfe von \Macro{FamilyProcessOptions} aus
\PName{SchlÃ¼ssel=Wert}-Paaren Optionen.

Wie\textnote{Achtung!} auch \Macro{ProcessOptions} darf
\Macro{FamilyProcessOptions} nicht wÃ¤hrend der AusfÃ¼hrung von Optionen
verwendet werden. Es ist also insbesondere auch nicht erlaubt, innerhalb der
AusfÃ¼hrung von Optionen Pakete zu laden.%, die selbst
%\Macro{FamilyProcessOptions} verwenden.%
%
\EndIndexGroup


\begin{Declaration}
  \Macro{BeforeFamilyProcessOptions}\OParameter{Mitglied}\Parameter{Familie}%
                                    \Parameter{Code}%
\end{Declaration}
Insbesondere\ChangedAt{v3.18}{\Package{scrbase}} Autoren von Wrapper-Klassen
wÃ¼nschen manchmal, in ein Paket oder eine Klasse noch vor der Verarbeitung der
Optionen eines zukÃ¼nftig geladenen Pakets oder einer zukÃ¼nftig geladenen
Klasse mit \DescRef{\LabelBase.cmd.FamilyProcessOptions} eingreifen zu
kÃ¶nnen. Dies ist mit \Macro{BeforeFamilyProcessOptions} mÃ¶glich. Das Paket
\Package{scrbase} bietet dafÃ¼r einen sogenannten Haken\Index{Haken}
(engl. \emph{hook}). Diesem kann man mit \Macro{BeforeFamilyProcessOptions}
neuen \PName{Code} hinzufÃ¼gen. Die Parameter \PName{Mitglied} und
\PName{Familie} entsprechen dabei denen von
\Macro{FammilyProcessOptions}. Allerdings kann man auch den Haken von
Familien-Mitgliedern \PName{Code} hinzufÃ¼gen, wenn bisher die \PName{Familie}
oder das \PName{Mitglied} noch gar nicht definiert ist.

Der Haken eines Familien-Mitglieds wird Ã¼brigens nach dessen AusfÃ¼hrung
automatisch gelÃ¶scht. Verwendet man hingegen ein leeres \PName{Mitglied}, so
wird dieser Haken\Index{Haken} fÃ¼r alle Mitglieder der \PName{Familie}
ausgefÃ¼hrt und bleibt auch Ã¼ber die AusfÃ¼hrung hinaus erhalten.

\begin{Example}
  Sie schreiben ein Paket \Package{Rauchwurst}, das selbst \Package{Mettwurst}
  lÃ¤dt. Allerdings wollen Sie nicht, dass fÃ¼r dieses Paket die Option
  \Option{Aufschnitt} gesetzt werden kann. Daher deaktivieren sie die Option
  vor dem Laden des Pakets Ã¼ber \Macro{BeforeFamilyProcessOptions}.
\begin{lstcode}
  \RequirePackage{scrbase}
  \BeforeFamilyProcessOptions[.Mettwurst.sty]%
                             {Fleischermeister}{%
    \RelaxFamilyKey[.Mettwurst.sty]%
                   {Fleischermeister}{Aufschnitt}%
  }
  \RequirePackageWithOptions{Mettwurst}
\end{lstcode}
  Versucht nun jemand Ihr Paket mit Option
  \Option{Aufschnitt} zu laden, so meldet das Paket \Package{Mettwurst}, dass
  diese Option nicht bekannt ist. Wird die Option \Option{Aufschnitt} als
  globale Option angegeben, so ignoriert Paket \Package{Mettwurst}
  diese. Voreinstellungen innerhalb des Pakets \Package{Mettwurst}, die
  beispielsweise mit \DescRef{\LabelBase.cmd.FamilyExecuteOptions} noch vor
  \DescRef{\LabelBase.cmd.FamilyProcessOptions} erfolgen kÃ¶nnten, wÃ¤ren
  allerdings davon unabhÃ¤ngig. Aber natÃ¼rlich kann man eigene
  Voreinstellungen von \Package{Rauchwurst} aus ebenfalls per
  \Macro{BeforeFamilyProcessOptions} in \Package{Mettwurst} einschleusen.%
\end{Example}
\EndIndexGroup
\ExampleEndFix


\begin{Declaration}
  \Macro{FamilyExecuteOptions}\OParameter{Mitglied}\Parameter{Familie}%
                              \Parameter{Optionenliste}
\end{Declaration}
Diese Anweisung stellt eine Erweiterung von
\Macro{ExecuteOptions} aus dem \LaTeX-Kern dar (siehe
\cite{latex:clsguide}). Dabei verarbeitet die Anweisung nicht nur Optionen,
die mit \Macro{DeclareOption} definiert wurden. Es werden auch alle SchlÃ¼ssel
eines angegebenen Familienmitglieds abgearbeitet. Wird das optionale Argument
\PName{Mitglied} nicht angegeben, so wird wieder das Mitglied
Â»\texttt{.}\Macro{@currname}\texttt{.}\Macro{@currext}Â« verwendet.

Eine Besonderheit sind SchlÃ¼ssel, die nicht einem Familienmitglied, sondern
der Familie selbst zugeordnet sind, bei der also das Mitglied leer geblieben
ist. Diese werden ebenfalls gesetzt, und zwar noch bevor der SchlÃ¼ssel des
Mitglieds gesetzt wird.
\begin{Example}
  Angenommen, die Option \Option{Aufschnitt} soll in den zurÃ¼ckliegenden
  Beispielen bereits als Voreinstellung gesetzt werden, so mÃ¼ssen die Pakete
  nur um den Aufruf
\begin{lstcode}
  \FamilyExecuteOptions{Fleischermeister}
                       {Aufschnitt}
\end{lstcode}
  ergÃ¤nzt werden.
\end{Example}

Wird\ChangedAt{v3.20}{\Package{scrbase}} \Macro{FamilyExecuteOptions} mit
einer nicht definierten Option in der \PName{Optionenliste} aufgerufen, so
wird normalerweise ein Fehler ausgegeben. Eine Ausnahme von dieser Regel ist,
wenn fÃ¼r das \PName{Mitglied} eine Option namens
\Option{@else@}\important{\Option{@else@}} definiert wurde. In diesem Fall
wird statt der unbekannten Option eben diese Option \Option{@else@}
verwendet. Der an \Option{@else@} Ã¼bergebene Wert ist dabei die nicht
definierte Option mit dem im Aufruf angegebenen Wert.  Innerhalb von
\KOMAScript{} wird das beispielsweise genutzt, um die Stil-Option bei der
Definition von Gliederungsbefehlen vor allen anderen auszuwerten.

Diese Anweisung darf auch innerhalb der AusfÃ¼hrung von Optionen verwendet
werden.%
%
\EndIndexGroup


\begin{Declaration}
  \Macro{FamilyOptions}\Parameter{Familie}\Parameter{Optionenliste}%
\end{Declaration}
Im Gegensatz zu normalen Optionen, die mit \Macro{DeclareOption} definiert
wurden, kÃ¶nnen die \PName{SchlÃ¼ssel} auch noch nach dem Laden der Klasse oder
des Pakets gesetzt werden. Dazu verwendet der Anwender
\Macro{FamilyOptions}. Die \PName{Optionenliste} hat dabei die Form:
%\begin{flushleft}\begin{tabular}{l}
    \PName{SchlÃ¼ssel}\texttt{=}\PName{Wert}\texttt{,}\linebreak[1]%
    \PName{SchlÃ¼ssel}\texttt{=}\PName{Wert} \dots{},
%\end{tabular}\vskip\dp\strutbox\end{flushleft}
wobei fÃ¼r \PName{SchlÃ¼ssel}, fÃ¼r die ein SÃ¤umniswert definiert ist, die
Wertzuweisung natÃ¼rlich auch entfallen kann.

Durch die Anweisung werden die \PName{SchlÃ¼ssel} aller Mitglieder der
angegebenen \PName{Familie} gesetzt. Existiert ein \PName{SchlÃ¼ssel} auch als
Eigenschaft der Familie selbst, so wird dieser Familien-SchlÃ¼ssel zuerst
gesetzt. Danach folgen die Mitglieder-SchlÃ¼ssel in der Reihenfolge, in der die
Mitglieder definiert wurden. Existiert ein angegebener \PName{SchlÃ¼ssel} weder
fÃ¼r die Familie noch fÃ¼r ein Mitglied der Familie, so wird von
\Macro{FamilyOptions} ein Fehler ausgegeben. Dies geschieht ebenfalls, wenn
zwar fÃ¼r einige Mitglieder ein SchlÃ¼ssel existiert, jedoch jedes dieser
Mitglieder Ã¼ber \DescRef{\LabelBase.cmd.FamilyKeyState} einen Fehler
zurÃ¼ckmeldet.
\begin{Example}
  Sie ergÃ¤nzen das Fleischermeister-Projekt um ein weiteres Paket
  \Package{Wurstsalat}. Wird dieses Paket verwendet, so sollen alle
  Wurstpakete zunÃ¤chst einmal Aufschnitt produzieren:
\begin{lstcode}
  \ProvidesPackage{Wurstsalat}%
                  [2008/05/06 nonsense package]
  \RequirePackage{scrbase}
  \DefineFamily{Fleischermeister}
  \DefineFamilyMember{Fleischermeister}
  \FamilyProcessOptions{Fleischermeister}\relax
  \FamilyOptions{Fleischermeister}{Aufschnitt}
\end{lstcode}
  Sollte noch kein Wurstpaket geladen sein, so wÃ¼rde nun eine Fehlermeldung
  wegen der nicht definierten Option Â»\Option{Aufschnitt}Â« ausgegeben. Das
  kann vermieden werden, indem vor der letzten Zeile fÃ¼r das Paket selbst
  ebenfalls ein entsprechender SchlÃ¼ssel definiert wird:
\begin{lstcode}
  \DefineFamilyKey{Fleischermeister}%
                  {Aufschnitt}[true]{}%
\end{lstcode}
  Allerdings produzieren so Wurstpakete, die nach Paket
  \Package{Wurstsalat} geladen werden, keinen Aufschnitt. Dies kann man
  ebenfalls Ã¤ndern:
\begin{lstcode}
  \AtBeginDocument{%
    \DefineFamilyKey[.Wurstsalat.sty]%
                    {Fleischermeister}%
                    {Aufschnitt}[true]{}%
  }
  \DefineFamilyKey{Fleischermeister}%
                  {Aufschnitt}[true]{%
    \AtBeginDocument{%
      \FamilyOptions{Fleischermeister}%
                    {Aufschnitt=#1}%
    }%
  }%
\end{lstcode}
  Somit wird zunÃ¤chst wÃ¤hrend \Macro{begin}\PParameter{document} die Option so
  definiert, dass sie fÃ¼r das Paket \Package{Wurstsalat} keine Funktion mehr
  ausÃ¼bt. Da nach dem Laden von \Package{Wurstsalat}, innerhalb von
  \Macro{begin}\PParameter{document} die beiden Anweisungen \Macro{@currname}
  und \Macro{@currext} nicht mehr den Dateinamen des Pakets enthalten, muss
  zwingend das optionale Argument von \DescRef{\LabelBase.cmd.DefineFamilyKey}
  verwendet werden.

  Bis zu dieser Umdefinierung der Option wird jedoch eine Definition
  verwendet, die wÃ¤hrend \Macro{begin}\PParameter{document} die Option erneut
  fÃ¼r die Familie und all ihre Mitglieder ausfÃ¼hrt und damit auch fÃ¼r andere
  Wurstpakete setzt. Die VerzÃ¶gerung der AusfÃ¼hrung von \Macro{FamilyOptions}
  ist hier entscheidend. Zum einen werden nur so spÃ¤ter geladene Wurstpakete
  erfasst. Zum anderen wird dadurch sichergestellt, dass die eigene Option
  \Option{Aufschnitt} bereits umdefiniert wurde. Dadurch wird eine endlose
  Rekursion vermieden.%
\end{Example}%

FÃ¼r\ChangedAt{v3.27}{\Package{scrbase}} die Option Namens
\Option{@else@}\important{\Option{@else}} existiert Ã¤hnlich wie bei Anweisung
\DescRef{\LabelBase.cmd.FamilyExecuteOptions} eine Sonderbehandlung. Ist eine
solche fÃ¼r ein Mitglied definiert, so wird sie immer dann ausgefÃ¼hrt, wenn das
Mitglied eine angegebene Option nicht kennt. Ist fÃ¼r die Familie selbst eine
Option \Option{@else@} definiert, so wird sie nur aufgerufen, wenn weder die
Familie noch eines ihrer Mitglieder eine angegebene Option vollstÃ¤ndig
verarbeiten konnte und mit \DescRef{\LabelBase.cmd.FamilyKeyStateProcessed}
quitiert hat.%
\EndIndexGroup


\begin{Declaration}
  \Macro{FamilyOption}\Parameter{Familie}%
                      \Parameter{Option}\Parameter{Werteliste}%
\end{Declaration}
Neben Optionen, die sich gegenseitig ausschlieÃŸende Werte besitzen, kann es
auch Optionen geben, die gleichzeitig mehrere Werte annehmen kÃ¶nnen. FÃ¼r diese
wÃ¤re es bei Verwendung von \DescRef{\LabelBase.cmd.FamilyOptions} notwendig,
der Option mehrfach einen Wert zuzuweisen und dabei die Option selbst mehrfach
anzugeben. Stattdessen kann man einfach mit \Macro{FamilyOption} einer
einzigen \PName{Option} eine ganze \PName{Werteliste} zuweisen. Die
\PName{Werteliste} ist dabei eine durch Komma separierte Liste von Werten:
%\begin{flushleft}\begin{tabular}{l}
    \PName{Wert}\texttt{,}\PName{Wert} \dots{}
%\end{tabular}\end{flushleft}
In diesem Zusammenhang sei darauf hingewiesen, dass die Verwendung eines
Kommas in einem Wert mÃ¶glich ist, wenn man den Wert in geschweifte Klammern
setzt. Die weitere Funktionsweise ist der vorhergehenden ErklÃ¤rung zu
\DescRef{\LabelBase.cmd.FamilyOptions} zu entnehmen.
\begin{Example}
  Das Paket \Package{Wurstsalat} soll eine Option bekommen, Ã¼ber die man
  weitere Zutaten bestimmen kann. FÃ¼r jede Zutat wird dabei wieder ein
  Schalter gesetzt.
\begin{lstcode}
  \newif\if@salatmit@Zwiebeln
  \newif\if@salatmit@Gurken
  \newif\if@salatmit@Peperoni
  \DefineFamilyKey{Fleischermeister}{SalatZusatz}{%
    \csname @salatmit@#1true\endcsname
  }
\end{lstcode}
  Es wurden hier die drei Zutaten Â»ZwiebelnÂ«, Â»GurkenÂ« und Â»PeperoniÂ«
  definiert. Eine Fehlerbehandlung fÃ¼r den Fall, dass der Anwender unbekannte
  Zutaten fordert, existiert nicht.

  FÃ¼r einen Salat mit Zwiebeln und Gurken kann der Anwender
\begin{lstcode}
  \FamilyOptions{Fleischermeister}{%
    SalatZusatz=Zwiebeln,SalatZusatz=Gurken}
\end{lstcode}
  oder einfach
\begin{lstcode}
  \FamilyOption{Fleischermeister}%
               {SalatZusatz}{Zwiebeln,Gurken}
\end{lstcode}
  verwenden.
\end{Example}

\iffalse% Umbruchkorrektur
Die\ChangedAt{v3.27}{\Package{scrbase}} Verarbeitung einer Option
\Option{@else@} findet in derselben Weise statt wie bei
\DescRef{\LabelBase.cmd.FamilyOptions}.%
\else%
Intern basiert \Macro{FamilyOption} auf
\DescRef{\LabelBase.cmd.FamilyOptions}.
Die\ChangedAt{v3.27}{\Package{scrbase}} Verarbeitung einer Option
\Option{@else@} findet daher in gleicher Weise statt.%
\fi%
\EndIndexGroup


\begin{Declaration}
  \Macro{AtEndOfFamilyOptions}\Parameter{Aktion}%
  \Macro{AtEndOfFamilyOptions*}\Parameter{Aktion}%
\end{Declaration}
Manchmal\ChangedAt{v3.12}{\Package{scrbase}} ist es vorteilhafter, wenn nicht
jede Wertzuweisung an eine Option unmittelbar eine \PName{Aktion} auslÃ¶st,
sondern dies erst geschieht, wenn alle Wertzuweisungen innerhalb eines Aufrufs
von
\DescRef{\LabelBase.cmd.FamilyProcessOptions}\IndexCmd{FamilyProcessOptions}
oder
\DescRef{\LabelBase.cmd.FamilyExecuteOptions}\IndexCmd{FamilyExecuteOptions}
respektive \DescRef{\LabelBase.cmd.FamilyOptions}\IndexCmd{FamilyOptions} oder
\DescRef{\LabelBase.cmd.FamilyOption}\IndexCmd{FamilyOptions} abgeschlossen
sind. Genau das ist mit Hilfe von \Macro{AtEndOfFamilyOptions} und der
zugehÃ¶rigen Sternvariante\ChangedAt{v3.23}{\Package{scrbase}} mÃ¶glich. Die
RÃ¼ckmeldung von FehlerzustÃ¤nden ist Ã¼ber die Anweisungen jedoch ebenso wenig
mÃ¶glich wie die Verwendung der Anweisungen auÃŸerhalb der AusfÃ¼hrung von
Optionen.

Die beiden Varianten unterscheiden sich im Falle von verschachtelt definierten
Optionen, wenn also die AusfÃ¼hrung einer Option den Aufruf einer oder mehrerer
anderer Optionen bedingt. In diesem Fall werden alle per
\Macro{AtEndOfFamilyOptions} festgelegten Aktionen ausgefÃ¼hrt, sobald der
innerste Optionenaufruf endet. Dagegen werden die per
\Macro{AtEndOfFamilyOptions*} festgelegten Aktionen erst mit dem Ende des
Ã¤uÃŸersten Optionenaufrufs ausgefÃ¼hrt. Die Reihenfolge\textnote{Achtung!} der
Aktionen ist dabei jedoch ausdrÃ¼cklich unbestimmt! Weder ist sichergestellt,
dass zuerst angeforderte Aktionen auch zuerst ausgefÃ¼hrt werden, noch die
umgekehrte Reihenfolge.%
\EndIndexGroup


\begin{Declaration}
  \Macro{FamilyBoolKey}\OParameter{Mitglied}\Parameter{Familie}
                       \Parameter{SchlÃ¼ssel}\Parameter{Schaltername}
  \Macro{FamilySetBool}\Parameter{Familie}
                       \Parameter{SchlÃ¼ssel}\Parameter{Schaltername}
                       \Parameter{Wert}
\end{Declaration}
In den vorherigen Beispielen wurden schon mehrfach Schalter gesetzt. Im
Beispiel der Option \Option{Aufschnitt} war es dabei notwendig, dass der
Anwender als Wert \PValue{true} oder \PValue{false} angibt. Es existierte
keine Fehlerbehandlung, falls der Anwender einen falschen Wert verwendet. Da
solche booleschen Schalter ein hÃ¤ufiger Anwendungsfall sind, kann man sie bei
\Package{scrbase} einfach mit \Macro{FamilyBoolKey} definieren. Dabei sind die
Argumente \PName{Mitglied}, \PName{Familie} und \PName{SchlÃ¼ssel} die gleichen
wie bei \DescRef{\LabelBase.cmd.DefineFamilyKey} (siehe
\DescPageRef{scrbase.cmd.DefineFamilyKey}). Das Argument \PName{Schaltername}
ist der Name eines Schalter ohne den PrÃ¤fix \Macro{if}. Existiert dieser
Schalter noch nicht, so wird er automatisch definiert und mit \PName{false}
voreingestellt. Intern verwendet \Macro{FamilyBoolKey} dann
\Macro{FamilySetBool} als \PName{Aktion} fÃ¼r
\DescRef{\LabelBase.cmd.DefineFamilyKey}. Der SÃ¤umniswert fÃ¼r eine solche
Option ist immer \PValue{true}.

\Macro{FamilySetBool} wiederum versteht als \PName{Wert} neben \PValue{true}
auch die Werte \PValue{on} und \PValue{yes} zum Einschalten und neben
\PValue{false} auch die Werte \PValue{off} und \PValue{no} zum
Ausschalten. Wird ein unbekannter Wert Ã¼bergeben, so wird die auf
\DescPageRef{\LabelBase.cmd.FamilyUnknownKeyValue} erklÃ¤rte Anweisung
\DescRef{\LabelBase.cmd.FamilyUnknownKeyValue} aufgerufen und so
\DescRef{\LabelBase.cmd.FamilyKeyState} (siehe
\DescPageRef{\LabelBase.cmd.FamilyKeyState}) entsprechend gesetzt. Dadurch
kann dann gegebenenfalls eine Meldung Ã¼ber eine unbekannte Wertzuweisung
ausgegeben werden.%
\begin{Example}
  Der SchlÃ¼ssel \Option{Aufschnitt} soll in den Wurstpaketen etwas robuster
  definiert werden, so dass Fehleingaben erkannt und behandelt
  werden. AuÃŸerdem sollen alle Wurstpakete denselben Schalter
  verwenden, so dass entweder alle Wurstpakete Aufschnitt produzieren oder
  keines.
\begin{lstcode}
  \FamilyBoolKey{Fleischermeister}{Aufschnitt}%
                                  {@Aufschnitt}
\end{lstcode}
  Ein Test, ob Aufschnitt produziert wird, sÃ¤he dann so aus:
\begin{lstcode}
  \if@Aufschnitt
     ...
  \else
     ...
  \fi
\end{lstcode}
  Dies wÃ¤re in allen drei Wurstpaketen identisch. Damit kÃ¶nnte man
  prinzipiell die Eigenschaft Â»AufschnittÂ« auch als Eigenschaft der Familie
  definieren:
\begin{lstcode}[moretexcs={define@key}]
  \@ifundefined{if@Aufschnitt}{%
    \expandafter\newif
    \csname if@Aufschnitt\endcsname
  }{}%
  \DefineFamilyKey[]{Fleischermeister}%
                    {Aufschnitt}[true]{%
    \FamilySetBool{Fleischermeister}%
                  {Aufschnitt}%
                  {@Aufschnitt}%
                  {#1}%
  }
\end{lstcode}
  oder einfacher
\begin{lstcode}
  \FamilyBoolKey[]{Fleischermeister}%
                  {Aufschnitt}%
                  {@Aufschnitt}
\end{lstcode}
  unter Ausnutzung des Hinweises bezÃ¼glich leerer Mitglieder
  \iftrue% Umbruchkorrekturtext
  im Gegensatz zum Weglassen des optionalen Arguments
  \fi%
  auf \autopageref{explain:scrbase.macro.DefineFamilyKey}, der nicht nur fÃ¼r
  \DescRef{\LabelBase.cmd.DefineFamilyKey}, sondern entsprechend auch fÃ¼r
  \Macro{FamilyBoolKey} gilt.

  Da \DescRef{\LabelBase.cmd.FamilyKeyState} bereits von \Macro{FamilySetBool}
  gesetzt wird, kann innerhalb der Definition der Option mit Hilfe von
  \DescRef{\LabelBase.cmd.DefineFamilyKey} der Status gegebenenfalls auch
  abgefragt werden. So kÃ¶nnte man im ersten Fall beispielsweise nach
  \Macro{FamilySetBool} einen Test der Art:
\begin{lstcode}
  \ifx\FamilyKeyState\FamilyKeyStateProcessed
      ...
  \else
      ...
  \fi   
\end{lstcode}
  ergÃ¤nzen, um zusÃ¤tzliche Aktionen in AbhÃ¤ngigkeit davon, ob
  \Macro{FamilySetBool} erfolgreich war oder nicht,
  auszufÃ¼hren. Es\textnote{Achtung!} ist zu beachten, dass an dieser Stelle
  unbedingt ein Test mit Hilfe von \Macro{ifx} vorzunehmen ist. Expandierende
  Tests wie \DescRef{\LabelBase.cmd.Ifstr} sind hier zu vermeiden. Sie kÃ¶nnen
  abhÃ¤ngig vom aktuellen Status und dem Vergleichszustand zu unterschiedlichen
  Fehlermeldungen und auch zu falschen Ergebnissen fÃ¼hren.%
\end{Example}%
\EndIndexGroup
\ExampleEndFix


\begin{Declaration}
  \Macro{FamilyInverseBoolKey}\OParameter{Mitglied}\Parameter{Familie}
                              \Parameter{SchlÃ¼ssel}\Parameter{Schaltername}
  \Macro{FamilySetInverseBool}\Parameter{Familie}
                              \Parameter{SchlÃ¼ssel}\Parameter{Schaltername}
                              \Parameter{Wert}
\end{Declaration}%
Diese\ChangedAt{v3.27}{\Package{scrbase}} beiden Anweisungen unterscheiden
sich von \DescRef{\LabelBase.cmd.FamilyBoolKey} beziehungsweise
\DescRef{\LabelBase.cmd.FamilySetBool} nur dadurch, dass die Logik invertiert
wird. Das heiÃŸt, dass die Werte \PValue{true}, \PValue{yes} und \PValue{on}
den durch \PName{Schaltername} angegebenen Schalter auf \Macro{iffalse} setzen
und damit deaktivieren, wÃ¤hrend \PValue{false}, \PValue{no} und \PValue{off}
ihn zu \Macro{iftrue} werden lassen, also aktivieren.%
\EndIndexGroup

\begin{Declaration}
  \Macro{FamilyNumericalKey}\OParameter{Mitglied}\Parameter{Familie}
                            \Parameter{SchlÃ¼ssel}
                            \OParameter{SÃ¤umniswert}\Parameter{Makroname}%
                            \Parameter{Werteliste}
  \Macro{FamilySetNumerical}\Parameter{Familie}\Parameter{SchlÃ¼ssel}
                            \Parameter{Makroname}\Parameter{Werteliste}%
                            \Parameter{Wert}
\end{Declaration}
WÃ¤hrend Schalter nur zwei Werte annehmen kÃ¶nnen, gibt es auch SchlÃ¼ssel, die
mehrere Werte kennen. So kann beispielsweise eine Ausrichtung nicht nur
entweder links oder nicht links, sondern auch links, mittig oder rechts
sein. Intern unterscheidet man solche Einstellungen dann gerne mit Hilfe von
\Macro{ifcase}\IndexCmd{ifcase}. Diese \TeX-Anweisung erwartet wiederum einen
numerischen Wert. Daher heiÃŸt bei \Package{scrbase} die Anweisung, mit der
man via \PName{SchlÃ¼ssel} einem Makro eine Definition zuweisen kann,
entsprechend \Macro{FamilyNumericalKey}.

Die \PName{Werteliste} hat dabei die Form:
%\begin{flushleft}\vskip\dp\strutbox\begin{tabular}{l}
    \Parameter{Wert}\Parameter{Definition}\texttt{,}\linebreak[1]%
    \Parameter{Wert}\Parameter{Definition}~\dots{}
%\end{tabular}\vskip\dp\strutbox\end{flushleft}
Ãœber diese \PName{Werteliste} werden so nicht nur die erlaubten Werte fÃ¼r den
\PName{SchlÃ¼ssel} angegeben. FÃ¼r jeden erlaubten \PName{Wert} wird auch
gleich angegeben, wie bei Verwendung desselben das Makro
\Macro{\PName{Makroname}} definiert werden soll. Ãœblicherweise werden als
\PName{Definition} schlicht Zahlenwerte angegeben. Es sind zwar auch andere
Angaben mÃ¶glich, derzeit gibt es aber die EinschrÃ¤nkung, dass
\PName{Definition} voll expandierbar sein muss und bei der Zuweisung auch
expandiert wird.
\begin{Example}
  Die Wurst fÃ¼r den Wurstsalat kann unterschiedlich geschnitten werden. So
  wÃ¤re es denkbar, dass der Aufschnitt einfach ungeschnitten bleibt oder in
  grobe oder feine Streifen geschnitten werden soll. Diese Information soll in
  der Anweisung \Macro{Schnitt} gespeichert werden.
\begin{lstcode}
  \FamilyNumericalKey{Fleischermeister}%
                     {SalatSchnitt}{Schnitt}{%
                       {Kein}{Kein},{Nein}{Kein},%
                       {Grob}{Grob},%
                       {Fein}{Fein}%
                     }
\end{lstcode}
  Dass nicht geschnitten werden soll, kann in diesem Fall vom Anwender sowohl
  mit
\begin{lstcode}
  \FamilyOptions{Fleischermeister}{SalatSchnitt=Kein}
\end{lstcode}
  als auch mit
\begin{lstcode}
  \FamilyOptions{Fleischermeister}{SalatSchnitt=Nein}
\end{lstcode}
  angegeben werden. In beiden FÃ¤llen wÃ¼rde \Macro{Schnitt} mit dem Inhalt
  \PValue{Kein} definiert. Es kann durchaus sinnvoll sein, dem Anwender wie in
  diesem Beispiel mehrere Werte fÃ¼r denselben Zweck anzubieten.

  Nun ist es sehr wahrscheinlich, dass die Schnittart nicht ausgegeben,
  sondern spÃ¤ter ausgewertet werden soll. In diesem Fall sind die textuellen
  Definitionen aber eher unpraktisch. Definiert man den SchlÃ¼ssel hingegen als
\begin{lstcode}
  \FamilyNumericalKey{Fleischermeister}%
                     {SalatSchnitt}{Schnitt}{%
                       {Kein}{0},{Nein}{0},%
                       {Grob}{1},%
                       {Fein}{2}%
                     }
\end{lstcode}
  so kann spÃ¤ter einfach in der Form
\begin{lstcode}
  \ifcase\Schnitt
    % ungeschnitten
  \or
    % grob geschnitten
  \else
    % fein geschnitten
  \fi
\end{lstcode}
  unterschieden werden.
\end{Example}

Intern wird von \Macro{FamilyNumericalKey} dann
\DescRef{\LabelBase.cmd.DefineFamilyKey} mit der Anweisung
\Macro{FamilySetNumerical} verwendet. Wird an einen solchen SchlÃ¼ssel ein
unbekannter Wert Ã¼bergeben, so wird von \Macro{FamilySetNumerical} Anweisung
\DescRef{\LabelBase.cmd.FamilyUnknownKeyValue} (siehe
\DescPageRef{\LabelBase.cmd.FamilyUnknownKeyValue}) aufgerufen. Dies fÃ¼hrt zu
einer Fehlersignalisierung, indem \DescRef{\LabelBase.cmd.FamilyKeyState} den
Status \DescRef{\LabelBase.cmd.FamilyKeyStateUnknownValue} annimmt (siehe
\DescPageRef{\LabelBase.cmd.FamilyKeyStateUnknownValue}). Daraus resultiert
beispielsweise bei der Verwendung als lokale Option dann eine
Fehlermeldung. Ebenso wird beim Aufruf von \Macro{FamilySetNumerical} auch der
Erfolg via \DescRef{\LabelBase.cmd.FamilyKeyStateProcessed} in
\DescRef{\LabelBase.cmd.FamilyKeyState} signalisiert.%
%
\EndIndexGroup


\begin{Declaration}
  \Macro{FamilyCounterKey}\OParameter{Mitglied}\Parameter{Familie}
                          \Parameter{SchlÃ¼ssel}
                          \OParameter{SÃ¤umniswert}\Parameter{\LaTeX-ZÃ¤hler}
  \Macro{FamilySetCounter}\Parameter{Familie}
                          \Parameter{SchlÃ¼ssel}\Parameter{\LaTeX-ZÃ¤hler}
                          \Parameter{Wert}
\end{Declaration}
WÃ¤hrend\ChangedAt{v3.12}{\Package{scrbase}} bei
\DescRef{\LabelBase.cmd.FamilyNumericalKey} ein Makro aufgrund eines
symbolischen Wertes auf einen korrespondierenden numerischen Wert
gesetzt wurde, gibt es natÃ¼rlich auch FÃ¤lle, in denen ein \PName{SchlÃ¼ssel}
direkt einen \PName{\LaTeX-ZÃ¤hler} reprÃ¤sentiert, dem unmittelbar ein
numerischer \PName{Wert} zugewiesen werden soll. Dazu dient die Anweisung
\Macro{FamilyCounterKey}, von der intern dann \Macro{FamilySetCounter}
aufgerufen wird. Dabei finden einige grundlegende PrÃ¼fungen des
\PName{Wert}-Arguments statt um festzustellen, ob dieses Argument fÃ¼r eine
Zuweisung an einen ZÃ¤hler in Frage kommt. Die Zuweisung findet nur statt, wenn
diese PrÃ¼fungen gelingen. Allerdings kÃ¶nnen hier nicht alle Fehler erkannt
werden, so dass eine falsche Zuweisung auch zu einer Fehlermeldung von \TeX{}
selbst fÃ¼hren kann. Erkannte Fehler werden hingegen Ã¼ber
\DescRef{\LabelBase.cmd.FamilyKeyStateUnknownValue} signalisiert.

Wurde\ChangedAt{v3.15}{\Package{scrbase}} kein Wert Ã¼bergeben, so wird
stattdessen der \PName{SÃ¤umniswert} eingesetzt. Falls kein \PName{SÃ¤umniswert}
angegeben wird, kann spÃ¤ter der \PName{SchlÃ¼ssel} nur mit WertÃ¼bergabe
verwendet werden.%
\iffalse% Umbruchkorrekturtext
\ Anderenfalls wir mit
\DescRef{\LabelBase.cmd.FamilyKeyStateNeedValue} ein entsprechender Fehler
signalisiert und beispielsweise innerhalb \Macro{FamilyOptions}  auch als
solcher gemeldet.%
\fi%
\EndIndexGroup


\begin{Declaration}
  \Macro{FamilyCounterMacroKey}\OParameter{Mitglied}\Parameter{Familie}
                               \Parameter{SchlÃ¼ssel}
                               \OParameter{SÃ¤umniswert}\Parameter{Makro}
  \Macro{FamilySetCounterMacro}\Parameter{Familie}
                               \Parameter{SchlÃ¼ssel}\Parameter{Makro}
                               \Parameter{Wert}
\end{Declaration}
Diese\ChangedAt{v3.12}{\Package{scrbase}} beiden Anweisungen unterscheiden
sich von den zuvor erklÃ¤rten \DescRef{\LabelBase.cmd.FamilyCounterKey} und
\DescRef{\LabelBase.cmd.FamilySetCounter} nur dadurch, dass nicht ein
\LaTeX-ZÃ¤hler auf einen Wert gesetzt wird, sondern ein \PName{Makro} mit
diesem Wert definiert wird. Auch dabei wird \PName{Wert} lokal einem ZÃ¤hler
zugewiesen und dann dessen expandierter Wert verwendet. Es gilt daher der Wert
zum Zeitpunkt des Aufrufs der Option.%
\EndIndexGroup


\begin{Declaration}
  \Macro{FamilyLengthKey}\OParameter{Mitglied}\Parameter{Familie}
                         \Parameter{SchlÃ¼ssel}
                         \OParameter{SÃ¤umniswert}\Parameter{LÃ¤nge}
  \Macro{FamilySetLength}\Parameter{Familie}
                         \Parameter{SchlÃ¼ssel}\Parameter{LÃ¤nge}
                         \Parameter{Wert}
  \Macro{FamilyLengthMacroKey}\OParameter{Mitglied}\Parameter{Familie}
                              \Parameter{SchlÃ¼ssel}
                              \OParameter{SÃ¤umniswert}\Parameter{Makro}
  \Macro{FamilySetLengthMacro}\Parameter{Familie}
                              \Parameter{SchlÃ¼ssel}\Parameter{Makro}
                              \Parameter{Wert}
  \Macro{FamilyUseLengthMacroKey}\OParameter{Mitglied}\Parameter{Familie}
                                 \Parameter{SchlÃ¼ssel}
                                 \OParameter{SÃ¤umniswert}\Parameter{Makro}
  \Macro{FamilySetUseLengthMacro}\Parameter{Familie}
                                 \Parameter{SchlÃ¼ssel}\Parameter{Makro}
                                 \Parameter{Wert}
\end{Declaration}
Ãœber\ChangedAt{v3.12}{\Package{scrbase}} \Macro{FamilyLengthKey} kann ein
\PName{SchlÃ¼ssel} definiert werden, der eine \PName{LÃ¤nge}
reprÃ¤sentiert. Dabei spielt es keine Rolle, ob eine \LaTeX-LÃ¤nge, ein
\TeX-Abstand oder eine \TeX-Ausdehnung als \PName{LÃ¤nge} verwendet
wird. Intern wird die \PName{LÃ¤nge} Ã¼ber \Macro{FamilySetLength} gesetzt.
Dabei finden einige grundlegende PrÃ¼fungen des \PName{Wert}-Arguments statt um
festzustellen, ob dieses Argument fÃ¼r eine Zuweisung an eine \PName{LÃ¤nge} in
Frage kommt. Die Zuweisung findet nur statt, wenn diese PrÃ¼fungen
gelingen. Allerdings kÃ¶nnen hier nicht alle Fehler erkannt werden, so dass
eine falsche Zuweisung auch zu einer Fehlermeldung von \TeX{} selbst fÃ¼hren
kann. Erkannte Fehler werden hingegen Ã¼ber
\DescRef{\LabelBase.cmd.FamilyKeyStateUnknownValue} signalisiert.

Wurde\ChangedAt{v3.15}{\Package{scrbase}} kein Wert Ã¼bergeben, so wird
stattdessen der \PName{SÃ¤umniswert} eingesetzt. Falls kein \PName{SÃ¤umniswert}
angegeben wird, kann spÃ¤ter der \PName{SchlÃ¼ssel} nur mit WertÃ¼bergabe
verwendet werden.

\Macro{FamilyLengthMacroKey} und \Macro{FamilySetLengthMacroKey} sowie
\Macro{FamilyUseLengthMacro} und \Macro{FamilySetUseLengthMacro} verwenden fÃ¼r
die Speicherung des Wertes keine \PName{LÃ¤nge}, sondern ein \PName{Makro}. Bei
\Macro{FamilyLengthMacroKey} und \Macro{FamilySetLengthMacro} wird wie im
Falle einer \PName{LÃ¤nge} der aktuelle \PName{Wert} zum Zeitpunkt der
Verwendung des SchlÃ¼ssels beziehungsweise der Anweisung in \PName{Makro}
gespeichert. Dagegen wird bei
\Macro{FamilyUseLengthMacroKey}\ChangedAt{v3.20}{\Package{scrbase}} und
\Macro{FamilySetUseLengthMacro} \PName{Wert} selbst gespeichert. Damit wird
\PName{Wert} dann bei jeder Verwendung von \PName{Makro} neu ausgewertet.%
\EndIndexGroup


\begin{Declaration}
  \Macro{FamilyStringKey}\OParameter{Mitglied}\Parameter{Familie}
                         \Parameter{SchlÃ¼ssel}
                         \OParameter{SÃ¤umniswert}\Parameter{Makro}
  \Macro{FamilyCSKey}\OParameter{Mitglied}\Parameter{Familie}
                     \Parameter{SchlÃ¼ssel}
                     \OParameter{SÃ¤umniswert}\Parameter{Makroname}
\end{Declaration}
Hier wird nun\ChangedAt{v3.08}{\Package{scrbase}} ein SchlÃ¼ssel definiert, der
jeden beliebigen Wert annehmen kann. Der Wert wird in dem angegebenen
\PName{Makro} gespeichert. Wird das optionale Argument fÃ¼r den
\PName{SÃ¤umniswert} weggelassen, so entspricht \Macro{FamilyStringKey}:
\begin{lstcode}[escapeinside=&gt;&lt;]
  \DefineFamilyKey[&gt;\PName{Mitglied}&lt;]{&gt;\PName{Familie}&lt;}{&gt;\PName{SchlÃ¼ssel}&lt;}
                  {\def&gt;\PName{Makro}&lt;{#1}}
\end{lstcode}
Existiert
das optionale Argument fÃ¼r den \PName{SÃ¤umniswert} so entspricht die Anweisung:
\begin{lstcode}[escapeinside=&gt;&lt;]
  \DefineFamilyKey[&gt;\PName{Mitglied}&lt;]{&gt;\PName{Familie}&lt;}{&gt;\PName{SchlÃ¼ssel}&lt;}
                  [&gt;\PName{SÃ¤umniswert}&lt;]
                  {\def&gt;\PName{Makro}&lt;{#1}\FamilyKeyStateProcessed}
\end{lstcode}

\begin{Example}
  In der Voreinstellung sollen 250\,g Wurstsalat erzeugt werden. Die Menge
  soll jedoch einfach per Option geÃ¤ndert werden kÃ¶nnen. Dazu wird die zu
  erstellende Menge im Makro \Macro{Salatgewicht} gespeichert. Die Option,
  Ã¼ber die das Gewicht geÃ¤ndert werden kann, soll \iffalse ebenfalls \fi
  \PValue{Salatgewicht} heiÃŸen:
\begin{lstcode}
  \newcommand*{\Salatgewicht}{250g}
  \FamilyStringKey{Fleischermeister}%
                  {Salatgewicht}[250g]%
                  {\Salatgewicht}
\end{lstcode}
  Soll nach einer Ã„nderung
  \iftrue% Umbruchkorrekturtext
  wie
\begin{lstcode}
  \FamilyOptions{Fleichermeister}{Salatgewicht=100g}
\end{lstcode}
  \fi%
  wieder die Standardmenge hergestellt
  werden, so kann der Anwender die Option einfach ohne Gewichtsangabe
  aufrufen:
\begin{lstcode}
  \FamilyOptions{Fleischermeister}{Salatgewicht}
\end{lstcode}
  Das ist mÃ¶glich, weil die Standardmenge bei der Definition auch als
  SÃ¤umniswert angegeben wurde.
\end{Example}
Da alle Werte unmittelbar fÃ¼r eine Makrodefinition verwendet werden, gibt es
keine unbekannten Werte. In der Wertzuweisung an den \PName{SchlÃ¼ssel} dÃ¼rfen
jedoch keine AbsÃ¤tze enthalten sein.

Im\ChangedAt{v3.25}{\Package{scrbase}} Unterschied zu \Macro{FamilyStringKey}
erwartet \Macro{FamilyCSKey} kein Makro als letztes Argument, sondern
lediglich den Namen eines Makros, also beispielsweise nicht
\PParameter{\Macro{Salatgewicht}}, sondern \PParameter{Salatgewicht}.%
%
\EndIndexGroup


\begin{Declaration}
  \Macro{FamilyUnknownKeyValue}\Parameter{Familie}\Parameter{SchlÃ¼ssel}
                               \Parameter{Wert}\Parameter{Werteliste}
\end{Declaration}
Diese Anweisung signalisiert Ã¼ber \DescRef{\LabelBase.cmd.FamilyKeyState}
einen Fehler aufgrund eines unbekannten oder unerlaubten Wertes. Dabei wird
als \PName{Werteliste} eine durch Komma separierte Liste von erlaubten Werten
der Form:
%\begin{flushleft}\vskip\dp\strutbox\begin{tabular}{l}
    `\PName{Wert}'\texttt{,} `\PName{Wert}' \dots{}
%\end{tabular}\vskip\dp\strutbox\end{flushleft}
erwartet. Allerdings\ChangedAt{v3.12}{\Package{scrbase}} wird die
\PName{Werteliste} derzeit nicht ausgewertet.

\begin{Example}
  FÃ¼r den Aufschnitt soll nun zusÃ¤tzlich wÃ¤hlbar sein, ob er grob oder
  fein geschnitten werden soll. Dabei ist grob die Voreinstellung, die auch
  dann verwendet werden soll, wenn nicht angegeben wird, wie der Aufschnitt zu
  schneiden ist.
\begin{lstcode}
  \@ifundefined{if@Feinschnitt}{%
    \expandafter
    \newif\csname if@Feinschnitt\endcsname}{}%
  \@ifundefined{if@Aufschnitt}{%
    \expandafter
    \newif\csname if@Aufschnitt\endcsname}{}
  \DefineFamilyKey{Fleischermeister}%
                  {Aufschnitt}[true]{%
    \FamilySetBool{Fleischermeister}{Aufschnitt}%
                                    {@Aufschnitt}%
                                    {#1}%
    \ifx\FamilyKeyState\FamilyKeyStateProcessed
      \@Feinschnittfalse
    \else      
      \Ifstr{#1}{fein}{%
        \@Aufschnitttrue
        \@Feinschnittrue
        \FamilyKeyStateProcessed
      }{%
        \FamilyUnknownKeyValue{Fleichermeister}%
                              {Aufschnitt}%
                              {#1}{%
                                `true', `on', `yes',
                                `false`, `off`, `no',
                                `fein'%
                              }%
      }%
    \fi
  }%
\end{lstcode}
  ZunÃ¤chst wird versucht, den booleschen Schalter fÃ¼r Aufschnitt Ã¼ber
  \DescRef{\LabelBase.cmd.FamilySetBool} zu setzen. Gelingt dies, wurde also
  \DescRef{\LabelBase.cmd.FamilyKeyState} zu
  \DescRef{\LabelBase.cmd.FamilyKeyStateProcessed} definiert, wird
  der Feinschnitt abgeschaltet. Anderenfalls wird Ã¼berprÃ¼ft, ob anstelle
  eines gÃ¼ltigen Wertes fÃ¼r einen booleschen Schalter %der Wert
  \PValue{fein} Ã¼bergeben wurde. In diesem Fall wird sowohl der Feinschnitt,
  als auch Aufschnitt aktiviert und mit Hilfe von
  \DescRef{\LabelBase.cmd.FamilyKeyStateProcessed} der Erfolgs-Status
  gesetzt. Ist auch das nicht der Fall, wird der von
  \DescRef{\LabelBase.cmd.FamilySetBool} signalisierte Fehler-Zustand
  neu auf \DescRef{\LabelBase.cmd.FamilyKeyStateUnknownValue} gesetzt. Die
  Liste der Ã¼blichen erlaubten Werte von
  \DescRef{\LabelBase.cmd.FamilySetBool} wird dabei um \PValue{fein}
  ergÃ¤nzt. Da diese Liste jedoch inzwischen nicht mehr verwendet wird, hÃ¤tte
  man auf den Aufruf von \Macro{FamilyUnknownKeyValue} im Beispiel auch
  einfach verzichten und damit den Fehlerstatus von
  \DescRef{\LabelBase.cmd.FamilySetBool} Ã¼bernehmen kÃ¶nnen.

  Die bei den Tests verwendete Anweisung
  \DescRef{\LabelBase.cmd.Ifstr}\IndexCmd{Ifstr} ist auf
  \DescPageRef{scrbase.cmd.Ifstr} in \autoref{sec:scrbase.if} erklÃ¤rt.
\end{Example}
%
\EndIndexGroup
\ExampleEndFix


\section{Verzweigungen}
\seclabel{if}

Das Paket \Package{scrbase} stellt diverse Verzweigungsanweisungen zur
VerfÃ¼gung. Dabei wird Ã¼berwiegend die \LaTeX-Syntax mit Argumenten eingesetzt,
die man von Anweisungen wie \Macro{IfFileExists}\iffalse % Umbruchkorrektur
, \Macro{@ifundefined}, \Macro{@ifpackageloaded} und vielen weiteren\fi %
\ kennt.

\begin{Declaration}
  \Macro{Ifundefinedorrelax}
  \Parameter{Name}\Parameter{Dann-Teil}\Parameter{Sonst-Teil}
\end{Declaration}
Diese\ChangedAt{v3.28}{\Package{scrbase}} Anweisung funktioniert
prinzipiell wie \Macro{@ifundefined} aus dem \LaTeX-Kern (siehe
\cite{latex:source2e}). Es wird also der \PName{Dann-Teil} ausgefÃ¼hrt, wenn
\PName{Name} der Name einer undefinierten Anweisung oder \Macro{\PName{Name}}
derzeit \Macro{relax} ist. Im Unterschied zu \Macro{@ifundefined} wird auch
bei Ã¤lteren \LaTeX-Versionen %
\iftrue% Umbruchvarianten
weder Hash-Speicher belegt noch \Macro{\PName{Name}} %
\else%
\Macro{\PName{Name}} nicht %
\fi%
zu \Macro{relax}, wenn \Macro{\PName{Name}} zuvor undefiniert
war.
\EndIndexGroup


\begin{Declaration}
  \Macro{Ifnotundefined}\Parameter{Name}%
  \Parameter{Dann-Teil}\Parameter{Sonst-Teil}
\end{Declaration}
Ist\ChangedAt{v3.28}{\Package{scrbase}} die Anweisung mit dem angegebenen
Namen bereits definiert wird der \PName{Dann-Teil} ausgefÃ¼hrt, anderenfalls
der \PName{Sonst-Teil}.\iftrue % Umbruchkorrektur
\ Da es bereits ein Paket mit einer inkompatiblen
Anweisung \Macro{Ifdefined} gibt, musste leider diese etwas unhandliche
Bezeichnung gewÃ¤hlt werden.%
\iffalse%
\iftrue% Umbruchvarianten
\ Von dieser Anweisung gibt es keine interne Variante.%
\else%
\ Es gibt keine interne Variante.%
\fi%
\fi%
\fi%
\EndIndexGroup


\begin{Declaration}
  \Macro{Ifstr}\Parameter{Zeichenfolge}\Parameter{Zeichenfolge}%
  \Parameter{Dann-Teil}\Parameter{Sonst-Teil}
\end{Declaration}
Die\ChangedAt{v3.28}{\Package{scrbase}} beiden Argumente \PName{Zeichenfolge}
werden expandiert und dann verglichen. Sind sie gleich, so wird der
\PName{Dann-Teil} ausgefÃ¼hrt, anderenfalls der \PName{Sonst-Teil}.%
\iffalse% Umbruchkorrektur
\iftrue% Umbruchvarianten
\ Von dieser Anweisung gibt es keine interne Variante.%
\else%
\ Es gibt keine interne Variante.%
\fi%
\fi%
\EndIndexGroup


\begin{Declaration}
  \Macro{Ifstrstart}\Parameter{Zeichenfolge}\Parameter{Zeichenfolge}
                    \Parameter{Dann-Teil}\Parameter{Sonst-Teil}
\end{Declaration}
Die\ChangedAt{v3.12}{\Package{scrbase}}\ChangedAt{v3.28}{\Package{scrbase}}
beiden Argumente \PName{Zeichenfolge} werden expandiert und dann
verglichen. Beginnt die erste Zeichenfolge, von Leerzeichen abgesehen, mit der
zweiten Zeichenfolge, so wird der \PName{Dann-Teil} ausgefÃ¼hrt, anderenfalls
der \PName{Sonst-Teil}.%
\iffalse% Umbruchkorrektur
\iftrue% Umbruchvarianten
\ Von dieser Anweisung gibt es keine interne Variante.%
\else%
\ Es gibt keine interne Variante.%
\fi%
\fi%
\EndIndexGroup


\begin{Declaration}
  \Macro{IfArgIsEmpty}\Parameter{Argument}%
  \Parameter{Dann-Teil}\Parameter{Sonst-Teil}
\end{Declaration}
Ist\ChangedAt{v3.19}{\Package{scrbase}} das \PName{Argument} leer, so wird der
\PName{Dann-Teil} ausgefÃ¼hrt, anderenfalls der \PName{Sonst-Teil}. Bereits ein
Leerzeichen gilt als nicht leer. Da das \PName{Argument} nicht expandiert
wird, gelten Makros, die zu einem leeren Ergebnis expandieren, ebenfalls als
nicht leeres \PName{Argument}. Dasselbe gilt fÃ¼r \Macro{relax} oder nicht
definierte Makros.%
\EndIndexGroup


\begin{Declaration}
  \Macro{Ifpdfoutput}
  \Parameter{Dann-Teil}\Parameter{Sonst-Teil}
\end{Declaration}
Wird\ChangedAt{v3.28}{\Package{scrbase}} eine PDF-Datei erzeugt, wird der
\PName{Dann-Teil} ausgefÃ¼hrt, anderenfalls der \PName{Sonst-Teil}. Dabei ist
es unerheblich, ob die PDF-Datei mit Hilfe von lua\TeX{}, pdf\TeX{}, V\TeX{}
oder \XeTeX{} erzeugt wird.%
\EndIndexGroup


\begin{Declaration}
  \Macro{Ifpsoutput}
  \Parameter{Dann-Teil}\Parameter{Sonst-Teil}
\end{Declaration}
Wird\ChangedAt{v3.28}{\Package{scrbase}} eine PostScript-Datei erzeugt, wird
der \PName{Dann-Teil} ausgefÃ¼hrt, anderenfalls der \PName{Sonst-Teil}. V\TeX{}
kann PostScript direkt erzeugen, was hier erkannt wird. Wird hingegen kein
V\TeX{} verwendet, ist aber ein Schalter \Macro{if@dvips} definiert, so wird
die Entscheidung darÃ¼ber getroffen. \KOMAScript{} stellt \Macro{if@dvips} in
\hyperref[cha:typearea]{\Package{typearea}}\IndexPackage{typearea}%
\IndexCmd{if@dvips} bereit.%
\EndIndexGroup


\begin{Declaration}[0]
  \Macro{Ifdvioutput}
  \Parameter{Dann-Teil}\Parameter{Sonst-Teil}
\end{Declaration}
Wird \ChangedAt{v3.28}{\Package{scrbase}}eine DVI-Datei erzeugt, so wird der
\PName{Dann-Teil} ausgefÃ¼hrt, anderenfalls der \PName{Sonst-Teil}. Es wird
immer dann davon \iffree{}{\pagebreak}% Umbruchkorrektur
ausgegangen, dass eine DVI-Datei erzeugt wird, wenn keine
direkte Ausgabe einer PDF- oder Postscript-Datei erkannt werden kann.%
\EndIndexGroup


\begin{Declaration}
  \Macro{Ifisdimen}\Parameter{Code}\Parameter{Dann-Teil}\Parameter{Sonst-Teil}
\end{Declaration}
Wenn\ChangedAt{v3.12}{\Package{scrbase}}\ChangedAt{v3.28}{\Package{scrbase}}
die Expansion von \PName{Code} in einem \Macro{dimen}, also einem
\TeX-LÃ¤ngenregister, resultiert, wird der \PName{Dann-Teil} ausgefÃ¼hrt,
anderenfalls der \PName{Sonst-Teil}. Die Anweisung ist nicht voll
expandierbar.%
\iffalse% Umbruchkorrektur
\iftrue% Umbruchvarianten
\ Von dieser Anweisung gibt es keine interne Variante.%
\else%
\ Es gibt keine interne Variante.%
\fi%
\fi%
\EndIndexGroup


\begin{Declaration}
  \Macro{Ifisdimension}\Parameter{Code}%
  \Parameter{Dann-Teil}\Parameter{Sonst-Teil}
\end{Declaration}
Wenn\ChangedAt{v3.12}{\Package{scrbase}}\ChangedAt{v3.28}{\Package{scrbase}}
die Expansion von \PName{Code} in etwas resultiert, das syntaktisch dem Wert
einer LÃ¤nge entspricht, wird der \PName{Dann-Teil} ausgefÃ¼hrt, anderenfalls
der \PName{Sonst-Teil}. Es ist zu beachten,\textnote{Achtung!} dass derzeit
unbekannte oder fehlende Einheiten zu einer Fehlermeldung fÃ¼hren. Die
Anweisung ist nicht voll expandierbar.%
\iffalse% Umbruchkorrektur
\iftrue% Umbruchvarianten
\ Von dieser Anweisung gibt es keine interne Variante.%
\else%
\ Es gibt keine interne Variante.%
\fi%
\fi%
\EndIndexGroup


\begin{Declaration}
  \Macro{Ifdimen}\Parameter{Zeichenfolge}%
  \Parameter{Dann-Teil}\Parameter{Sonst-Teil}
\end{Declaration}
Der\ChangedAt{v3.28}{\Package{scrbase}}\ChangedAt{v3.28}{\Package{scrbase}}
\PName{Dann-Teil} wird ausgefÃ¼hrt, wenn die einfache Expansion der
\PName{Zeichenfolge} eine gÃ¼ltige LÃ¤nge mit einer gÃ¼ltigen LÃ¤ngeneinheit
ergibt. Anderenfalls wird der \PName{Sonst-Teil} verwendet.%
\iffalse% Umbruchkorrektur
\iftrue% Umbruchvarianten
\ Von dieser Anweisung gibt es keine interne Variante.%
\else%
\ Es gibt keine interne Variante.%
\fi%
\fi%
\EndIndexGroup


\begin{Declaration}
  \Macro{Ifisdimexpr}\Parameter{Code}
  \Parameter{Dann-Teil}\Parameter{Sonst-Teil}
\end{Declaration}
Wenn\ChangedAt{v3.12}{\Package{scrbase}}\ChangedAt{v3.28}{\Package{scrbase}}
die Expansion von \PName{Code} in einer \Macro{dimexpr}\IndexCmd{dimexpr},
also einem \eTeX-LÃ¤ngenausdruck resultiert, wird der \PName{Dann-Teil}
ausgefÃ¼hrt, anderenfalls der \PName{Sonst-Teil}. Es ist zu
beachten,\textnote{Achtung!} dass fehlerhafte AusdrÃ¼cke zu Fehlermeldungen
fÃ¼hren. Die Anweisung ist nicht voll expandierbar.%
\iffalse% Umbruchkorrektur
\iftrue% Umbruchvarianten
\ Von dieser Anweisung gibt es keine interne Variante.%
\else%
\ Es gibt keine interne Variante.%
\fi%
\fi%
\EndIndexGroup


\begin{Declaration}
  \Macro{Ifisskip}\Parameter{Code}\Parameter{Dann-Teil}\Parameter{Sonst-Teil}
\end{Declaration}
Wenn\ChangedAt{v3.12}{\Package{scrbase}}\ChangedAt{v3.28}{\Package{scrbase}}
die Expansion von \PName{Code} in einem \Macro{skip}, also einem \TeX-Abstand,
resultiert, wird der \PName{Dann-Teil} ausgefÃ¼hrt, anderenfalls der
\PName{Sonst-Teil}. Die Anweisung ist nicht voll expandierbar.%
\iffalse% Umbruchkorrektur
\iftrue% Umbruchvarianten
\ Von dieser Anweisung gibt es keine interne Variante.%
\else%
\ Es gibt keine interne Variante.%
\fi%
\fi%
\EndIndexGroup


\begin{Declaration}
  \Macro{Ifisglue}\Parameter{Code}%
  \Parameter{Dann-Teil}\Parameter{Sonst-Teil}
\end{Declaration}
Wenn\ChangedAt{v3.12}{\Package{scrbase}}\ChangedAt{v3.28}{\Package{scrbase}}
die Expansion von \PName{Code} in etwas resultiert, das syntaktisch dem Wert
eines Abstandes entspricht, wird der \PName{Dann-Teil} ausgefÃ¼hrt,
anderenfalls der \PName{Sonst-Teil}. Es ist zu beachten,\textnote{Achtung!}
dass derzeit unbekannte oder fehlende Einheiten zu einer Fehlermeldung
fÃ¼hren. Die Anweisung ist nicht voll expandierbar.%
\iffalse% Umbruchkorrektur
\iftrue% Umbruchvarianten
\ Von dieser Anweisung gibt es keine interne Variante.%
\else%
\ Es gibt keine interne Variante.%
\fi%
\fi%
\EndIndexGroup


\iffree{\begin{Declaration}}{\begin{Declaration}[0]}% Umbruchkorrektur
  \Macro{Ifisglueexpr}\Parameter{Code}%
  \Parameter{Dann-Teil}\Parameter{Sonst-Teil}
\end{Declaration}
Wenn\ChangedAt{v3.12}{\Package{scrbase}}\ChangedAt{v3.28}{\Package{scrbase}}
die Expansion von \PName{Code} in einer \Macro{glueexpr}\IndexCmd{glueexpr},
also einem \mbox{\eTeX}-Abstandsausdruck resultiert, wird der
\PName{Dann-Teil} ausgefÃ¼hrt, \iffree{}{\pagebreak}% Umbruchkorrektur
anderenfalls der \PName{Sonst-Teil}. Es ist zu beachten,\textnote{Achtung!}
dass fehlerhafte AusdrÃ¼cke zu Fehlermeldungen fÃ¼hren. Die Anweisung ist nicht
voll expandierbar.%
\iffalse% Umbruchkorrektur
\iftrue% Umbruchvarianten
\ Von dieser Anweisung gibt es keine interne Variante.%
\else%
\ Es gibt keine interne Variante.%
\fi%
\fi%
\EndIndexGroup


\begin{Declaration}
  \Macro{Ifiscounter}\Parameter{ZÃ¤hler}%
  \Parameter{Dann-Teil}\Parameter{Sonst-Teil}
\end{Declaration}
Wenn\ChangedAt{v3.12}{\Package{scrbase}}\ChangedAt{v3.28}{\Package{scrbase}}
\PName{ZÃ¤hler} ein definierter \LaTeX-ZÃ¤hler ist, wird der \PName{Dann-Teil}
ausgefÃ¼hrt, anderenfalls der \PName{Sonst-Teil}. Die Anweisung ist nicht voll
expandierbar.%
\iffalse% Umbruchkorrektur
\iftrue% Umbruchvarianten
\ Von dieser Anweisung gibt es keine interne Variante.%
\else%
\ Es gibt keine interne Variante.%
\fi%
\fi%
\EndIndexGroup


\begin{Declaration}
  \Macro{Ifiscount}\Parameter{Code}\Parameter{Dann-Teil}\Parameter{Sonst-Teil}
\end{Declaration}
Wenn\ChangedAt{v3.12}{\Package{scrbase}}\ChangedAt{v3.28}{\Package{scrbase}}
die Expansion von \PName{Code} in einem \Macro{count}, also einem \TeX-ZÃ¤hler,
resultiert, wird der \PName{Dann-Teil} ausgefÃ¼hrt, anderenfalls der
\PName{Sonst-Teil}. Die Anweisung ist nicht voll expandierbar. FÃ¼r einen Test
auf einen \LaTeX-ZÃ¤hler siehe \DescRef{\LabelBase.cmd.Ifiscounter}.%
\iffalse% Umbruchkorrektur
\iftrue% Umbruchvarianten
\ Von dieser Anweisung gibt es keine interne Variante.%
\else%
\ Es gibt keine interne Variante.%
\fi%
\fi%
\EndIndexGroup


\begin{Declaration}
  \Macro{Ifisinteger}\Parameter{Code}%
  \Parameter{Dann-Teil}\Parameter{Sonst-Teil}
\end{Declaration}
Wenn\ChangedAt{v3.12}{\Package{scrbase}}\ChangedAt{v3.28}{\Package{scrbase}}
die Expansion von \PName{Code} in etwas resultiert, das syntaktisch dem Wert
eines ZÃ¤hlers entspricht, also eine negative oder positive ganze Zahl ist,
wird der \PName{Dann-Teil} ausgefÃ¼hrt, anderenfalls der
\PName{Sonst-Teil}. Die Anweisung ist nicht voll expandierbar.%
\iffalse% Umbruchkorrektur
\iftrue% Umbruchvarianten
\ Von dieser Anweisung gibt es keine interne Variante.%
\else%
\ Es gibt keine interne Variante.%
\fi%
\fi%
\EndIndexGroup


\begin{Declaration}
  \Macro{Ifnumber}\Parameter{Zeichenfolge}%
  \Parameter{Dann-Teil}\Parameter{Sonst-Teil}
\end{Declaration}
Der\ChangedAt{v3.28}{\Package{scrbase}} \PName{Dann-Teil} wird ausgefÃ¼hrt,
wenn die einfache Expansion der \PName{Zeichenfolge} nur aus Ziffern
besteht. In allen anderen FÃ¤llen wird der \PName{Sonst-Teil} verwendet.%
\iffalse% Umbruchkorrektur
\iftrue% Umbruchvarianten
\ Von dieser Anweisung gibt es keine interne Variante.%
\else%
\ Es gibt keine interne Variante.%
\fi%
\fi%
\EndIndexGroup


\begin{Declaration}
  \Macro{Ifisnumexpr}\Parameter{Code}%
  \Parameter{Dann-Teil}\Parameter{Sonst-Teil}
\end{Declaration}
Wenn\ChangedAt{v3.12}{\Package{scrbase}}\ChangedAt{v3.28}{\Package{scrbase}}
die Expansion von \PName{Code} in einer \Macro{numexpr}\IndexCmd{numexpr},
also einem \eTeX-Zahlenausdruck resultiert, wird der \PName{Dann-Teil}
ausgefÃ¼hrt, anderenfalls der \PName{Sonst-Teil}. Es ist zu
beachten,\textnote{Achtung!} dass fehlerhafte AusdrÃ¼cke zu Fehlermeldungen
fÃ¼hren. Die Anweisung ist nicht voll expandierbar.%
\iffalse% Umbruchkorrektur
\iftrue% Umbruchvarianten
\ Von dieser Anweisung gibt es keine interne Variante.%
\else%
\ Es gibt keine interne Variante.%
\fi%
\fi%
\EndIndexGroup


\begin{Declaration}
  \Macro{IfActiveMkBoth}\Parameter{Dann-Teil}\Parameter{Sonst-Teil}
\end{Declaration}
Bei\ChangedAt{v3.27}{\Package{scrbase}} der Umschaltung zwischen automatischen
und manuellen Kolumnentiteln, verwendet der \LaTeX-Kern die Anweisung
\DescRef{scrlayer.cmd.@mkboth}\important{\Macro{@mkboth}}\IndexCmd{@mkboth}.
Im Falle automatischer Kolumnentitel setzt diese normalerweise sowohl den
linken als auch rechten Markenanteil. Im Falle manueller Kolumnentiteln setzt
sie keine Marke. Will man wissen, ob \DescRef{scrlayer.cmd.@mkboth} Marken
setzt oder nicht, so verwenden viele Pakete einen Vergleich entweder mit
\DescRef{maincls.cmd.markboth}\IndexCmd{markboth} oder
\Macro{@gobbletwo}. Dies deckt aber nicht alle FÃ¤lle von mÃ¶glichen
Umdefinierungen von \DescRef{scrlayer.cmd.@mkboth} ab. Daher testet
\Macro{IfActiveMkBoth}, ob \DescRef{scrlayer.cmd.@mkboth} tatsÃ¤chlich zum
Setzen einer Marke fÃ¼hren wÃ¼rde und deckt dabei sogar die Verwendung von
\Macro{marks} fÃ¼r die Definition von \DescRef{scrlayer.cmd.@mkboth} ab. Wird
ein solches aktives \DescRef{scrlayer.cmd.@mkboth} entdeckt, so wird der
\PName{Dann-Teil} ausgefÃ¼hrt. In allen anderen FÃ¤llen wird der
\PName{Sonst-Teil} ausgefÃ¼hrt.%
\begin{Example}
  Angenommen, Sie wollen in einem Paket im Fall der Verwendung automatischer
  Kolumnentitel, wie sie beispielsweise der Seitenstil
  \PageStyle{headings}\IndexPagestyle{headings} aktiviert, nur die rechte
  Marke setzen und die linke unverÃ¤ndert lassen, wohingegen bei Verwendung
  manueller Kolumentitel die Marken unverÃ¤ndert bleiben sollen. In einem
  ersten Ansatz verwenden Sie dafÃ¼r:
\begin{lstcode}
  \ifx\@mkboth\markboth \markright{Kolumnentitel}\fi
\end{lstcode}
  Etwas spÃ¤ter entdecken Sie, dass irgendein Paket nicht wie gewohnt
\begin{lstcode}
  \let\@mkboth\markboth
\end{lstcode}
  sondern
\begin{lstcode}
  \renewcommand{\@mkboth}{\markboth}
\end{lstcode}
  verwendet hat, um automatische Kolumnentitel zu aktivieren. Daher ruft Ihr
  Vergleich niemals die \DescRef{maincls.cmd.markright}-Anweisung auf.  Daher
  Ã¤ndern Sie den Vergleich oben zu
\begin{lstcode}
  \ifx\@mkboth\@gobbletwo
  \else \markright{Kolumnentitel}\fi
\end{lstcode}
  Leider wird nun \DescRef{maincls.cmd.markright} auch bei manuellen
  Kolumentiteln aufgerufen, weil irgend jemand fÃ¼r diesen Fall
\begin{lstcode}
  \renewcommand{\@mkboth}[2]{%
    \typeout{DEBUG: ignoring running head setting}%
  }
\end{lstcode}
  definiert hat.

  Beide Probleme sind jedoch mit Hilfe von \Package{scrbase} einfach zu lÃ¶sen:
\begin{lstcode}
  \IfActiveMkBoth{\markright{Kolumnentitel}}{}
\end{lstcode}%
\end{Example}
Noch einfacher lÃ¤sst sich das Problem aus dem Beispiel %
\iffalse Ã¼brigens \fi % Umbruchkorrektur
mit Hilfe von \DescRef{scrlayer.cmd.@mkright} aus Paket
\hyperref[cha:scrlayer]{\Package{scrlayer}} lÃ¶sen (siehe
\autoref{sec:scrlayer.pagestyle.content},
\DescPageRef{scrlayer.cmd.@mkright}).%
\EndIndexGroup


\begin{Declaration}[0]
  \Macro{if@atdocument}\ \PName{Dann-Teil}\ %
  \textMacro{else}\ \PName{Sonst-Teil} \textMacro{fi}
\end{Declaration}
Diese Verzweigung in \TeX-Syntax existiert bewusst nur als interne
Anweisung. In der DokumentprÃ¤ambel ist \Macro{if@atdocument} \Macro{iffalse},
nach \Macro{begin}\PParameter{document} entspricht \Macro{if@atdocument} dann
\Macro{iftrue}.  Klassen- und Paketautoren kÃ¶nnen dieses Anweisung manchmal
sinnvoll nutzen, wenn sich Anweisungen in der DokumentprÃ¤ambel anders
verhalten sollen als innerhalb des Dokuments. Es\textnote{Achtung!} ist zu
beachten, dass es sich bei dieser Anweisung um eine Verzweigung in \TeX-Syntax
und nicht in \LaTeX-Syntax handelt. Ab\ChangedAt{v3.37}{\Package{scrbase}}
\LaTeX{} 2020/10/01 wird \Macro{@atdocumenttrue} von \Package{scrbase} Ã¼ber
den generischen \LaTeX-Hook \texttt{begindocument/before} ausgefÃ¼hrt. Daher
ist der Zustand bereits fÃ¼r \Macro{BeginDocument} fÃ¼r Klassen und alle Pakete
\Macro{iftrue}. FÃ¼r Verwendung von \Macro{if@atdocument} mit dem generischen
\LaTeX-Hook \texttt{begindocument/before} wird hingegen gegebenenfalls eine
zusÃ¤tzliche Hook-Regel benÃ¶tigt, um einen definierten Zustand zu erreichen.%
\EndIndexGroup


\section{Definition sprachabhÃ¤ngiger Bezeichner}
\seclabel{languageSupport}
\BeginIndexGroup
\BeginIndex{}{Sprachdefinition}

\iffalse% Umbruchkorrektur
AnfÃ¤nger haben hÃ¤ufig Probleme damit, sprachabhÃ¤ngige Begriffe wie
\Macro{listfigurename}\IndexCmd{listfigurename}, in der Voreinstellung meist
Â»List of FiguresÂ« beziehungsweise in Deutsch: Â»AbbildungsverzeichnisÂ«, zu
Ã¤ndern. Werden diese beispielsweise einfach mit \Macro{renewcommand} in der
DokumentprÃ¤ambel umdefiniert, so Ã¼berleben sie eine spÃ¤tere Umschaltung der
Sprache nicht. Bei Verwendung von \Package{babel}\IndexCmd{babel} wird die
Umdefinierung in der DokumentprÃ¤ambel bereits von
\Macro{begin}\PParameter{document} wieder Ã¼berschrieben.
\fi

Normalerweise muss man zur Definition oder zur Ã„nderung sprachabhÃ¤ngiger
Begriffe Anweisungen wie \Macro{captionsngerman} so umdefinieren, dass
zusÃ¤tzlich zu den bisherigen Begriffen auch die neuen oder geÃ¤nderten
definiert werden. Erschwert wird dieses Vorhaben dadurch, dass beim Laden
eines Pakets wie \Package{babel}\IndexPackage{babel} oder
\Package{polyglossia}\IndexPackage{polyglossia} diese Anweisungen von den
Paketen erneut definiert werden. Bei den genannten Paketen geschieht dies,
indem alle zuvor gemachten Ã„nderungen Ã¼berschrieben werden. Aus diesem Grund
ist es sinnvoll, eigene Ã„nderungen bis nach dem Laden entsprechender Pakete
oder mit Hilfe von \Macro{AtBeginDocument} bis
\Macro{begin}\PParameter{document} zu verzÃ¶gern.

DarÃ¼ber hinaus kommt erschwerend hinzu, dass einige Pakete zusÃ¤tzliche,
sprachabhÃ¤ngige Begriffe in \Macro{captions\PName{Sprache}} definieren,
wÃ¤hrend andere dafÃ¼r \Macro{extras\PName{Sprache}} verwenden. So muss der
Anwender sich schon sehr genau auskennen, um die richtige Anweisung auf die
richtige Weise zu ergÃ¤nzen.

Das Paket \Package{scrbase} bietet dem Anwender daher fÃ¼r die Definition und
Ã„nderung selbst einige zusÃ¤tzliche Anweisungen, die ihn von vielen dieser
Ãœberlegungen befreit. Gleichzeitig erlauben die Befehle, die
sprachabhÃ¤ngigen Begriffe mehrerer Dialekte oder AusprÃ¤gungen einer Sprache
gleichzeitig zu definieren oder zu Ã¤ndern.

\begin{Declaration}
  \Macro{defcaptionname}
    \Parameter{Sprachliste}\Parameter{Begriff}\Parameter{Inhalt}
  \Macro{providecaptionname}
    \Parameter{Sprachliste}\Parameter{Begriff}\Parameter{Inhalt}
  \Macro{newcaptionname}
    \Parameter{Sprachliste}\Parameter{Begriff}\Parameter{Inhalt}
  \Macro{renewcaptionname}
    \Parameter{Sprachliste}\Parameter{Begriff}\Parameter{Inhalt}
  \Macro{defcaptionname*}
    \Parameter{Sprachliste}\Parameter{Begriff}\Parameter{Inhalt}
  \Macro{providecaptionname*}
    \Parameter{Sprachliste}\Parameter{Begriff}\Parameter{Inhalt}
  \Macro{newcaptionname*}
    \Parameter{Sprachliste}\Parameter{Begriff}\Parameter{Inhalt}
  \Macro{renewcaptionname*}%
    \Parameter{Sprachliste}\Parameter{Begriff}\Parameter{Inhalt}
\end{Declaration}
Mit Hilfe dieser Anweisungen ist es mÃ¶glich, einem \PName{Begriff} in
AbhÃ¤ngigkeit der Sprache einen \PName{Inhalt} zuzuweisen. Mehrere Sprachen
kÃ¶nnen durch Komma voneinander getrennt als
\PName{Sprachliste}\ChangedAt{v3.12}{\Package{scrbase}} angegeben werden.
Der \PName{Begriff} ist immer ein Makro. Die Arbeitsweise der Anweisungen
unterscheidet sich je nachdem, ob eine Sprache und ein \PName{Begriff}
innerhalb der Sprache zum Zeitpunkt des Aufrufs bereits definiert ist.

Ist eine Sprache nicht definiert, vermerkt \Macro{providecaptionname} das
lediglich in \File{log}-Datei. Dabei wird fÃ¼r jede Sprache nur einmal eine
entsprechende Information in die \File{log}-Datei geschrieben. Ist die Sprache
definiert, enthÃ¤lt aber bisher keinen entsprechenden \PName{Begriff}, so wird
er mit dem angegebenen \PName{Inhalt} definiert. Ist der \PName{Begriff}
hingegen in der Sprache bereits definiert, so wird er nicht umdefiniert,
sondern ebenfalls ein entsprechender Hinweis in die \File{log}-Datei
geschrieben.

Ist dagegen bei \Macro{newcaptionname}
eine Sprache nicht definiert, dann wird diese neu definiert, indem eine
entsprechende Anweisung definiert wird. FÃ¼r die Sprache
\PValue{ngerman} wÃ¤re das beispielsweise \Macro{captionsngerman}. AuÃŸerdem
wird darÃ¼ber auch in der \File{log}-Datei informiert. Ist die Sprache
definiert, der \PName{Begriff} in dieser Sprache aber noch nicht
vorhanden, so wird er mit dem gewÃ¼nschten \PName{Inhalt} definiert. Ist der
\PName{Begriff} in der Sprache bereits vorhanden, so wird eine
Fehlermeldung ausgegeben.

Ist bei Anweisung \Macro{renewcaptionname} eine Sprache nicht definiert, so
wird eine Fehlermeldung ausgegeben. Ist die Sprache definiert, der
\PName{Begriff} in dieser Sprache jedoch nicht, so wird ebenfalls eine
Fehlermeldung ausgegeben. Ist der \PName{Begriff} in der Sprache definiert, so
wird er auf den gewÃ¼nschten \PName{Inhalt} umdefiniert.

Die\ChangedAt{v3.12}{\Package{scrbase}} Anweisung \Macro{defcaptionname}
definiert einen \PName{Begriff} immer, Ã¼berschreibt also eventuell vorhandene
Definitionen. Wie bei \Macro{providecaptionname} braucht eine angegebene
Sprache nicht definiert zu sein.

\KOMAScript{} selbst verwendet \Macro{providecaptionname} um beispielsweise
die Begriffe aus \autoref{sec:scrlttr2-experts.languages},
\DescPageRef{scrlttr2-experts.cmd.yourrefname} zu definieren.

\begin{Example}
  MÃ¶chten Sie Â»Abb.Â« statt Â»AbbildungÂ« in den Abbildungsunterschriften, so
  erreichen Sie dies mit:
\begin{lstcode}
  \renewcaptionname{ngerman}{\figurename}{Abb.}
\end{lstcode}

  Soll dieselbe Ã„nderung nicht nur fÃ¼r \PValue{ngerman}, sondern
  auch fÃ¼r die Sprachen \PValue{naustrian} und \PValue{nswissgerman}, also fÃ¼r
  Ã–sterreichisch und Schweizer Deutsch gelten, so ist
  es nicht notwendig zwei weitere Anweisungen:
\begin{lstcode}
  \renewcaptionname{naustrian}{\figurename}{Abb.}
  \renewcaptionname{nswissgerman}{\figurename}{Abb.}
\end{lstcode}
  hinzuzufÃ¼gen. Stattdessen kann einfach, die \PName{Sprachliste} erweitert
  werden:
\begin{lstcode}
  \renewcaptionname{ngerman,naustrian,nswissgerman}%
                   {\figurename}{Abb.}
\end{lstcode}
  In gleicher Weise kÃ¶nnen auch \PValue{german}, \PValue{austrian} und
  \PValue{swissgerman}, also Deutsch, Ã–sterreichisch und Schweizer Deutsch
  nach der veralteten Rechtschreibung, hinzugefÃ¼gt werden.
\end{Example}
\iffalse % Das ist 6 Jahre her und damit nicht mehr von Belang!
\begin{Explain}
  Die Sprachen \PValue{swissgerman} und \PValue{nswissgerman} werden Ã¼brigens
  von Ã¤lteren Versionen von \Package{babel} noch nicht unterstÃ¼tzt. Sie sind
  erst seit Dezember~2013 Bestandteil des deutschen Sprachpakets fÃ¼r
  \Package{babel}. FÃ¼r die Anweisungen \Macro{defcaptionname},
  \Macro{newcaptionname} und \Macro{providecaptionname} spielt dies kaum eine
  Rolle, da diese auch Begriffe fÃ¼r nicht existierende Sprachen definieren
  kÃ¶nnen. Da mit \Macro{renewcaptionname} jedoch nur existierende Begriffe von
  existierenden Sprachen umdefiniert werden kÃ¶nnen, resultiert die
  Umdefinierung fÃ¼r \Option{nswissgerman} und \Option{swissgerman} bei
  Verwendung einer Ã¤lteren Version von \Package{babel} in einer entsprechenden
  Fehlermeldung.
\end{Explain}%
\fi

Es\ChangedAt{v3.12}{\Package{scrbase}} ist nicht erforderlich, die Definierung
oder Umdefinierung via \Macro{AtBeginDocument} bis
\Macro{begin}\PParameter{document} zu verzÃ¶gern. Stattdessen erledigt
\Package{scrbase} das selbst, falls die Anweisungen in der DokumentprÃ¤ambel
aufgerufen werden. AuÃŸerdem prÃ¼ft \Package{scrbase} auch, ob ein
umzudefinierender Begriff statt in \Macro{captions\PName{Sprache}} in
\Macro{extras\PName{Sprache}} zu definieren ist. Die Sternvarianten der
Befehle verwenden grundsÃ¤tzlich \Macro{extras\PName{Sprache}}, da dessen
Definitionen in der Regel nach \Macro{captions\PName{Sprache}} Anwendung
finden. Damit funktioniert auch das Umdefinieren von sprachabhÃ¤ngigen
Bezeichnern von Paketen\iffalse\ wie \Package{hyperref}\fi, die dafÃ¼r
\Macro{extras\PName{Sprache}} verwenden.

In \autoref{tab:scrbase.commonNames} ist ein Ãœberblick Ã¼ber die Ã¼blicherweise
von Klassen und Sprachpaketen definierten Begriffe und deren Verwendung zu
finden.\iffree{}{ \KOMAScript{} selbst definiert noch einige weitere
  Begriffe. Siehe dazu \autoref{sec:scrlttr2-experts.languages} ab
  \DescPageRef{scrlttr2-experts.cmd.yourrefname}.}
%
%\iffree{}{\enlargethispage{4pt}}% Umbruchkorrektur
\begin{desclist}
  \renewcommand*{\abovecaptionskipcorrection}{-\normalbaselineskip}%
  \desccaption[{%
    Ãœberblick Ã¼ber Ã¼bliche sprachabhÃ¤ngige Begriffe%
  }]{%
    Ãœberblick Ã¼ber sprachabhÃ¤ngige Begriffe in den Ã¼blichen
    Sprachpaketen\label{tab:scrbase.commonNames}%
  }{%
    Ãœberblick Ã¼ber Ã¼bliche sprachabhÃ¤ngige Begriffe
    (\emph{Fortsetzung})%
  }%
  \entry{\Macro{abstractname}}{%
    Ãœberschrift fÃ¼r die Zusammenfassung%
    \IndexCmd{abstractname}%
  }%
  \entry{\Macro{alsoname}}{%
    Â»siehe auchÂ« bei ergÃ¤nzenden Verweisen im Stichwortverzeichnis%
    \IndexCmd{alsoname}%
  }%
  \entry{\Macro{appendixname}}{%
    Â»AnhangÂ« in der KapitelÃ¼berschrift eines Anhangs%
    \IndexCmd{appendixname}%
  }%
  \entry{\Macro{bibname}}{%
    Ãœberschrift fÃ¼r das Literaturverzeichnis%
    \IndexCmd{bibname}%
  }%
  \entry{\Macro{ccname}}{%
    Spitzmarke fÃ¼r den Verteiler in Briefen%
    \IndexCmd{ccname}%
  }%
  \entry{\Macro{chaptername}}{%
    Â»KapitelÂ« in der KapitelÃ¼berschrift%
    \IndexCmd{chaptername}%
  }%
  \entry{\Macro{contentsname}}{%
    Ãœberschrift fÃ¼r das Inhaltsverzeichnis%
    \IndexCmd{contentsname}%
  }%
  \entry{\Macro{enclname}}{%
    Spitzmarke fÃ¼r die Anlagen bei Briefen%
    \IndexCmd{enclname}%
  }%
  \entry{\Macro{figurename}}{%
    Spitzmarke in der Abbildungsunterschrift%
    \IndexCmd{figurename}%
  }%
  \entry{\Macro{glossaryname}}{%
    Ãœberschrift fÃ¼r das Glossar%
    \IndexCmd{glossaryname}%
  }%
  \entry{\Macro{headtoname}}{%
    Â»AnÂ« im Briefkopf%
    \IndexCmd{headtoname}%
  }%
  \entry{\Macro{indexname}}{%
    Ãœberschrift fÃ¼r das Stichwortverzeichnis%
    \IndexCmd{indexname}%
  }%
  \entry{\Macro{listfigurename}}{%
    Ãœberschrift fÃ¼r das Abbildungsverzeichnis%
    \IndexCmd{listfigurename}%
  }%
  \entry{\Macro{listtablename}}{%
    Ãœberschrift fÃ¼r das Tabellenverzeichnis%
    \IndexCmd{listtablename}%
  }%
  \entry{\Macro{pagename}}{%
    Â»SeiteÂ« in der Seitennummer von Briefen%
    \IndexCmd{pagename}%
  }%
  \entry{\Macro{partname}}{%
    Â»TeilÂ« in der TeileÃ¼berschrift%
    \IndexCmd{partname}%
  }%
  \entry{\Macro{prefacename}}{%
    Ãœberschrift fÃ¼r das Vorwort%
    \IndexCmd{prefacename}%
  }%
  \entry{\Macro{proofname}}{%
    Spitzmarke bei Beweisen%
    \IndexCmd{proofname}%
  }%
  \entry{\Macro{refname}}{%
    Ãœberschrift fÃ¼r das Quellenverzeichnis%
    \IndexCmd{refname}%
  }%
  \entry{\Macro{seename}}{%
    Â»sieheÂ« bei Verweisen im Stichwortverzeichnis%
    \IndexCmd{seename}%
  }%
  \entry{\Macro{tablename}}{%
    Spitzmarke in der Tabellenunter- bzw. "~Ã¼berschrift%
    \IndexCmd{tablename}%
  }%
\end{desclist}
%
\EndIndexGroup
%
\EndIndexGroup


\section{Identifikation von \KOMAScript}
\seclabel{identify}

Obwohl -- oder gerade weil -- \Package{scrbase} ganz allgemein als Paket fÃ¼r
Klassen- und Paketautoren konzipiert ist, wird es natÃ¼rlich von den
\KOMAScript-Klassen und den meisten \KOMAScript-Paketen verwendet. Es enthÃ¤lt
daher auch eine Anweisung, die in allen \KOMAScript-Klassen und allen
grundlegenden \KOMAScript-Paketen vorhanden ist.


\begin{Declaration}
  \Macro{KOMAScriptVersion}
\end{Declaration}
Bei \KOMAScript{} ist in dieser Anweisung die Hauptversion von \KOMAScript{}
in der Form Â»\PName{Datum} \PName{Version} \texttt{KOMA-Script}Â«
abgelegt. Diese Hauptversion ist fÃ¼r alle \KOMAScript-Klassen und alle
\KOMAScript-Pakete, die von den Klassen verwendet werden, gleich. Daher kann
sie auch nach dem Laden von \Package{scrbase} abgefragt werden. Diese
Anleitung wurde beispielsweise mit der \KOMAScript-Version
Â»\KOMAScriptVersionÂ« erstellt. Das Vorhandensein der Anweisung ist ein
starkes Indiz dafÃ¼r, dass zumindest ein \KOMAScript-Paket verwendet wird.%
\EndIndexGroup


\section{Erweiterungen des \LaTeX-Kerns}
\seclabel{latexkernel}

In einigen FÃ¤llen stellt der \LaTeX-Kern selbst Anweisungen zur VerfÃ¼gung,
lÃ¤sst aber ganz Ã¤hnliche Anweisungen, die ebenfalls hÃ¤ufiger benÃ¶tigt werden
oder eigentlich nahe liegen, vermissen. Einige wenige solcher Anweisungen
fÃ¼r Klassen- und Paketautoren stellt \Package{scrbase} zur VerfÃ¼gung.

\begin{Declaration}
  \Macro{ClassInfoNoLine}\Parameter{Klassenname}\Parameter{Information}
  \Macro{PackageInfoNoLine}\Parameter{Paketname}\Parameter{Information}
\end{Declaration}%
Der \LaTeX-Kern bietet dem Klassen- und Paketautor zwar Anweisungen wie
\Macro{PackageInfo} und \Macro{ClassInfo}, um Informationen mit aktueller
Zeilennummer in die Log-Datei zu schreiben. Er bietet neben
\Macro{PackageWarning} und \Macro{ClassWarning}, die Warnungen mit aktueller
Zeilennummer ausgeben, auch die beiden Anweisungen
\Macro{PackageWarningNoLine} und \Macro{ClassWarningNoLine}, um Warnungen ohne
Zeilennummer auszugeben. Die naheliegenden Anweisungen
\Macro{ClassInfoNoLine} und \Macro{PackageInfoNoLine}, um auch Informationen
ohne Zeilennummer in die Log-Datei zu schreiben, fehlen jedoch. Diese werden
von \Package{scrbase} bereitgestellt.
%
\EndIndexGroup


\begin{Declaration}
  \Macro{l@addto@macro}\Parameter{Anweisung}\Parameter{Erweiterung}%
\end{Declaration}%
Der \LaTeX-Kern bietet mit \Macro{g@addto@macro} eine interne Anweisung, um
die Definition eines Makro \PName{Anweisung} global um den Code
\PName{Erweiterung} zu erweitern. Das funktioniert in dieser Form nur fÃ¼r
Makros ohne Argumente. Dennoch kÃ¶nnte man die Anweisung in einigen FÃ¤llen
auch in einer Form benÃ¶tigen, die lokal zur aktuellen Gruppe arbeitet. Diese
wird mit \Macro{l@addto@macro} von \Package{scrbase} bereitgestellt. Eine
Alternative stellt hier die Verwendung des Pakets
\Package{etoolbox}\IndexPackage{etoolbox} oder
\Package{xpatch}\IndexPackage{xpatch} dar, die eine ganze Reihe solcher
Anweisungen fÃ¼r unterschiedliche Zwecke bieten (siehe
\cite{package:etoolbox} oder \cite{package:xpatch}).
%
\EndIndexGroup


\section{Erweiterungen der mathematischen FÃ¤higkeiten von \eTeX}
\seclabel{etex}

Das fÃ¼r \LaTeX{} inzwischen verwendete und von \KOMAScript{} vorausgesetzte
\eTeX{} besitzt mit \Macro{numexpr}\IndexCmd{numexpr} erweiterte MÃ¶glichkeiten
zur Berechnung einfacher AusdrÃ¼cke mit \TeX-ZÃ¤hlern und ganzen Zahlen. Als
Operationen werden dabei die vier Grundrechenarten und Klammern
unterstÃ¼tzt. Bei der Division wird korrekt gerundet.
\iffalse Manchmal sind weitere Operationen nÃ¼tzlich.\fi% Umbruchkorrektur

\begin{Declaration}
  \Macro{XdivY}\Parameter{Dividend}\Parameter{Divisor}
  \Macro{XmodY}\Parameter{Dividend}\Parameter{Divisor}
\end{Declaration}%
\BeginIndex{Cmd}{XdivY}%
\BeginIndex{Cmd}{XmodY}%
Die\ChangedAt{v3.05a}{\Package{scrbase}} Anweisung \Macro{XdivY} liefert den
Wert des ganzzahligen Quotienten, die Anweisung \Macro{XmodY} den Wert des
Rests der Division mit Rest. Diese Art der Division ist nach der Gleichung
\[
\textit{Dividend} = \textit{Divisor} \cdot
\textit{Quotient} + \textit{Rest}
\]
%
definiert, wobei \textit{Dividend}, \textit{Divisor} und \textit{Rest} ganze
Zahlen und \textit{Rest} auÃŸerdem grÃ¶ÃŸer oder gleich 0 und kleiner als
\textit{Divisor} ist. Der \textit{Divisor} ist eine natÃ¼rliche Zahl (ohne die
0).

Der Wert kann jeweils zur Zuweisung an einen ZÃ¤hler oder direkt innerhalb
eines Ausdrucks mit \Macro{numexpr}\IndexCmd{numexpr} verwendet werden. Zur
Ausgabe als arabische Zahl ist \Macro{the} voranzustellen.%
%
\EndIndexGroup


\section[{Mechanismus fÃ¼r mehrstufige Haken}]
{Mechanismus fÃ¼r mehrstufige
  Haken\ChangedAt{v3.27}{\Package{scrbase}}}
\seclabel{hooks}

\BeginIndexGroup
\BeginIndex{}{Haken}
Der \LaTeX-Kern bietet selbst bereits einige wenige Stellen in der
Verarbeitung eines Dokuments, an denen die AusfÃ¼hrung zusÃ¤tzlichen Codes
\emph{eingehakt} werden kann. Klassen- und Paketautoren dÃ¼rften
\Macro{AtBeginDocument} und \Macro{AtEndDocument} bestens bekannt
sein. \KOMAScript{} bietet an einigen Stellen vergleichbares, beispielsweise
um Code in die AusfÃ¼hrung von
\hyperref[sec:maincls.structure]{Gliederungsbefehlen} einzuhaken. Ãœber die
Jahre zeigten sich dabei zwei Probleme:
\begin{itemize}
\item Es gibt nie genug Haken.
\item Es gibt sowohl Code, der nur einmal ausgefÃ¼hrt werden soll, also quasi
  bei seiner AusfÃ¼hrung wieder vom Haken fÃ¤llt, als auch Code, der bei jedem
  Durchlaufen des Hakens auszufÃ¼hren ist, also dauerhaft auf dem Haken bleibt.
\end{itemize}
Ãœblicherweise muss man zur Definition eines einzelnen Hakens eine Anweisung
definieren, mit der Code fÃ¼r den jeweiligen Haken aufgesammelt wird. Der Code
wird dazu in einem weiteren internen Makro abgelegt, das man an der Stelle
einfÃ¼gen muss, an der der aufgesammelte Code auszufÃ¼hren ist. Je mehr Haken
man einfÃ¼gt, desto mehr solcher Anweisungen gibt es. Um sowohl Einmalcode als
auch dauerhaften Code zu ermÃ¶glichen, bedarf es sogar zweier Haken und damit
der doppelten Anzahl an zu definierenden Anweisungen.

Das Beispiel der Gliederungsbefehle zeigt, dass sich das erste Problem
an einem einzigen CodeausfÃ¼hrungspunkt noch verschÃ¤rfen kann. Der
eine Paketautor benÃ¶tigt nur eine MÃ¶glichkeit, fÃ¼r alle
Gliederungsbefehle denselben Code auszufÃ¼hren. Ein anderer Paketautor hÃ¤tte
lieber, dass er bei bestimmten Gliederungsbefehlen unterschiedlichen Code
ausfÃ¼hren kann. Es wÃ¼rde also sowohl ein allgemeiner Haken als auch ein Haken
je Gliederungsbefehl benÃ¶tigt. Das ganze dann wieder wegen des zweiten
Problems verdoppelt.

\KOMAScript{} bietet in \Package{scrbase} daher einen verallgemeinerten
Hakenmechanismus, der mehrstufige Haken sowohl fÃ¼r Einmalcode als auch fÃ¼r
dauerhaften Code bereitstellt. Diese Haken haben aufgrund der Implementierung
den Namen \emph{do-hook} erhalten. Davon leitet sich auch der Name der
Anweisungen ab, mit denen sie gesteuert werden.

\begin{Declaration}
  \Macro{ExecuteDoHook}\Parameter{Spezifikator}
\end{Declaration}
Ãœber\ChangedAt[2019/01]{v3.27}{\Package{scrbase}} diese Anweisung werden Haken
implementiert. Dabei bestimmt der \PName{Spezifikator} den Namen des oder
genauer der Haken. Der \PName{Spezifikator} wird zur Analyse immer vollstÃ¤ndig
expandiert.

Der \PName{Spezifikator} besteht allgemein aus durch Querstrichen,
Â»\texttt{/}Â«, voneinander getrennten Zeichenfolgen. Von \Macro{ExecuteDoHook}
wird zunÃ¤chst die Zeichenfolge vor dem ersten Querstrich abgetrennt. Diese ist
der Name. Der verbleibende Rest ohne den fÃ¼hrenden Querstrich ist das
Argument. Dann wird der Code fÃ¼r den Haken mit diesem Namen
ausgefÃ¼hrt. AnschlieÃŸend wird erneut die vordere Zeichenfolge vom Rest
abgetrennt und mit einem Querstrich hinten an den Namen angefÃ¼gt und der Code
fÃ¼r den so neu gebildeten Namen ausgefÃ¼hrt. Das geht so lange, bis der Code
fÃ¼r den Haken mit dem Namen \PName{Spezifikator} und leerem Argument
ausgefÃ¼hrt wurde.

Im einfachsten Fall besteht der \PName{Spezifikator} aus einem einzelnen
Namen. In diesem Fall wird zunÃ¤chst der dauerhafte Code fÃ¼r genau einen durch
diesen Namen festgelegten Haken mit leerem Argument ausgefÃ¼hrt.

In jeder Stufe der AusfÃ¼hrung wird nach dem dauerhaften Code fÃ¼r einen Haken
zusÃ¤tzlich Einmalcode ausgefÃ¼hrt, bevor der Einmalcode global vom Haken
genommen wird.

\begin{Example}
  Mit \DescRef{\LabelBase.cmd.ExecuteDoHook}%
  \PParameter{heading/begingroup/\PName{Name}} in der AusfÃ¼hrung jedes
  durch \DescRef{maincls-experts.cmd.DeclareSectionCommand} definierten
  Gliederungbefehls wurden in den \KOMAScript-Klassen letztlich sechs Haken an
  diesem Codepunkt eingefÃ¼gt, die in dieser Reihenfolge ausgefÃ¼hrt werden:
  \begin{enumerate}
  \item \PValue{heading} mit Argument \PValue{begingroup/}\PName{Name} fÃ¼r
    dauerhaften Code,
  \item \PValue{heading} mit Argument \PValue{begingroup/}\PName{Name} fÃ¼r
    Einmalcode,
  \item \PValue{heading/begingroup} mit Argument \PName{Name} fÃ¼r
    dauerhaften Code,
  \item \PValue{heading/begingroup} mit Argument \PName{Name} fÃ¼r
    Einmalcode,
  \item \PValue{heading/begingroup/}\PName{Name} mit leerem Argument fÃ¼r
    dauerhaften Code,
  \item \PValue{heading/begingroup/}\PName{Name} mit leerem Argument fÃ¼r
    Einmalcode.
  \end{enumerate}
  Der Platzhalter \PName{Name} ist dabei identisch mit dem bei
  \DescRef{maincls-experts.cmd.DeclareSectionCommand},
  \DescRef{maincls-experts.cmd.DeclareNewSectionCommand} oder
  \DescRef{maincls-experts.cmd.ProvideSectionCommand}
  angegebenen Namen
  der Gliederungsebene beziehungsweise des dadurch bestimmten
  Gliederungsbefehls, also beispielsweise \PValue{subparagraph} oder
  \PValue{chapter}. Betrachtet man obige Auf"|listung unter
  BerÃ¼cksichtigung der Vielzahl an Gliederungsbefehlen,
  wird klar, dass die Haken \PValue{heading} und \PValue{heading/begingroup}
  mehrfach, nÃ¤mlich fÃ¼r jeden Gliederungsbefehl existieren.%
\end{Example}%
%
\EndIndexGroup
\ExampleEndFix


\begin{Declaration}
  \Macro{AddtoDoHook}\Parameter{Name}\Parameter{Befehl}
  \Macro{AddtoOneTimeDoHook}\Parameter{Name}\Parameter{Befehl}
\end{Declaration}
Mit\ChangedAt[2019/01]{v3.27}{\Package{scrbase}} \Macro{AddtoDoHook} wird an
dem Haken mit dem Namen \PName{Name} dauerhafter\textnote{dauerhaft} Code
aufgehÃ¤ngt. Als Code dient dabei der \PName{Befehl}, dem das in der ErklÃ¤rung
zu \DescRef{\LabelBase.cmd.ExecuteDoHook} erwÃ¤hnte Argument als Parameter
angehÃ¤ngt wird.
\begin{Example}
  Angenommen, es soll innerhalb von \Macro{section} mitgezÃ¤hlt werden, wie oft
  diese Anweisung ausgefÃ¼hrt wird. Dies wÃ¤re in FortfÃ¼hrung des obigen
  Beispiels mit
\begin{lstcode}
  \newcounter{sectionZaehler}
  \AddtoDoHook{heading/begingroup/section}
              {\stepcounter{sectionZaehler}}
\end{lstcode}
  sehr einfach mÃ¶glich. Allerdings wÃ¼rde dann in Wirklichkeit
  \Macro{stepcounter}\PParameter{sectionZaehler}\PParameter{} ausgefÃ¼hrt. Wir
  erinnern uns daran, dass immer ein Argument als Parameter angehÃ¤ngt wird.
  Im Falle des Hakens mit dem Namen \PValue{heading/begingroup/section} ist
  dieses Argument leer. Da ein solcher leerer Parameter hier zu einer leeren
  Gruppe wird, ist es besser, diesen leeren Parameter quasi aufzubrauchen:
\begin{lstcode}
  \newcommand*{\stepcountergobble}[2]{%
    \stepcounter{#1}%
  }
  \AddtoDoHook{heading/begingroup/section}
              {\stepcountergobble{sectionZaehler}}
\end{lstcode}
  Somit wird der angehÃ¤ngte, leere Parameter von der neuen Anweisung
  \Macro{stepcountergobble} gelesen, aber nicht verwendet.

  Sollen nun statt \Macro{section} alle Gliederungsbefehle gezÃ¤hlt werden, so
  muss nur ein anderer Hakenname eingesetzt werden:
\begin{lstcode}
  \AddtoDoHook{heading/begingroup}
              {\stepcountergobble{sectionZaehler}}
\end{lstcode}
  Hier ist Ã¼brigens der angehÃ¤ngte Parameter nicht leer, sondern enthÃ¤lt den
  Namen der Gliederungsebene oder des Gliederungsbefehls. Wollte man die
  Gliederungsbefehle einzeln zÃ¤hlen, so kÃ¶nnte man genau dies ausnÃ¼tzen:
\begin{lstcode}
  \newcommand*{\stepZaehler}[1]{%
    \stepcounter{#1Zaehler}%
  }
  \AddtoDoHook{heading/begingroup}
              {\stepZaehler}
\end{lstcode}
  NatÃ¼rlich mÃ¼ssten dann auch die ZÃ¤hler \Counter{partZaehler},
  \Counter{chapterZaehler} bis hinunter zu \Counter{subparagraphZaehler}
  definiert werden.
\end{Example}

Die Anweisung \Macro{AddtoOneTimeDoHook}\textnote{einmalig} arbeitet
vergleichbar, fÃ¼gt den \PName{Befehl} aber dem Einmalcode hinzu. Dieser Code
wird dann nach der ersten AusfÃ¼hrung global vom Haken genommen.%
\EndIndexGroup

\begin{Declaration}
  \Macro{ForDoHook}\Parameter{Spezifikator}\Parameter{Befehl}
\end{Declaration}
WÃ¤hrend\ChangedAt[2019/01]{v3.27}{\Package{scrbase}}
\DescRef{\LabelBase.cmd.ExecuteDoHook} dazu gedacht ist, die Befehle
auszufÃ¼hren, die zuvor mit \DescRef{\LabelBase.cmd.AddtoDoHook} oder
\DescRef{\LabelBase.cmd.AddtoOneTimeDoHook} fÃ¼r die durch den
\PName{Spezifikator} bestimmten Haken gespeichert wurden, fÃ¼hrt diese Anweisung
den unmittelbar angegebenen \PName{Befehl} aus. Dabei werden an \PName{Befehl}
sogar zwei Parameter angefÃ¼gt. Der erste Parameter ist der Name des Haken, der
zweite das Argument des Hakens.

Diese Anweisung ist ein Abfallprodukt der Implementierung von
\DescRef{\LabelBase.cmd.ExecuteDoHook}. Normalerweise sollten weder Anwender
noch Paketautoren diese Anweisung benÃ¶tigen.%
\EndIndexGroup

\begin{Declaration}
  \Macro{SplitDoHook}\Parameter{Spezifikator}\Parameter{Kopf-Makro}
                     \Parameter{Rest-Makro}
\end{Declaration}
Wie\ChangedAt[2019/01]{v3.27}{\Package{scrbase}} aus den vorangegangenen
ErklÃ¤rungen deutlich wird, kann der Parameter eines mit
\DescRef{\LabelBase.cmd.AddtoDoHook} oder
\DescRef{\LabelBase.cmd.AddtoOneTimeDoHook} hinzugefÃ¼gten \PName{Befehls}
ebenfalls ein mehrteiliger \PName{Spezifikator} sein. Mit \Macro{SplitDoHook}
kann so ein \PName{Spezifikator} in das vordere Element und den Rest
aufgeteilt werden. Das \PName{Kopf-Makro} wird dabei als das vordere Element
definiert. Das \PName{Rest-Makro} wird als der Rest definiert. Im Falle, dass
kein Rest bleibt, wird das \PName{Rest-Makro} leer definiert. Falls bereits der
\PName{Spezifikator} leer war, wird eine Warnung ausgegeben und sowohl
\PName{Kopf-Makro} als auch \PName{Rest-Makro} leer definiert.

\begin{Example}
  Wollte man am Anfang der Gruppe, in der die Ãœberschrift ausgegeben wird,
  einen ZÃ¤hler erhÃ¶hen, diesen am Ende aber wieder verringern, so kÃ¶nnte man
  dies Ã¼ber zwei Haken tun:
\begin{lstcode}
  \AddtoDoHook{heading/begingroup}
              {\stepZaehler}
  \newcommand*{\restepZaehler}[1]{%
    \addtocounter{#1Zaehler}{-1}%
  }
  \AddtoDoHook{heading/endgroup}
              {\restepcounter}
\end{lstcode}
  Man kÃ¶nnte aber auch mit einem einzigen Haken arbeiten und dessen Parameter
  zerlegen:
\begin{lstcode}
  \newcommand*{\changeZaehler}[1]{%
    \SplitDoHook{#1}{\Gruppe}{\Ebene}%
    \Ifstr{\Gruppe}{begingroup}{%
      \stepcounter{\Ebene Zaehler}%
    }{%
      \Ifstr{\Gruppe}{endgroup}{%
        \addtocounter{\Ebene Zaehler}{-1}%
      }{}%
    }%
  }
  \AddtoDoHook{heading}
              {\changeZaehler}
\end{lstcode}
  Wie zu sehen ist, ist die erste LÃ¶sung um einiges einfacher. Dazu kommt,
  dass man die zweite Fallunterscheidung in der zweiten LÃ¶sung gerne
  vergisst. Das wÃ¤re allerdings fatal, da es weitere Haken mit Namen
  \PValue{heading} aber abweichendem Argument geben kann.
\end{Example}

Genau genommen ist diese Anweisung ein Abfallprodukt der Implementierung
von \DescRef{\LabelBase.cmd.ForDoHook}.%
\EndIndexGroup
%
\EndIndexGroup

\section{Obsolete Optionen und Anweisungen}
\seclabel{obsolete}

FrÃ¼here Versionen von \Package{scrbase} verfÃ¼gten Ã¼ber Optionen und
Anweisungen, die inzwischen entfernt oder ersetzt wurden. Diese sind hier nur
aus GrÃ¼nden der VollstÃ¤ndigkeit aufgefÃ¼hrt und sollten nicht mehr verwendet
werden.

\LoadNonFree{scrbase}{0}%
\EndIndexGroup

\endinput

%%% Local Variables: 
%%% mode: latex
%%% TeX-master: "scrguide-de.tex"
%%% coding: utf-8
%%% ispell-local-dictionary: "de_DE"
%%% eval: (flyspell-mode 1)
%%% End:

% LocalWords:  Paketoptionen Familienmitglieder Familienmitglieds SÃ¤umniswert
% LocalWords:  Fleischermeister FamilyProcessOptions ProcessOption keyval Cmd
% LocalWords:  documentclass ProcessOptions FamilyExecuteOptions currname
% LocalWords:  Optionenliste ExecuteOptions DeclareOption currext Wurstsalat
% LocalWords:  FamilyOptions FamilyKeyState Wurstpakete nonsense package true
% LocalWords:  Wurstpaket FamilyOption salatmit SalatZusatz scrbase false
% LocalWords:  AtEndOfFamilyOptions FamilyBoolKey FamilySetBool Schaltername
% LocalWords:  FamilyLengthKey FamilySetLength FamilyLengthMacroKey
% LocalWords:  FamilySetLengthMacro WertÃ¼bergabe Gliederungsbefehlen
% LocalWords:  Sternvariante Anwenderanweisungen Signalisierung Paketautoren
% LocalWords:  FamilienschlÃ¼ssel MitgliederschlÃ¼ssels Vergleichszustand
% LocalWords:  BenutzerÃ¤quivalent DokumentprÃ¤ambel voranzustellen
</pre></body></html>