Ich möchte hier zwei Möglichkeiten vorstellen, die das Gewünschte machen, aber (im Gegensatz zu [Clemens][1]’ bereits [ausführlichen Antwort][2]) Macros des [LaTeX-Kernels][3] verwenden, die das ganze Prozedere vereinfachen/verkürzen. **Version 1** gibt dabei eine Warnung aus, falls das Macro bereits definiert war, **Version 2** überschreibt das zu definierende Macro, komme was wolle. In beiden Fällen müssen wir aber erst mal schauen, ob dem Command ein Asterisk `*` folgt, das entscheidet, ob die folgende Definition `long` ist. (Mehr dazu unter [Was ist der Unterschied zwischen `\newcommand` und `\newcommand*`?][5] # `\@star@or@long` Alle Versionen von `\*command` und `\*environment` verwenden als erstes das Macro **`\\@star@or@long`**, das ein Argument erwartet (das Macro, was es nach getaner Arbeit ausführen soll). Es setzt **`\\l@ngrel@x`** entweder zu `\long` (kein `*`) oder `\relax` (mit `*`). Dieses Macro wird dann in der eigentlichen Definition dem `\def` vorangestellt. Soweit sehen beide Definition noch sehr ähnlich aus: % Version 1 \newcommand*\Newcommand{\@star@or@long\New@command} % Version 2 \newcommand*\NewCommand{\@star@or@long\New@Command} # Version 1 (mit Warnung) Das Macro **`\\New@command`** testet nun die ihm als Argument übergebene Macro-Sequenz `#1` mittels **`\\@ifundefined`**, dem wir das Macro aber ohne `\` übergeben müssen: \@ifundefined{\expandafter\@gobble\string#1}{}{% \@latex@warning@no@line{Redefining \string#1!}}% `\@ifundefined` setzt es dann mittels `\csname` gleich wieder zu einer Macro-Sequenz zusammen. Diese wird dann dann mithilfe von `\ifx` gegen `\relax` getestet, da alle `\csname`s von Macros, die undefiniert sind, bei einem `\ifx`-Test `\relax` gleichen. Ein ähnlicher Test hier wäre \ifx#1\@undefined\else\ifx#1\relax\else \@latex@warning@no@line{Redefining \string#1!}% \fi\fi der `#1` erst gegen `\@undefined` testet (das eben nicht definiert ist) und, falls das nicht wahr ist, noch gegen `\relax` testet (falls `#1` mit `\csname` erstellt wurde, siehe oben). Dieser Test findet so zum Beispiel auch von `\DeclareRobustCommand` verwendet. verwendet, das ebenfalls das Macro überschreibt und dann eine Warnung ausgibt. Es erstellt nur eben ein „robustes“ Macro, das für Macros wichtig ist, die in „moving arguments“, also zum Beispiel `\section`s oder `\caption`s verwendet wird. Anschließend wird die „magische“ Zeile \let\@ifdefinable\@rc@ifdefinable ausgeführt, die kurzer Hand den eigentlichen Test der Definierbarkeit aushebelt; `\@rc@ifdefinable` selbst stellt die originale Definition von `\@ifdefinable` dann wieder her (damit es beim nächsten Mal wieder ganz normal funktioniert). Die zu definierende Macro-Sequenz wird einfach an `\new@command` weitergeleitet, das dann den Rest übernimmt (Anzahl der Argumente sowie optionaler Default-Wert und eigentliche Definition). ## Code \newcommand*\Newcommand{\@star@or@long\New@command} \newcommand*\New@command[1]{% \@ifundefined{\expandafter\@gobble\string#1}{}{% \@latex@warning@no@line{Redefining \string#1!}}% \let\@ifdefinable\@rc@ifdefinable \new@command#1} # Version 2 (ohne Warnung) Möchte man sich die Warnung ersparen, macht man im Prinzip das Gleiche, nur lässt man den eigentlichen Test für die Warnung einfach weg und schaltet den folgenden Definierbarkeitstest mit der oben erwähnten „magischen“ Zeile ab. ## Code \newcommand*\NewCommand{\@star@or@long\New@Command} \newcommand*\New@Command[1]{\let\@ifdefinable\@rc@ifdefinable\new@command#1} ## Oder andersrum Man könnte den Test auch kurzer Hand austricken, in dem man das zu definierende Macro `#1` zu `\relax` lässt (siehe die Ausführung zu `\csname` und `\@ifundefined` oben): \newcommand*\New@Command[1]{\let#1\relax\new@command#1} Der Test wird dann aber unnötigerweise ausgeführt, mit `\@rc@ifdefinable` findet er aber nicht mal statt. Das wäre ein bisschen das Gegenteil von der `\providecommand`-`\renewcommand`-Lösung, die den Test von `\renewcommand` auf Definiertheit aushebelt, in dem das Macro eben einfach definiert wird, falls es noch nicht existierte. [1]: http://texwelt.de/wissen/benutzer/4/clemens [2]: http://texwelt.de/wissen/antwort_link/1589/ [3]: http://www.tex.ac.uk/CTAN/macros/latex/unpacked/latex.ltx [5]: http://texwelt.de/wissen/fragen/1587/wie-kann-ich-ein-makro-redefinieren-falls-existent-sonst-definieren

Ich möchte hier zwei Möglichkeiten vorstellen, die das Gewünschte machen, aber (im Gegensatz zu [Clemens][1]’ bereits [ausführlichen Antwort][2]) Macros des [LaTeX-Kernels][3] verwenden, die das ganze Prozedere vereinfachen/verkürzen. **Version 1** gibt dabei eine Warnung aus, falls das Macro bereits definiert war, **Version 2** überschreibt das zu definierende Macro, komme was wolle. In beiden Fällen müssen wir aber erst mal schauen, ob dem Command ein Asterisk `*` folgt, das entscheidet, ob die folgende Definition `long` ist. (Mehr dazu unter [Was ist der Unterschied zwischen `\newcommand` und `\newcommand*`?][5] # `\@star@or@long` Alle Versionen von `\*command` und `\*environment` verwenden als erstes das Macro **`\\@star@or@long`**, das ein Argument erwartet (das Macro, was es nach getaner Arbeit ausführen soll). Es setzt **`\\l@ngrel@x`** entweder zu `\long` (kein `*`) oder `\relax` (mit `*`). Dieses Macro wird dann in der eigentlichen Definition dem `\def` vorangestellt. Soweit sehen beide Definition noch sehr ähnlich aus: % Version 1 \newcommand*\Newcommand{\@star@or@long\New@command} % Version 2 \newcommand*\NewCommand{\@star@or@long\New@Command} # Version 1 (mit Warnung) Das Macro **`\\New@command`** testet nun die ihm als Argument übergebene Macro-Sequenz `#1` mittels **`\\@ifundefined`**, dem wir das Macro aber ohne `\` übergeben müssen, wobei müssen: \@ifundefined{\expandafter\@gobble\string#1}{}{% \@latex@warning@no@line{Redefining \string#1!}}% `\@ifundefined` setzt es dann mittels `\csname` gleich wieder mittels `\csname` zu einer Macro-Sequenz zusammenbaut. Es testet zusammen. Diese wird dann dann mithilfe von `\ifx` gegen `\relax`; `\relax` getestet, da alle `\csname`s von Macros, die undefiniert sind, gleichen bei einem `\ifx`-Test `\relax`. Falls dieser `\relax` gleichen. Ein ähnlicher Test hier wäre \ifx#1\@undefined\else\ifx#1\relax\else \@latex@warning@no@line{Redefining \string#1!}% \fi\fi der `#1` erst gegen `\@undefined` testet (das eben nicht definiert ist) und, falls das nicht wahr ist, noch gegen `\relax` testet (falls `#1` mit `\csname` erstellt wurde, siehe oben). Dieser Test findet so zum Beispiel auch von `\DeclareRobustCommand` verwendet. Anschließend wird nichts gemacht (`{}`); falls das Macro aber *wider Erwarten* doch bereits definiert ist, wird eine Warnung ausgegeben und die „magische“ Zeile \let\@ifdefinable\@rc@ifdefinable ausgeführt, die kurzer Hand den eigentlichen Test der Definierbarkeit aushebelt; `\@rc@ifdefinable` selbst stellt die originale Definition von `\@ifdefinable` dann wieder her (damit es beim nächsten Mal wieder ganz normal funktioniert). Die zu definierende Macro-Sequenz wird einfach an `\new@command` weitergeleitet, das dann den Rest übernimmt (Anzahl der Argumente sowie optionaler Default-Wert und eigentliche Definition). ## Code \newcommand*\Newcommand{\@star@or@long\New@command} \newcommand*\New@command[1]{% \@ifundefined{\expandafter\@gobble\string#1}{}{% \@latex@warning@no@line{Redefining \string#1!}% \let\@ifdefinable\@rc@ifdefinable}% \string#1!}}% \let\@ifdefinable\@rc@ifdefinable \new@command#1} # Version 2 (ohne Warnung) Möchte man sich die Warnung ersparen, macht man im Prinzip das Gleiche, nur lässt man den eigentlichen Test für die Warnung einfach weg und schaltet immer den folgenden Definierbarkeitstest mit der oben erwähnten „magischen“ Zeile ab. ## Code \newcommand*\NewCommand{\@star@or@long\New@Command} \newcommand*\New@Command[1]{\let\@ifdefinable\@rc@ifdefinable\new@command#1} ## Oder andersrum Man könnte den Test auch kurzer Hand austricken, in dem man das zu definierende Macro `#1` zu `\relax` lässt (siehe die Ausführung zu `\csname` und `\@ifundefined` oben): \newcommand*\New@Command[1]{\let#1\relax\new@command#1} Der Test wird dann aber unnötigerweise ausgeführt, mit `\@rc@ifdefinable` findet er aber nicht mal statt. Das wäre ein bisschen das Gegenteil von der `\providecommand`-`\renewcommand`-Lösung, die den Test von `\renewcommand` auf Definiertheit aushebelt, in dem das Macro eben einfach definiert wird, falls es noch nicht existierte. [1]: http://texwelt.de/wissen/benutzer/4/clemens [2]: http://texwelt.de/wissen/antwort_link/1589/ [3]: http://www.tex.ac.uk/CTAN/macros/latex/unpacked/latex.ltx [5]: http://texwelt.de/wissen/fragen/1587/wie-kann-ich-ein-makro-redefinieren-falls-existent-sonst-definieren

Ich möchte hier zwei Möglichkeiten vorstellen, die das Gewünschte machen, aber (im Gegensatz zu [Clemens][1]’ bereits [ausführlichen Antwort][2]) Macros des [LaTeX-Kernels][3] verwenden, die das ganze Prozedere vereinfachen/verkürzen. **Version 1** gibt dabei eine Warnung aus, falls das Macro bereits definiert war, **Version 2** überschreibt das zu definierende Macro, komme was wolle. In beiden Fällen müssen wir aber erst mal schauen, ob dem Command ein Asterisk `*` folgt, das entscheidet, ob die folgende Definition `long` ist. (Mehr dazu unter [Was ist der Unterschied zwischen `\newcommand` und `\newcommand*`?][5] # `\@star@or@long` Alle Versionen von `\*command` und `\*environment` verwenden als erstes das Macro **`\\@star@or@long`**, das ein Argument erwartet (das Macro, was es nach getaner Arbeit ausführen soll). Es setzt **`\\l@ngrel@x`** entweder zu `\long` (kein `*`) oder `\relax` (mit `*`). Dieses Macro wird dann in der eigentlichen Definition dem `\def` vorangestellt. Soweit sehen beide Definition noch sehr ähnlich aus: % Version 1 \newcommand*\Newcommand{\@star@or@long\New@command} % Version 2 \newcommand*\NewCommand{\@star@or@long\New@Command} # Version 1 (mit Warnung) Das Macro **`\\New@command`** testet nun die ihm als Argument übergebene Macro-Sequenz `#1` mittels **`\\@ifundefined`**, dem wir das Macro aber ohne `\` übergeben müssen, wobei `\@ifundefined` es dann gleich wieder mittels `\csname` zu einer Macro-Sequenz zusammenbaut. Es testet dann mithilfe von `\ifx` gegen `\relax`; alle `\csname`s von Macros, die undefiniert sind, gleichen bei einem `\ifx`-Test `\relax`. Falls dieser Test wahr ist, wird nichts gemacht (`{}`); falls das Macro aber *wider Erwarten* doch bereits definiert ist, wird eine Warnung ausgegeben und die „magische“ Zeile \let\@ifdefinable\@rc@ifdefinable ausgeführt, die kurzer Hand den eigentlichen Test der Definierbarkeit aushebelt; `\@rc@ifdefinable` selbst stellt die originale Definition von `\@ifdefinable` dann wieder her (damit es beim nächsten Mal wieder ganz normal funktioniert). Die zu definierende Macro-Sequenz wird einfach an `\new@command` weitergeleitet, das dann den Rest übernimmt (Anzahl der Argumente sowie optionaler Default-Wert und eigentliche Definition). ## Code \newcommand*\Newcommand{\@star@or@long\New@command} \newcommand*\New@command[1]{% \@ifundefined{\expandafter\@gobble\string#1}{}{% \@latex@warning@no@line{Redefining \string#1!}% \let\@ifdefinable\@rc@ifdefinable}% \new@command#1} # Version 2 (ohne Warnung) Möchte man sich die Warnung ersparen, macht man im Prinzip das Gleiche, nur lässt gleich man den eigentlichen Test für die Warnung einfach weg und schaltet immer den folgenden Definierbarkeitstest mit der oben erwähnten „magischen“ Zeile ab. ## Code \newcommand*\NewCommand{\@star@or@long\New@Command} \newcommand*\New@Command[1]{\let\@ifdefinable\@rc@ifdefinable\new@command#1} ## Oder andersrum Man könnte den Test auch kurzer Hand austricken, in dem man das zu definierende Macro `#1` zu `\relax` lässt (siehe die Ausführung zu `\csname` und `\@ifundefined` oben): \newcommand*\New@Command[1]{\let#1\relax\new@command#1} Der Test wird dann aber unnötigerweise ausgeführt, mit `\@rc@ifdefinable` findet er aber nicht mal statt. Das wäre ein bisschen das Gegenteil von der `\providecommand`-`\renewcommand`-Lösung, die den Test von `\renewcommand` auf Definiertheit aushebelt, in dem das Macro eben einfach definiert wird, falls es noch nicht existierte. [1]: http://texwelt.de/wissen/benutzer/4/clemens [2]: http://texwelt.de/wissen/antwort_link/1589/ [3]: http://www.tex.ac.uk/CTAN/macros/latex/unpacked/latex.ltx [5]: http://texwelt.de/wissen/fragen/1587/wie-kann-ich-ein-makro-redefinieren-falls-existent-sonst-definieren

Ich möchte hier zwei Möglichkeiten vorstellen, die das Gewünschte machen. ## machen, aber (im Gegensatz zu [Clemens][1]’ bereits [ausführlichen Antwort][2]) Macros des [LaTeX-Kernels][3] verwenden, die das ganze Prozedere vereinfachen/verkürzen. **Version 1** gibt dabei eine Warnung aus, falls das Macro bereits definiert war, **Version 2** überschreibt das zu definierende Macro, komme was wolle. In beiden Fällen müssen wir aber erst mal schauen, ob dem Command ein Asterisk `*` folgt, das entscheidet, ob die folgende Definition `long` ist. (Mehr dazu unter [Was ist der Unterschied zwischen `\newcommand` und `\newcommand*`?][5] # `\@star@or@long` Alle Versionen von `\*command` und `\*environment` verwenden als erstes das Macro **`\\@star@or@long`**, das ein Argument erwartet (das Macro, was es nach getaner Arbeit ausführen soll). Es setzt **`\\l@ngrel@x`** entweder zu `\long` (kein `*`) oder `\relax` (mit `*`). Dieses Macro wird dann in der eigentlichen Definition dem `\def` vorangestellt. Soweit sehen beide Definition noch sehr ähnlich aus: % Version 1 \newcommand*\Newcommand{\@star@or@long\New@command} % Version 2 \newcommand*\NewCommand{\@star@or@long\New@Command} # Version 1 (mit Warnung) Diese Version macht in etwa das Gleiche, was [Clemens][1] in [seiner Antwort][2] erstellt hat, sie verwendet allerdings die originalen LaTeX-Macros, die auch von `\newcommand`, `\renewcommand`, etc. verwendet werden. Das Macro **`\\@star@or@long`** \def\@star@or@long#1{% \@ifstar {\let\l@ngrel@x\relax#1}% {\let\l@ngrel@x\long#1}} übernimmt dabei die Aufgabe den Asterisk `*` zu verarbeiten, die Information darüber wird in einem Macro **`\\l@ngrel@x`** gespeichert, das entweder zu `\long` or zu `\relax` gelassen (`\let`) wurde und somit direkt vor dem eigentlichen `\def`, das das Macro definiert, gestellt werden kann. Das Macro **`\\New@command`** testet dann die zu definierende nun die ihm als Argument übergebene Macro-Sequenz `#1` mittels **`\\@ifundefined`**, dem wir das Macro aber ohne `\` übergeben, übergeben müssen, wobei `\@ifundefined` es dann nichts anderes macht als es gleich wieder mittels `\csname` zu einer Macro-Sequenz zusammenbaut. Es testet dann mithilfe von `\ifx` gegen `\relax`, da `\relax`; alle `\csname`s von Macros, die undefiniert sind, `\relax` gleichen. gleichen bei einem `\ifx`-Test `\relax`. Falls dieser Test wahr ist, wird nichts gemacht (`{}`); falls das Macro aber *wider Erwarten* doch bereits definiert ist, wird eine Warnung ausgegeben und die „magische“ Zeile \let\@ifdefinable\@rc@ifdefinable ausgeführt, die kurzer Hand den eigentlichen Test der Definierbarkeit aushebelt; `\@rc@ifdefinable` selbst stellt die originale Definition von `\@ifdefinable` dann wieder her (damit es beim nächsten Mal wieder ganz normal funktioniert). Die zu definierende Macro-Sequenz wird einfach an `\new@command` weitergeleitet, das dann den Rest übernimmt (Anzahl der Argumente sowie optionaler Default-Wert). Default-Wert und eigentliche Definition). ## Code \newcommand*\Newcommand{\@star@or@long\New@command} \newcommand*\New@command[1]{% \@ifundefined{\expandafter\@gobble\string#1}{}{% \@latex@warning@no@line{Redefining \string#1!}% \let\@ifdefinable\@rc@ifdefinable}% \new@command#1} # Version 2 (ohne Warnung) Möchte man sich die Warnung ersparen, macht man im Prinzip das Gleiche, nur lässt man eben gleich den eigentlichen Test für die Warnung weg und schaltet eben immer den Test auf Definierbarkeit ab (siehe „magische“ Zeile). folgenden Definierbarkeitstest mit der oben erwähnten „magischen“ Zeile ab. ## Code \newcommand*\NewCommand{\@star@or@long\New@Command} \newcommand*\New@Command[1]{\let\@ifdefinable\@rc@ifdefinable\new@command#1} ## Oder andersrum Man könnte den Test auch kurzer Hand austricken, in dem man das zu definierende Macro `#1` zu `\relax` lässt (siehe die Ausführung zu `\csname` und `\@ifundefined`): \let#1\relax `\@ifundefined` oben): \newcommand*\New@Command[1]{\let#1\relax\new@command#1} Der Test wird dann aber unnötigerweise ausgeführt, mit `\@rc@ifdefinable` findet er aber nicht mal statt. Das ist wäre ein bisschen das Gegenteil von der `\providecommand`-`\renewcommand`-Lösung, die den Test von `\renewcommand` auf Definiertheit aushebelt, in dem das Macro eben einfach definiert wird, falls es noch nicht existierte. ## Code 1 (mit Warnung, kleines `c`) \newcommand*\Newcommand{\@star@or@long\New@command} \newcommand*\New@command[1]{% \@ifundefined{\expandafter\@gobble\string#1}{}{% \@latex@warning@no@line{Redefining \string#1!}% \let\@ifdefinable\@rc@ifdefinable}% \new@command#1} ## Code 2 (ohne Warnung, großes `C`) \newcommand*\NewCommand{\@star@or@long\New@Command} \newcommand*\New@Command[1]{\let\@ifdefinable\@rc@ifdefinable\new@command#1} [1]: http://texwelt.de/wissen/benutzer/4/clemens [2]: http://texwelt.de/wissen/antwort_link/1589/http://texwelt.de/wissen/antwort_link/1589/ [3]: http://www.tex.ac.uk/CTAN/macros/latex/unpacked/latex.ltx [5]: http://texwelt.de/wissen/fragen/1587/wie-kann-ich-ein-makro-redefinieren-falls-existent-sonst-definieren

Ich möchte hier zwei Möglichkeiten vorstellen, die das Gewünschte machen. ## Version 1 (mit Warnung) Diese Version macht in etwa das Gleiche, was [Clemens][1] in [seiner Antwort][2] erstellt hat, sie verwendet allerdings die originalen LaTeX-Macros, die auch von `\newcommand`, `\renewcommand`, etc. verwendet werden. Das Macro **`\\@star@or@long`** \def\@star@or@long#1{% \@ifstar {\let\l@ngrel@x\relax#1}% {\let\l@ngrel@x\long#1}} übernimmt dabei die Aufgabe den Asterisk `*` zu verarbeiten, die Information darüber wird in einem Macro **`\\l@ngrel@x`** gespeichert, das entweder zu `\long` or zu `\relax` gelassen (`\let`) wurde und somit direkt vor dem eigentlichen `\def`, das das Macro definiert, gestellt werden kann. Das Macro **`\\New@command`** testet dann die zu definierende Macro-Sequenz mittels **`\@ifundefined`**, **`\\@ifundefined`**, dem wir das Macro ohne `\` übergeben, wobei es dann nichts anderes macht als es wieder mittels `\csname` zu einer Macro-Sequenz zusammenbaut. Es testet dann mithilfe von `\ifx` gegen `\relax`, da alle `\csname`s von Macros, die undefiniert sind, `\relax` gleichen. Falls dieser Test wahr ist, wird nichts gemacht (`{}`); falls das Macro aber *wider Erwarten* doch bereits definiert ist, wird eine Warnung ausgegeben und die „magische“ Zeile \let\@ifdefinable\@rc@ifdefinable ausgeführt, die kurzer Hand den eigentlichen Test der Definierbarkeit aushebelt; `\@rc@ifdefinable` selbst stellt die originale Definition von `\@ifdefinable` dann wieder her (damit es beim nächsten Mal wieder ganz normal funktioniert). Die zu definierende Macro-Sequenz wird einfach an `\new@command` weitergeleitet, das dann den Rest übernimmt (Anzahl der Argumente sowie optionaler Default-Wert). ## Version 2 (ohne Warnung) Möchte man sich die Warnung ersparen, macht man im Prinzip das Gleiche, nur lässt man eben den eigentlichen Test weg und schaltet eben immer den Test auf Definierbarkeit ab (siehe „magische“ Zeile). Man könnte den Test auch kurzer Hand austricken, in dem man das zu definierende Macro `#1` zu `\relax` lässt (siehe die Ausführung zu `\csname` und `\@ifundefined`): \let#1\relax Der Test wird dann aber unnötigerweise ausgeführt, mit `\@rc@ifdefinable` findet er aber nicht mal statt. Das ist ein bisschen das Gegenteil von der `\providecommand`-`\renewcommand`-Lösung, die den Test von `\renewcommand` auf Definiertheit aushebelt, in dem das Macro eben einfach definiert wird, falls es noch nicht existierte. ## Code 1 (mit Warnung, kleines `c`) \newcommand*\Newcommand{\@star@or@long\New@command} \newcommand*\New@command[1]{% \@ifundefined{\expandafter\@gobble\string#1}{}{% \@latex@warning@no@line{Redefining \string#1!}% \let\@ifdefinable\@rc@ifdefinable}% \new@command#1} ## Code 2 (ohne Warnung, großes `C`) \newcommand*\NewCommand{\@star@or@long\New@Command} \newcommand*\New@Command[1]{\let\@ifdefinable\@rc@ifdefinable\new@command#1} [1]: http://texwelt.de/wissen/benutzer/4/clemens [2]: http://texwelt.de/wissen/antwort_link/1589/

Ich möchte hier zwei Möglichkeiten vorstellen, die das Gewünschte machen. ## Version 1 (mit Warnung) Diese Version macht in etwa das Gleiche, was [Clemens][1] in [seiner Antwort][2] erstellt hat, sie verwendet allerdings die originalen LaTeX-Macros, die auch von `\newcommand`, `\renewcommand`, etc. verwendet werden. Das Macro **`\@star@or@long`** **`\\@star@or@long`** \def\@star@or@long#1{% \@ifstar {\let\l@ngrel@x\relax#1}% {\let\l@ngrel@x\long#1}} übernimmt dabei die Aufgabe den Asterisk `*` zu verarbeiten, die Information darüber wird in einem Macro **`\l@ngrel@x`** **`\\l@ngrel@x`** gespeichert, das entweder zu `\long` or zu `\relax` gelassen (`\let`) wurde und somit direkt vor dem eigentlichen `\def`, das das Macro definiert, gestellt werden kann. Das Macro **`\New@command`** **`\\New@command`** testet dann die zu definierende Macro-Sequenz mittels **`\@ifundefined`**, dem wir das Macro ohne `\` übergeben, wobei es dann nichts anderes macht als es wieder mittels `\csname` zu einer Macro-Sequenz zusammenbaut. Es testet dann mithilfe von `\ifx` gegen `\relax`, da alle `\csname`s von Macros, die undefiniert sind, `\relax` gleichen. Falls dieser Test wahr ist, wird nichts gemacht (`{}`); falls das Macro aber *wider Erwarten* doch bereits definiert ist, wird eine Warnung ausgegeben und die „magische“ Zeile \let\@ifdefinable\@rc@ifdefinable ausgeführt, die kurzer Hand den eigentlichen Test der Definierbarkeit aushebelt; `\@rc@ifdefinable` selbst stellt die originale Definition von `\@ifdefinable` dann wieder her (damit es beim nächsten Mal wieder ganz normal funktioniert). Die zu definierende Macro-Sequenz wird einfach an `\new@command` weitergeleitet, das dann den Rest übernimmt (Anzahl der Argumente sowie optionaler Default-Wert). ## Version 2 (ohne Warnung) Möchte man sich die Warnung ersparen, macht man im Prinzip das Gleiche, nur lässt man eben den eigentlichen Test weg und schaltet eben immer den Test auf Definierbarkeit ab (siehe „magische“ Zeile). Man könnte den Test auch kurzer Hand austricken, in dem man das zu definierende Macro `#1` zu `\relax` lässt (siehe die Ausführung zu `\csname` und `\@ifundefined`): \let#1\relax Der Test wird dann aber unnötigerweise ausgeführt, mit `\@rc@ifdefinable` findet er aber nicht mal statt. Das ist ein bisschen das Gegenteil von der `\providecommand`-`\renewcommand`-Lösung, die den Test von `\renewcommand` auf Definiertheit aushebelt, in dem das Macro eben einfach definiert wird, falls es noch nicht existierte. ## Code 1 (mit Warnung, kleines `c`) \newcommand*\Newcommand{\@star@or@long\New@command} \newcommand*\New@command[1]{% \@ifundefined{\expandafter\@gobble\string#1}{}{% \@latex@warning@no@line{Redefining \string#1!}% \let\@ifdefinable\@rc@ifdefinable}% \new@command#1} ## Code 2 (ohne Warnung, großes `C`) \newcommand*\NewCommand{\@star@or@long\New@Command} \newcommand*\New@Command[1]{\let\@ifdefinable\@rc@ifdefinable\new@command#1} [1]: http://texwelt.de/wissen/benutzer/4/clemens [2]: http://texwelt.de/wissen/antwort_link/1589/

Ich möchte hier zwei Möglichkeiten vorstellen, die das Gewünschte machen. ## Version 1 (mit Warnung) Diese Version macht das, in etwa das Gleiche, was [Clemens][1] in [seiner Antwort][2] gemacht erstellt hat, nur mit den original sie verwendet allerdings die originalen LaTeX-Macros, die auch in von `\newcommand`, `\renewcommand`, etc. verwendet werden. Das Macro `\@star@or@long` **`\@star@or@long`** \def\@star@or@long#1{% \@ifstar {\let\l@ngrel@x\relax#1}% {\let\l@ngrel@x\long#1}} übernimmt dabei die Aufgabe den Asterisk `*` zu verarbeiten, die Information darüber wird in einem Macro zwischengespeichert, **`\l@ngrel@x`** gespeichert, das entweder zu `\long` or zu `\relax` gelassen (`\let`) wird wurde und so dann somit direkt vor dem eigentlichen `\def` des zu definierenden Macros `\def`, das das Macro definiert, gestellt werden kann. Der Befehl `\New@command` Das Macro **`\New@command`** testet dann das die zu definierende Macro gegen Macro-Sequenz mittels dem bereits in Clemens’ Antwort benutzten `\@ifundefined`, **`\@ifundefined`**, dem wir das Macro ohne `\` übergeben, wobei es dann nichts anderes macht als es wieder mittels `\csname` zu einer Macro-Sequenz zusammenbaut, um es zusammenbaut. Es testet dann mit mithilfe von `\ifx` gegen `\relax` zu testen. (Alle `\relax`, da alle `\csname`s von Macros, die undefiniert sind, sind `\relax`.) `\relax` gleichen. Falls dieser Test wahr ist, wird nichts gemacht (`{}`); falls das Macro aber wider Erwarten *wider Erwarten* doch bereits definiert ist, wird eine Warnung ausgegeben und die „magische“ Zeile \let\@ifdefinable\@rc@ifdefinable ausgeführt, die kurzer Hand den eigentlichen Test der Definierbarkeit aushebelt (die sich aber aushebelt; `\@rc@ifdefinable` selbst stellt die originale Definition von `\@ifdefinable` dann wieder sofort aktiviert). her (damit es beim nächsten Mal wieder ganz normal funktioniert). Die zu definierende Macro-Sequenz wird dann kurzer Hand einfach an `\new@command` weitergeleitet, die das dann den Rest übernimmt (Anzahl der Argumente sowie optionaler Default-Wert). ## Version 2 (ohne Warnung) Möchte man sich die Warnung ersparen, macht man das Gleiche (Version 2), im Prinzip das Gleiche, nur dass lässt man sich den eigenen Test spart eben den eigentlichen Test weg und direkt schaltet eben immer den Test auf Definierbarkeit abschaltet ab (siehe „magische“ Zeile). ---- Man könnte den Test auch kurzer Hand austricken austricken, in dem man eben das zu definierende Macro `#1` zu `\relax` lässt: lässt (siehe die Ausführung zu `\csname` und `\@ifundefined`): \let#1\relax Der Test wird dann aber unnötigerweise ausgeführt, mit `\@rc@ifdefinable` findet er aber nicht mal statt. Das ist ein bisschen das Gegenteil von der `\providecommand`-`\renewcommand`-Lösung, die den Test von `\renewcommand` auf Definiertheit aushebelt, in dem das Macro eben einfach definiert, wenn definiert wird, falls es noch nicht existierte. ## Code 1 (mit Warnung, kleines `c`) \newcommand*\Newcommand{\@star@or@long\New@command} \newcommand*\New@command[1]{% \@ifundefined{\expandafter\@gobble\string#1}{}{% \@latex@warning@no@line{Redefining \string#1!}% \let\@ifdefinable\@rc@ifdefinable}% \new@command#1} ## Code 2 (ohne Warnung, großes `C`) \newcommand*\NewCommand{\@star@or@long\New@Command} \newcommand*\New@Command[1]{\let\@ifdefinable\@rc@ifdefinable\new@command#1} [1]: http://texwelt.de/wissen/benutzer/4/clemens [2]: http://texwelt.de/wissen/antwort_link/1589/

Ich möchte hier zwei Möglichkeiten vorstellen, die das Gewünschte machen. Version 1 macht das, was [Clemens][1] in [seiner Antwort][2] gemacht hat, nur mit den original LaTeX-Macros, die auch in `\newcommand`, `\renewcommand`, etc. verwendet werden. Das Macro `\@star@or@long` übernimmt dabei die Aufgabe auf den Asterisk `*` zu verarbeiten, die Information darüber wird in einem Macro zwischengespeichert (das wird zwischengespeichert, das entweder zu `\long` or zu `\relax` gelassen) gelassen (`\let`) wird und so dann direkt vor dem eigentlichen `\def` des zu definierenden Macros gestellt. gestellt werden kann. Der Befehl `\New@command` testet dann das zu definierende Macro gegen mittels dem bereits in Clemens’ Antwort benutzten `\@ifundefined`, dem wir das Macro ohne `\` übergeben, wobei es dann nichts anderes macht als es wieder mittels `\csname` zu einer Macro-Sequenz zusammenbaut, um es dann mit `\ifx` gegen `\relax` zu testen. (Alle `\csname`s von Macros, die undefiniert sind, sind `\relax`.) Falls dieser Test wahr ist, wird nichts gemacht (`{}`); falls das Macro aber wider Erwarten doch bereits definiert ist, wird eine Warnung ausgegeben und die „magische“ Zeile \let\@ifdefinable\@rc@ifdefinable ausgeführt, die kurzer Hand den eigentlichen Test der Definierbarkeit aushebelt (die sich aber selbst wieder sofort aktiviert). Die zu definierende Macro-Sequenz wird dann kurzer Hand einfach an `\new@command` weitergeleitet, die dann den Rest übernimmt (Anzahl der Argumente sowie optionaler Default-Wert). Möchte man sich die Warnung ersparen, macht man das Gleiche (Version 2), nur dass man sich den eigenen Test spart und direkt den Test auf Definierbarkeit abschaltet (siehe „magische“ Zeile). ---- Man könnte den Test auch kurzer Hand austricken in dem man eben das zu definierende Macro `#1` zu `\relax` lässt: \let#1\relax Der Test wird dann aber unnötigerweise ausgeführt, mit `\@rc@ifdefinable` findet er aber nicht mal statt. Das ist ein bisschen das Gegenteil von der `\providecommand`-`\renewcommand`-Lösung, die den Test von `\renewcommand` auf Definiertheit aushebelt, in dem das Macro eben einfach definiert, wenn es noch nicht existierte. ## Code 1 (mit Warnung, kleines `c`) \newcommand*\Newcommand{\@star@or@long\New@command} \newcommand*\New@command[1]{% \@ifundefined{\expandafter\@gobble\string#1}{}{% \@latex@warning@no@line{Redefining \string#1!}% \let\@ifdefinable\@rc@ifdefinable}% \new@command#1} ## Code 2 (ohne Warnung, großes `C`) \newcommand*\NewCommand{\@star@or@long\New@Command} \newcommand*\New@Command[1]{\let\@ifdefinable\@rc@ifdefinable\new@command#1} [1]: http://texwelt.de/wissen/benutzer/4/clemens [2]: http://texwelt.de/wissen/antwort_link/1589/

Ich möchte hier zwei Möglichkeiten vorstellen, die das Gewünschte machen. Version 1 macht das, was [Clemens][1] in [seiner Antwort][2] gemacht hat, nur mit den original LaTeX-Macros, die auch in `\newcommand`, `\renewcommand`, etc. verwendet werden. Das Macro `\@star@or@long` übernimmt dabei die Aufgabe auf den Asterisk `*` zu verarbeiten, die Information darüber wird in einem Macro zwischengespeichert (das wird entweder zu `\long` or zu `\relax` gelassen) und dann direkt vor dem eigentlichen `\def` des zu definierenden Macros gestellt. Der Befehl `\New@command` testet dann das zu definierende Macro gegen mittels dem bereits in Clemens’ Antwort benutzten `\@ifundefined`, dem wir das Macro ohne `\` übergeben, wobei es dann nichts anderes macht als es wieder mittels `\csname` zu einer Macro-Sequenz zusammenbaut, um es dann mit `\ifx` gegen `\relax` zu testen. (Alle `\csname`s von Macros, die undefiniert sind, sind `\relax`.) Falls dieser Test wahr ist, wird nichts gemacht (`{}`); falls das Macro aber wider Erwarten doch bereits definiert ist, wird eine Warnung ausgegeben und die „magische“ Zeile \let\@ifdefinable\@rc@ifdefinable ausgeführt, die kurzer Hand den eigentlichen Test der Definierbarkeit aushebelt (die sich aber selbst wieder sofort aktiviert). Die zu definierende Macro-Sequenz wird dann kurzer Hand einfach an `\new@command` weitergeleitet, die dann den Rest übernimmt (Anzahl der Argumente sowie optionaler Default-Wert). Möchte man sich die Warnung ersparen, macht man das Gleiche, Gleiche (Version 2), nur dass man sich den eigenen Test spart und direkt den Test auf Definierbarkeit abschaltet (siehe „magische“ Zeile). ---- Man könnte den Test auch kurzer Hand austricken in dem man eben das zu definierende Macro `#1` zu `\relax` lässt: \let#1\relax Der Test wird dann aber unnötigerweise ausgeführt, mit `\@rc@ifdefinable` findet er aber nicht mal statt. Das ist ein bisschen das Gegenteil von der `\providecommand`-`\renewcommand`-Lösung, die den Test von `\renewcommand` auf Definiertheit aushebelt, in dem das Macro eben einfach definiert, wenn es noch nicht existierte. ## Code 1 (mit Warnung, kleines `c`) \newcommand*\Newcommand{\@star@or@long\New@command} \newcommand*\New@command[1]{% \@ifundefined{\expandafter\@gobble\string#1}{}{% \@latex@warning@no@line{Redefining \string#1!}% \let\@ifdefinable\@rc@ifdefinable}% \new@command#1} ## Code 2 (ohne Warnung, großes `C`) \newcommand*\NewCommand{\@star@or@long\New@Command} \newcommand*\New@Command[1]{\let\@ifdefinable\@rc@ifdefinable\new@command#1} [1]: http://texwelt.de/wissen/benutzer/4/clemens [2]: http://texwelt.de/wissen/antwort_link/1589/

Ich möchte hier zwei Möglichkeiten vorstellen, die das Gewünschte machen (ob es sinnvoll ist oder nicht sei mal dahin gestellt). machen. Version 1 macht das, was [Clemens][1] in [seiner Antwort][2] gemacht hat, nur mit den original LaTeX-Macros, die auch in `\newcommand`, `\renewcommand`, etc. verwendet werden. Das Macro `\@star@or@long` übernimmt dabei die Aufgabe auf den Asterisk `*` zu verarbeiten, die Information darüber wird in einem Macro zwischengespeichert (das wird entweder zu `\long` or zu `\relax` gelassen) und dann direkt vor dem eigentlichen `\def` des zu definierenden Macros gestellt. Der Befehl `\New@command` testet dann das zu definierende Macro gegen mittels dem bereits in Clemens’ Antwort benutzten `\@ifundefined`, dem wir das Macro ohne `\` übergeben, wobei es dann nichts anderes macht als es wieder mittels `\csname` zu einer Macro-Sequenz zusammenbaut, um es dann mit `\ifx` gegen `\relax` zu testen. (Alle `\csname`s von Macros, die undefiniert sind, sind `\relax`.) Falls dieser Test wahr ist, wird nichts gemacht (`{}`); falls das Macro aber wider Erwarten doch bereits definiert ist, wird eine Warnung ausgegeben und die „magische“ Zeile \let\@ifdefinable\@rc@ifdefinable ausgeführt, die kurzer Hand den eigentlichen Test der Definierbarkeit aushebelt (die sich aber selbst wieder sofort aktiviert). Die zu definierende Macro-Sequenz wird dann kurzer Hand einfach an `\new@command` weitergeleitet, die dann den Rest übernimmt (Anzahl der Argumente sowie optionaler Default-Wert). Möchte man sich die Warnung ersparen, macht man das gleiche, Gleiche, nur dass man sich den eigenen Test spart und direkt den Test auf Definierbarkeit abschaltet (siehe „magische“ Zeile). ---- Man könnte den Test auch kurzer Hand austricken in dem man eben das zu definierende Macro `#1` zu `\relax` lässt: \let#1\relax Der Test wird dann aber unnötigerweise ausgeführt, mit `\@rc@ifdefinable` wird findet er aber nicht mal durchgeführt. statt. Das ist ein bisschen das Gegenteil von der `\providecommand`-`\renewcommand`-Lösung, die den Test von `\renewcommand` auf Definiertheit aushebelt, in dem das Macro eben einfach definiert, wenn es noch nicht existierte. ## Code 1 (mit Warnung) Warnung, kleines `c`) \newcommand*\Newcommand{\@star@or@long\New@command} \newcommand*\New@command[1]{% \@ifundefined{\expandafter\@gobble\string#1}{}{% \@latex@warning@no@line{Redefining \string#1!}% \let\@ifdefinable\@rc@ifdefinable}% \new@command#1} ## Code 2 (ohne Warnung) Warnung, großes `C`) \newcommand*\NewCommand{\@star@or@long\New@Command} \newcommand*\New@Command[1]{\let\@ifdefinable\@rc@ifdefinable\new@command#1} [1]: http://texwelt.de/wissen/benutzer/4/clemens [2]: http://texwelt.de/wissen/antwort_link/1589/

Ich möchte hier zwei Möglichkeiten vorstellen, die das Gewünschte machen (ob es sinnvoll ist oder nicht sei mal dahin gestellt). Version 1 macht das, was [Clemens][1] in [seiner Antwort][2] gemacht hat, nur mit den original LaTeX-Macros, die auch in `\newcommand`, `\renewcommand`, etc. verwendet werden. Das Macro `\@star@or@long` übernimmt dabei die Aufgabe auf den Asterisk `*` zu verarbeiten, die Information darüber wird in einem Macro zwischengespeichert (das wird entweder zu `\long` or zu `\relax` gelassen) und dann direkt vor dem eigentlichen `\def` des zu definierenden Macros gestellt. Der Befehl `\New@command` testet dann das zu definierende Macro gegen mittels dem bereits in Clemens’ Antwort benutzten `\@ifundefined`, dem wir das Macro ohne `\` übergeben, wobei es dann nichts anderes macht als es wieder mittels `\csname` zu einer Macro-Sequenz zusammenbaut, um es dann mit `\ifx` gegen `\relax` zu testen. (Alle `\csname`s von Macros, die undefiniert sind, sind `\relax`.) Falls dieser Test wahr ist, wird nichts gemacht (`{}`); falls das Macro aber wider Erwarten doch bereits definiert ist, wird eine Warnung ausgegeben und die „magische“ Zeile \let\@ifdefinable\@rc@ifdefinable ausgeführt, die kurzer Hand den eigentlichen Test der Definierbarkeit aushebelt (die sich aber selbst wieder sofort aktiviert). Die zu definierende Macro-Sequenz wird dann kurzer Hand einfach an `\new@command` weitergeleitet, die dann den Rest übernimmt (Anzahl der Argumente sowie optionaler Default-Wert). Möchte man sich die Warnung ersparen, macht man das gleiche, nur dass man sich den eigenen Test spart und direkt den Test auf Definierbarkeit abschaltet (siehe „magische“ Zeile). ---- Man könnte den Test auch kurzer Hand austricken in dem man eben das zu definierende Macro `#1` zu `\relax` lässt: \let#1\relax Der Test wird dann aber unnötigerweise ausgeführt, mit `\@rc@ifdefinable` wird er aber nicht mal durchgeführt. ## Code 1 (mit Warnung) \newcommand*\Newcommand{\@star@or@long\New@command} \newcommand*\New@command[1]{% \@ifundefined{\expandafter\@gobble\string#1}{}{% \@latex@warning@no@line{Redefining \string#1!}% \let\@ifdefinable\@rc@ifdefinable}% \new@command#1} ## Code 2 (ohne Warnung) \newcommand*\NewCommand{\@star@or@long\New@Command} \newcommand*\New@Command[1]{\let\@ifdefinable\@rc@ifdefinable\new@command#1} [1]: http://texwelt.de/wissen/benutzer/4/clemens [2]: http://texwelt.de/wissen/antwort_link/1589/