/*
 * Wine command prompt
 * German Language Support
 *
 * Copyright 2004 Henning Gerhardt
 * Copyright 2009 André Hentschel
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 */

#include "wcmd.h"

#pragma code_page(65001)

LANGUAGE LANG_GERMAN, SUBLANG_NEUTRAL

STRINGTABLE
{
  WCMD_ATTRIB, "ATTRIB zeigt oder ändert die DOS Dateieigenschaften.\n"
  WCMD_CALL,
"CALL <Batchdateiname> wird in einer Batchdatei genutzt, um Befehle aus\n\
einer anderen Batchdatei auszuführen. Wenn die Batchdatei exisiert, kehrt\n\
die Kontrolle zu der Datei zurück, die sie aufgerufen hat. Der CALL Befehl kann\n\
Parameter zu der rufenden Prozedure übergeben.\n\
\n\
Änderungen für das aktuelle Verzeichnis, Umgebungsvariablen usw. werden in\n\
der gerufenen Prozedur gemacht, die sie von der aufgerufenen geerbt hat.\n"

  WCMD_CD,     "CD ist die Kurzform von CHDIR.\n"
  WCMD_CHDIR,  "CHDIR Wechselt in ein Verzeichnis.\n"

  WCMD_CLS,    "CLS löscht den Bildschirminhalt der Konsole.\n"

  WCMD_COPY,   "COPY Kopiert eine Datei.\n"
  WCMD_CTTY,   "CTTY Ändert das Eingabe/Ausgabe - Gerät.\n"
  WCMD_DATE,   "DATE zeigt oder ändert das Systemdatum.\n"
  WCMD_DEL,    "DEL löscht eine oder mehrere Dateien\n"
  WCMD_DIR,    "DIR listet den Inhalt eines Verzeichnisses.\n"

  WCMD_ECHO,
"ECHO <Zeichenkette> zeigt die <Zeichenkette> auf dem aktuellen Terminalgerät.\n\
\n\
ECHO ON bewirkt, dass alle nachfolgenden Befehle in einer Batchdatei zuerst\n\
auf dem Terminalgerät angezeigt und danach ausgeführt werden.\n\
\n\
ECHO OFF kehrt den Effekt des vorherigen ECHO ON (ECHO ist standardmässig\n\
auf OFF) um. Um den ECHO OFF Befehl nicht anzeigen zu lassen, kann vor dessen\n\
ein @ Zeichen gesetzt werden.\n"

  WCMD_ERASE,  "ERASE löscht die angegebenen Dateien.\n"

  WCMD_FOR,
"Der FOR Befehl wird genutzt, um einen Befehl für eine Menge von Dateien\n\
einzeln auszuführen.\n\
\n\
Syntax: FOR %Variable IN (set) DO Befehl\n\
\n\
Die Anforderung das % Zeichen zu verdoppeln, sobald FOR in einer Batchdatei\n\
benutzt wird, existiert in CMD nicht.\n"

  WCMD_GOTO,
"Der GOTO Befehl transferiert die Ausführung zu einer anderen Stelle in einer\n\
Batchdatei.\n\
\n\
Die Bezeichnung, die das Ziel eines GOTO's ist, kann bis zu 255 Zeichen lang\n\
sein, darf aber keine Leerzeichen enthalten (dies ist der Unterschied zu\n\
anderen Betriebssystemen). Wenn zwei oder mehr identische Bezeichnungen in\n\
einer Batchdatei existieren, dann wird immer zu der ersten Bezeichnung\n\
gesprungen. Versucht GOTO zu einer nicht vorhanden Bezeichnung zu springen,\n\
beendet sich die Ausführung der Batchdatei.\n\
\n\
GOTO hat keine Auswirkungen, wenn es interaktiv genutzt wird.\n"

  WCMD_HELP,   "HELP zeigt die Hilfe an\n"

  WCMD_IF,
"IF wird benutzt, um einen Befehl bedingt auszuführen.\n\
\n\
Syntax:	IF [NOT] EXIST Dateiname Befehl\n\
	IF [NOT] Zeichenkette1==Zeichenkette2 Befehl\n\
	IF [NOT] ERRORLEVEL Nummer Befehl\n\
\n\
In der zweiten Form des Befehls, müssen die beiden Zeichenketten in doppelten\n\
Anführungszeichen stehen. Der Vergleich achtet nicht auf die Groß- und\n\
Kleinschreibung.\n"

  WCMD_LABEL,  
"LABEL wird benutzt, um die Laufwerksbezeichnung festzulegen.\n\
\n\
Syntax: LABEL [Laufwerk:]\n\
\n\
Der Befehl wartet auf die Eingabe einer neuen Bezeichnung für das angegebene\n\
Laufwerk. Sie können sich auch die Laufwerksbezeicnung mit dem VOL - Befehl\n\
anzeigen lassen.\n"

  WCMD_MD,     "MD ist die Kurzform von MKDIR\n"
  WCMD_MKDIR,  "MKDIR erstellt ein Verzeichnis\n"
  WCMD_MOVE,
"MOVE verschiebt eine Datei oder ein Verzeichnis zu einem neuen Punkt im\n\
Dateisystem.\n\
\n\
Ist das zu verschiebende Objekt ein Verzeichnis, dann werden alle Dateien und\n\
Unterverzeichnisse unterhalb des Objektes genauso verschoben.\n\
\n\
MOVE schlägt fehl, wenn die alte und die neue Position auf verschiedenen DOS\n\
Laufwerken sind.\n"

  WCMD_PATH,
"PATH ändert oder zeigt den CMD Suchpfad an.\n\
\n\
Nach der Eingabe von PATH, wird die aktuelle PATH Einstellung angezeigt\n\
(nach dem Start wird der Wert aus der wine.conf Datei genommen). Um die\n\
Einstellungen zu ändern, muss nach dem PATH Befehl der neue Wert angegeben\n\
werden\n\
\n\
Es ist auch möglich den PATH mit Hilfe der PATH Umgebungsvariable zu\n\
modifizieren. Zum Beispiel:\n\
		PATH %PATH%;c:\\temp\n"

  WCMD_PAUSE,
"PAUSE lässt eine Meldung auf dem Bildschirm erscheinen\n\
'Drücken Sie die Eingabetaste um fortzufahren' und wartet darauf, dass der\n\
Benutzer die Eingabetaste/Enter-Taste drückt. Es wird hauptsächlich in\n\
Batchdateien genutzt, um dem Beutzer zu erlauben, die Ausgabe eines vorherigen\n\
Befehls zu lesen, bevor es durch Scrollen vom Bildschirm verschwindet.\n"

  WCMD_PROMPT,
"PROMPT setzt den Befehlszeilenprompt.\n\
\n\
Die Zeichenkette, die dem PROMPT Befehl folgt (und dem Leerzeichen\n\
unmittelbar danach), erscheint am Zeilenanfang, wenn CMD auf die Eingabe\n\
wartet.\n\
\n\
Die nachfolgenden Zeichen haben eine besondere Bedeutung:\n\
\n\
$$    Dollarzeichen       $_    Zeilenvorschub      $b    Pipe Zeichen (|)\n\
$d    aktuelles Datum     $e    Escape              $g    > Zeichen\n\
$l    < Zeichen           $n    akutelles Laufwerk  $p    aktueller Pfad\n\
$q    Gleichheitszeichen  $t    aktuelle Zeit       $v    cmd Version\n\
\n\
Hinweis: Die Eingabe des PROMPT Befehls ohne eine Prompt-Zeichenkette, setzt\n\
den Prompt zu den Standardwert zurück, was das aktuelle Verzeichnis (inklusive\n\
dem aktuellen Laufwerksbuchstaben) gefolgt von einen Größerzeichen (>)\n\
(genau wie der PROMPT $p$g Befehl).\n\
\n\
Der Prompt kann auch geändert werden durch das Ändern der PROMPT\n\
Umgebungsvariable, so hat der Befehl 'SET PROMPT=text' die gleiche Auswirkung\n\
wie 'PROMPT text'.\n"

  WCMD_REM,
"Beginnt eine Befehlszeile mit REM (gefolgt von einem Leerzeichen), wird\n\
keine Aktion ausgeführt und kann deshalb auch als Kommentar in einer\n\
Batchdatei genutzt werden.\n"

  WCMD_REN,    "REN ist die Kurzform von RENAME.\n"
  WCMD_RENAME, "RENAME benennt die angegebenen Dateien um.\n"
  WCMD_RD,     "RD ist die Kurzform von RMDIR.\n"
  WCMD_RMDIR,  "RMDIR löscht das angegebene Verzeichnis.\n"

  WCMD_SET,
"SET ändert oder zeigt die CMD Umgebungsvariablen an.\n\
\n\
SET ohne Parameter zeigt alle aktuellen Umgebungsvariablen an.\n\
\n\
Um eine Umgebungsvariable zu erschaffen oder zu ändern, ist der Syntax nötig:\n\
\n\
      SET <Variable>=<Wert>\n\
\n\
Wobei <Variable> und <Wert> Zeichenketten sind. Es dürfen keine Leerzeichen vor\n\
dem Gleichheitszeichen sein, noch darf der Variablenname Leerzeichen enthalten.\n\
\n\
In Wine werden die Umgebungsvariablen des darunterliegenden Betriebssystems\n\
mit in die Win32 Umgebung eingebunden, deshalb gibt es gewöhnlich mehr Werte\n\
als es sie in einer ursprünglichen Win32 Realisierung gäbe. Anmerkung: Es ist\n\
nicht möglich die Umgebungsvariablen des Betriebssystems vom CMD aus zu\n\
beeinflussen.\n"

  WCMD_SHIFT,
"SHIFT wird in einer Batchdatei genutzt, um einen Parameter vom Anfang der\n\
Liste zu entfernen, so das der Parameter 2 zu Parameter 1 wird und so weiter.\n\
Es hat keine Auswirkungen, wenn es von der Befehlszeile aus aufgerufen wird.\n"

  WCMD_TIME,   "TIME Setzt oder zeigt die aktuelle Systemzeit an.\n"

  WCMD_TITLE,
"Setzt den Fenstertitel für das CMD - Fenster.\n\
\n\
Syntax: TITLE [Zeichenkette]\n"

  WCMD_TYPE,
"TYPE <Datei> kopiert <Datei> zu dem Konsolengerät (oder dorthin, wohin\n\
dies umgeleitet wurde). Es wird keine Überprüfung vorgenommen, ob die\n\
Datei lesbaren Text enthält.\n"

  WCMD_VERIFY,
"VERIFY wird benutzt, um das Verify Flag zu setzen, zu löschen oder zu\n\
testen. Gültige Eingaben sind:\n\
\n\
VERIFY ON	Setzt das Flag\n\
VERIFY OFF	Löscht das Flag\n\
VERIFY		Zeigt an, ob ON oder OFF verwendet wird.\n\
\n\
Das Verify Flag hat keine Funktion in Wine.\n"

  WCMD_VER,
"VER zeigt die aktuelle Version von CMD an.\n"

  WCMD_VOL,    "VOL zeigt die Volumeseriennummer an\n"

  WCMD_PUSHD,  "PUSHD <Verzeichnisname> speichert das aktuelle\n\
Verzeichnis auf einem Stack und wecheselt das Arbeitsverzeichnis\n\
zu dem angegebenen.\n"

  WCMD_POPD,   "POPD wechselt das Arbeitsverzeichnis zu dem zuletzt\n\
mit PUSHD gespeicherten.\n"

  WCMD_MORE,   "MORE gibt Dateien und Pipes seitenweise aus.\n"

  WCMD_EXIT,
"EXIT beendet die aktuelle Befehlssitzung und kehrt zum\n\
Betriebssystem oder der Shell zurück, von der CMD gestart wurde.\n"


  WCMD_ALLHELP, "In CMD eingebaute Befehle sind:\n\
ATTRIB\t\tZeigt oder ändert die DOS Dateieigenschaften\n\
CALL\t\tRuft eine Batch-Datei innerhalb einer anderen auf\n\
CD (CHDIR)\tWechselt in ein Verzeichnis\n\
CLS\t\tLöscht den Inhalt der Konsole\n\
COPY\t\tKopiert eine Datei\n\
CTTY\t\tÄndert das Eingabe/Ausgabe - Gerät\n\
DATE\t\tZeigt oder ändert das Systemdatum\n\
DEL (ERASE)\tLöscht eine oder mehrere Dateien\n\
DIR\t\tListet den Inhalt eines Verzeichnisses\n\
ECHO\t\tKopiert den Text direkt zur Konsolenausgabe\n\
HELP\t\tZeigt detalierte Informationen zu einen Thema\n\
MD (MKDIR)\tErzeugt ein Unterverzeichnis\n\
MORE\t\tZeigt die Ausgabe seitenweise an\n\
MOVE\t\tBewegt eine oder mehrere Dateien oder einen Verzeichnisbaum\n\
PATH\t\tSetzt oder zeigt den Suchpfad an\n\
PROMPT\t\tÄndert den Befehlszeilenprompt\n\
REN (RENAME)\tBenennt eine Datei um\n\
RD (RMDIR)\tLöscht ein Unterverzeichnis\n\
SET\t\tSetzt oder zeigt die Umgebungsvariablen an\n\
TIME\t\tSetzt oder zeigt die aktuelle Systemzeit an\n\
TITLE\t\tSetzt den Fenstertitel für die CMD - Sitzung\n\
TYPE\t\tGibt den Inhalt einer Textdatei aus\n\
VER\t\tZeigt die aktuelle Version von CMD an\n\
VOL\t\tZeigt die Bezeichnung eines Laufwerkes an\n\
EXIT\t\tBeendet den CMD\n\n\
Geben Sie HELP <Befehl> ein, damit Sie weitere Informationen für einen der\n\
obigen Befehle erhalten.\n"

  WCMD_CONFIRM, "Sind sie sicher"
  WCMD_YES, "J"
  WCMD_NO, "N"
  WCMD_NOASSOC, "Verknüpfung für Dateiendung %s fehlt\n"
  WCMD_NOFTYPE, "Kein Befehl zum Öffnen für Dateityp '%s'\n"
  WCMD_OVERWRITE, "%s überschreiben"
  WCMD_MORESTR, "Mehr..."
  WCMD_TRUNCATEDLINE, "Die Zeile bei der Batchverarbeitung ist möglicherweise abgeschnitten. Benutze:\n"
  WCMD_NYI, "Noch nicht implementiert\n\n"
  WCMD_NOARG, "Argument fehlt\n"
  WCMD_SYNTAXERR, "Syntaxfehler\n"
  WCMD_FILENOTFOUND, "%s : Datei nicht gefunden\n"
  WCMD_NOCMDHELP, "Hilfe für %s ist nicht verfügbar\n"
  WCMD_NOTARGET, "Das Sprungziel von GOTO wurde nicht gefunden\n"
  WCMD_CURRENTDATE, "Aktuelles Datum ist %s\n"
  WCMD_CURRENTTIME, "Aktuelle Zeit ist %s\n"
  WCMD_NEWDATE, "Geben Sie das neue Datum ein: "
  WCMD_NEWTIME, "Geben Sie die neue Zeit ein: "
  WCMD_MISSINGENV, "Die Umgebungsvariable %s ist nicht definiert\n"
  WCMD_READFAIL, "'%s' konnte nicht geöffnet werden\n"
  WCMD_CALLINSCRIPT, "Kann kein Batch-Label außerhalb eines Batch-Scripts aufrufen\n"
  WCMD_ALL, "A"
  WCMD_DELPROMPT, "%s, löschen"
  WCMD_ECHOPROMPT, "Echo ist %s\n"
  WCMD_VERIFYPROMPT, "Verify ist %s\n"
  WCMD_VERIFYERR, "Verify muß ON oder OFF sein\n";
  WCMD_ARGERR, "Parameterfehler\n"
  WCMD_VOLUMEDETAIL, "Volume in Laufwerk %c ist %s\nVolumeseriennummer ist %04x-%04x\n\n"
  WCMD_VOLUMEPROMPT, "Volumebezeichnung (11 Zeichen, EINGABETASTE für keine)?"
  WCMD_NOPATH, "PATH nicht gefunden\n"
  WCMD_ANYKEY,"Drücken Sie die Eingabetaste um fortzufahren: "
  WCMD_CONSTITLE,"Wine Befehlsprozessor"
  WCMD_VERSION,"CMD Version %s\n\n"
  WCMD_MOREPROMPT, "Mehr? "
  WCMD_LINETOOLONG, "Die Eingabezeile ist zu lang.\n"
}
