diff --git a/docs/de/bookinfo.xml b/docs/de/bookinfo.xml
new file mode 100755
index 00000000..bf4a24de
--- /dev/null
+++ b/docs/de/bookinfo.xml
@@ -0,0 +1,39 @@
+
+
+
+ Smarty - the compiling PHP template engine
+
+
+ MonteOhrt <monte@ispi.net>
+
+
+ AndreiZmievski <andrei@php.net>
+
+
+ &build-date;
+
+ 2001-2004
+ ispi of Lincoln, Inc.
+
+
+
+
diff --git a/docs/de/getting-started.xml b/docs/de/getting-started.xml
new file mode 100644
index 00000000..6b07741b
--- /dev/null
+++ b/docs/de/getting-started.xml
@@ -0,0 +1,426 @@
+
+
+
+
+
+ Erste Schritte
+
+ Was ist Smarty?
+
+ Smarty ist eine Template-Engine für PHP. Genauer gesagt erlaubt es
+ die einfache Trennung von Applikations-Logik und Design/Ausgabe. Dies
+ ist vor allem wünschenswert, wenn der Applikationsentwickler nicht
+ die selbe Person ist wie der Designer. Nehmen wir zum Beispiel eine
+ Webseite die Zeitungsartikel ausgibt. Der Titel, die Einführung,
+ der Author und der Inhalt selbst enthalten keine Informationen darüber
+ wie sie dargestellt werden sollen. Also werden sie von der Applikation
+ an Smarty übergeben, damit der Designer in den Templates mit einer Kombination von
+ HTML- und Template-Tags die Ausgabe (Tabellen, Hintergrundfarben,
+ Schriftgrössen, Stylesheets, etc.) gestalten kann. Falls nun die
+ Applikation eines Tages angepasst werden muss, ist dies für den
+ Designer nicht von Belang, da die Inhalte immer noch genau gleich
+ übergeben werden. Genauso kann der Designer die Ausgabe der
+ Daten beliebig verändern, ohne dass eine Änderung der
+ Applikation vorgenommen werden muss. Somit können der Programmierer
+ die Applikations-Logik und der Designer die Ausgabe frei anpassen,
+ ohne sich dabei in die Quere zu kommen.
+
+
+ Was Smarty nicht kann: Smarty versucht nicht die gesamte Logik aus dem
+ Template zu verbannen. Solange die verwendete Logik ausschließlich für die
+ Ausgabe verwendet wird, kann sie auch im Template eingebettet werden. Ein Tip:
+ versuchen Sie Applikations-Logik aus dem Template und Präsentations-Logik
+ aus der Applikation herauszuhalten. Nur so bleibt die Applikation auf absehbere Zeit
+ gut skalier- und wartbar.
+
+
+ Einer der einzigartigen Aspekte von Smarty ist die Kompilierung der
+ Templates. Smarty liest die Template-Dateien und generiert daraus neue
+ PHP-Skripte; von da an werden nur noch diese Skripte verwendet. Deshalb
+ müssen Templates nicht für jeden Seitenaufruf performance-intensiv
+ neu geparst werden und jedes Template kann voll von PHP Compiler-Cache
+ Lösungen profitieren.
+ (Zend, http://www.zend.com; PHP Accelerator, http://www.php-accelerator.co.uk)
+
+
+ Ein paar Smarty Charakteristiken
+
+
+ Sehr schnell.
+ Sehr effizient, da der PHP-Parser die 'schmutzige' Arbeit übernimmt.
+ Kein Overhead durch Template-Parsing, nur einmaliges kompilieren.
+ Re-kompiliert nur gänderte Templates.
+ Sie können die Engine um individuelle Funktionen und Variablen-Modifikatoren erweitern.
+ Konfigurierbare Syntax für Template-Tags: Sie können {}, {{}}, <!--{}-->, etc. verwenden.
+ 'if/elseif/else/endif'-Konstrukte werden direkt dem PHP-Parser übergeben. Somit können {if ...} Ausdrücke sowohl sehr einfach als auch sehr komplex sein.
+ Unbegrenzte Verschachtelung von 'section', 'if' und anderen Blöcken.
+ Ermöglicht die direkte Einbettung von PHP-Code. (Obwohl es weder benötigt noch empfohlen wird, da die Engine einfach erweiterbar ist.)
+ Eingebauter Caching-Support
+ Beliebige Template-Quellen
+ Eigene Cache-Handling Funktionen
+ Plugin Architektur
+
+
+
+ Installation
+
+ Anforderungen
+
+ Smarty benötigt einen Webserver mit PHP >=4.0.6.
+
+
+
+
+ Basis Installation
+
+ Technische Bemerkung
+
+ Dieser Leitfaden geht davon aus, dass Sie Ihr Webserver- und PHP-Setup kennen
+ und mit den Namenskonventionen für Dateien und Verzeichnisse Ihres Betriebssystems
+ vertraut sind. Im Folgenden wird ein Unix-Dateisystem verwendet, stellen Sie also
+ sicher, dass sie die für Ihr Betriebssystem nötigen Änderungen vornehmen.
+
+
+ Das Beispiel geht davon aus, dass '/php/includes' in Ihrem PHP-'include_path'
+ liegt. Konsultieren Sie das PHP-Manual für weiterführende Informationen hierzu.
+
+
+
+ Installieren Sie als erstes die Smarty-Library Dateien. Diese Dateien
+ sollten von Ihnen NICHT editiert und von allen Applikationen
+ verwendet werden. Sie werden nur erneuert, wenn Sie eine neue Version von Smarty installieren.
+
+
+ Technische Bemerkung
+
+ Wir empfehlen keine Änderungen an den Smarty-Library Dateien vorzunehmen.
+ Dies macht ein mögliches Upgrade wesentlich einfacher. Sie müssen
+ diese Dateien auch nicht anpassen, um Smarty zu konfigurieren! Benutzen Sie für
+ diesen Zwecke eine Instanz der Smarty-Klasse.
+
+
+
+
+ Folgende Library Dateien werden mit Smarty geliefert und werden benötigt:
+
+
+ Smarty-Library Dateiliste
+
+Smarty.class.php
+Smarty_Compiler.class.php
+Config_File.class.php
+debug.tpl
+/core/*.php (alle)
+/plugins/*.php (alle)
+
+
+
+ Sie können diese Dateien entweder in Ihrem PHP-'include_path' oder
+ auch in irgend einem anderen Verzeichnis ablegen, solange die Konstante
+ SMARTY_DIR auf den korrekten
+ Pfad zeigt. Im Folgenden werden Beispiele für beide Fälle aufgezeigt.
+
+
+ So erzeugt man eine Instanz der Smarty-Klasse im PHP-Skript:
+
+
+
+ Smarty Instanz erstellen:
+
+require('Smarty.class.php');
+$smarty = new Smarty;
+
+
+
+ Versuchen Sie das Skript auszuführen. Wenn Sie eine Fehlermeldung erhalten dass
+ Smarty.class.php nicht gefunden werden konnte, versuchen Sie folgendes:
+
+
+
+ Absoluter Pfad übergeben
+
+require('/usr/local/lib/php/Smarty/Smarty.class.php');
+$smarty = new Smarty;
+
+
+
+ Library Verzeichnis dem Include-Pfad hinzufügen
+
+// editieren Sie php.ini, fügen Sie das Smarty
+// Verzeichnis Ihrem include_path hinzu, und starten Sie den Webserver neu
+// Danach sollte folgendes Funktionieren.
+require('Smarty.class.php');
+$smarty = new Smarty;
+
+
+
+ SMARTY_DIR manuell setzen
+
+define('SMARTY_DIR','/usr/local/lib/php/Smarty/');
+require(SMARTY_DIR.'Smarty.class.php');
+$smarty = new Smarty;
+
+
+
+
+ Jetzt, wo die Library Dateien an ihrem Platz sind, wird es
+ Zeit, die Smarty Verzeichnisse zu erstellen.
+
+
+ Für unser Beispiel werden wir die Smarty Umgebung für eine
+ Gästebuch-Applikation konfigurieren. Wir verwenden den Applikationsnamen
+ nur, um die Verzeichnis-Struktur zu verdeutlichen. Sie können die selbe
+ Umgebung für alle Ihre Applikationen verwenden indem Sie 'guestbook'
+ durch dem Namen Ihrer Applikation ersetzen.
+
+
+ Stellen Sie sicher, dass Sie die DocumentRoot Ihres Webservers kennen.
+ In unserem Beispiel lautet sie '/web/www.domain.com/docs/'.
+
+
+ Die Smarty Verzeichnisse werden in den Klassen-Variablen $template_dir,
+ $compile_dir, $config_dir und $cache_dir definiert. Die Standardwerte sind:
+ "templates", "templates_c", "configs" und "cache". Für unser Beispiel
+ legen wir alle diese Verzeichnisse unter '/web/www.domain.com/smarty/guestbook/' an.
+
+
+
+ Technische Bemerkung
+
+ Wir empfehlen, diese Verzeichnisse ausserhalb der DocumentRoot anzulegen,
+ um mögliche Direktzugriffe zu verhindern.
+
+
+
+
+ In Ihrer DocumentRoot muss mindestens eine Datei liegen, die für Browser
+ zugänglich ist. Wir nennen dieses Skript 'index.php', und legen
+ es in das Verzeichnis '/guestbook/' in unserer DocumentRoot.
+
+
+
+ Technische Bemerkung
+
+ Bequem ist es, den Webserver so zu konfigurieren, dass 'index.php' als
+ Standard-Verzeichnis-Index verwendet wird. Somit kann man das Skript
+ direkt mit 'http://www.domain.com/guestbook/' aufrufen. Falls Sie Apache
+ verwenden, lässt sich dies konfigurieren indem Sie 'index.php'
+ als letzten Eintrag für DirectoryIndex verwenden. (Jeder Eintrag muss
+ mit einem Leerzeichen abgetrennt werden).
+
+
+
+
+ Die Dateistruktur bis jetzt:
+
+
+
+ Beispiel der Dateistruktur
+
+/usr/local/lib/php/Smarty/Smarty.class.php
+/usr/local/lib/php/Smarty/Smarty_Compiler.class.php
+/usr/local/lib/php/Smarty/Config_File.class.php
+/usr/local/lib/php/Smarty/debug.tpl
+/usr/local/lib/php/Smarty/plugins/*.php
+/usr/local/lib/php/Smarty/core/*.php
+
+/web/www.mydomain.com/smarty/guestbook/templates/
+/web/www.mydomain.com/smarty/guestbook/templates_c/
+/web/www.mydomain.com/smarty/guestbook/configs/
+/web/www.mydomain.com/smarty/guestbook/cache/
+
+/web/www.mydomain.com/docs/guestbook/index.php
+
+
+
+ Technische Bemerkung
+
+ Falls Sie kein Caching und keine Konfigurationsdateien verwenden, ist es nicht
+ erforderlich die Verzeichnisse '$config_dir' und '$cache_dir' zu erstellen.
+ Es wird jedoch trotzdem empfohlen, da diese Funktionalitäten eventuell später
+ genutzt werden sollen.
+
+
+
+
+ Smarty benötigt Schreibzugriff auf die Verzeichnisse '$compile_dir' und '$cache_dir'.
+ Stellen Sie also sicher, dass der Webserver-Benutzer (normalerweise Benutzer 'nobody' und Gruppe 'nogroup')
+ in diese Verzeichnisse schreiben kann. (In OS X lautet der Benutzer normalerweise 'www' und
+ ist in der Gruppe 'www'). Wenn Sie Apache verwenden, können Sie in der httpd.conf (gewöhnlich in '/usr/local/apache/conf/')
+ nachsehen, unter welchem Benutzer Ihr Server läuft.
+
+
+
+ Dateirechte einrichten
+
+
+chown nobody:nobody /web/www.mydomain.com/smarty/guestbook/templates_c/
+chmod 770 /web/www.mydomain.com/smarty/guestbook/templates_c/
+
+chown nobody:nobody /web/www.mydomain.com/smarty/guestbook/cache/
+chmod 770 /web/www.mydomain.com/smarty/guestbook/cache/
+
+
+
+ Technische Bemerkung
+
+ 'chmod 770' setzt ziemlich strenge Rechte und erlaubt nur dem Benutzer 'nobody'
+ und der Gruppe 'nobody' Lese-/Schreibzugriff auf diese Verzeichnisse. Falls Sie
+ die Rechte so setzen möchten, dass auch andere Benutzer die Dateien lesen
+ können (vor allem für Ihren eigenen Komfort), so erreichen Sie dies mit 775.
+
+
+
+
+ Nun müssen wir die 'index.tpl' Datei erstellen, welche Smarty laden soll.
+ Die Datei wird in Ihrem '$template_dir' abgelegt.
+
+
+
+ Editieren von /web/www.mydomain.com/smarty/guestbook/templates/index.tpl
+
+
+{* Smarty *}
+
+Hallo, {$name}!
+
+
+
+
+ Technische Bemerkung
+
+ {* Smarty *} ist ein Template-Kommentar. Der wird zwar nicht benötigt,
+ es ist jedoch eine gute Idee jedes Template mit einem Kommentar zu versehen.
+ Dies erleichtert die Erkennbarkeit des Templates, unabhängig von der
+ verwendeten Dateierweiterung. (Zum Beispiel für Editoren die Syntax-Highlighting
+ unterstützen.)
+
+
+
+
+ Als nächstes editieren wir die Datei 'index.php'. Wir erzeugen eine
+ Smarty-Instanz, weisen dem Template eine Variable zu und geben 'index.tpl' aus.
+
+
+
+ Editieren von /web/www.mydomain.com/docs/guestbook/index.php
+
+
+define('SMARTY_DIR','/usr/local/lib/php/Smarty/');
+require(SMARTY_DIR.'Smarty.class.php');
+
+$smarty = new Smarty;
+
+$smarty->template_dir = '/web/www.mydomain.com/smarty/guestbook/templates/';
+$smarty->compile_dir = '/web/www.mydomain.com/smarty/guestbook/templates_c/';
+$smarty->config_dir = '/web/www.mydomain.com/smarty/guestbook/configs/';
+$smarty->cache_dir = '/web/www.mydomain.com/smarty/guestbook/cache/';
+
+$smarty->assign('name','Ned');
+
+$smarty->display('index.tpl');
+
+
+
+ Technische Bemerkung
+
+ In unserem Beispiel verwenden wir durchwegs absolute Pfadnamen zu den
+ Smarty-Verzeichnissen. Falls '/web/www.mydomain.com/smarty/guestbook/' in
+ Ihrem PHP-'include_path' liegt, wäre dies nicht nötig. Es ist jedoch
+ effizienter und weniger fehleranfällig die Pfade absolut zu setzen.
+ Und es garantiert, dass Smarty die Templates aus dem geplanten Verzeichnis lädt.
+
+
+
+
+ Wenn Sie 'index.php' nun in Ihrem Webbrowser öffnen, sollte 'Hallo, Ned!' ausgegeben werden.
+
+
+ Die Basis-Installation von Smarty wäre somit beendet.
+
+
+
+ Erweiterte Konfiguration
+
+
+
+ Dies ist eine Weiterführung der Basis Installation, bitte lesen Sie diese zuerst!
+
+
+ Ein flexiblerer Weg um Smarty aufzusetzen ist, die Klasse zu erweitern und
+ eine eigene Smarty-Umgebung zu initialisieren. Anstatt immer wieder
+ die Verzeichnisse zu definieren, kann diese Aufgabe auch in einer einzigen
+ Datei erledigt werden. Beginnen wir, indem wir ein neues Verzeichnis namens '/php/includes/guestbook/'
+ erstellen und eine Datei namens 'setup.php' darin anlegen.
+
+
+
+ Editieren von /php/includes/guestbook/setup.php
+
+
+// Smarty Library Dateien laden
+define('SMARTY_DIR','/usr/local/lib/php/Smarty/');
+require(SMARTY_DIR.'Smarty.class.php');
+
+// ein guter Platz um Applikations spezifische Libraries zu laden
+// require('guestbook/guestbook.lib.php');
+
+class Smarty_GuestBook extends Smarty {
+
+ function Smarty_GuestBook() {
+
+
+ // Konstruktor. Diese Werte werden für jede Instanz automatisch gesetzt
+
+ $this->Smarty();
+
+ $this->template_dir = '/web/www.mydomain.com/smarty/guestbook/templates/';
+ $this->compile_dir = '/web/www.mydomain.com/smarty/guestbook/templates_c/';
+ $this->config_dir = '/web/www.mydomain.com/smarty/guestbook/configs/';
+ $this->cache_dir = '/web/www.mydomain.com/smarty/guestbook/cache/';
+
+ $this->caching = true;
+ $this->assign('app_name','Guest Book');
+ }
+
+}
+
+
+
+ Technische Bemerkung
+
+ In unserem Beispiel werden die Library Dateien ausserhalb der DocumentRoot
+ abgelegt. Diese Dateien könnten sensitive Informationen enthalten,
+ die wir nicht zugänglich machen möchten.
+ Deshalb legen wir alle Library Dateien in '/php/includes/guestbook/' ab
+ und laden sie in unserem 'setup.php' Skript, wie Sie im oben gezeigten
+ Beispiel sehen können.
+
+
+
+
+ Nun passen wir 'index.php' an, um 'setup.php' zu verwenden:
+
+
+
+ Editieren von /web/www.mydomain.com/docs/guestbook/index.php
+
+
+require('guestbook/setup.php');
+
+$smarty = new Smarty_GuestBook;
+
+$smarty->assign('name','Ned');
+
+$smarty->display('index.tpl');
+
+
+
+ Wie Sie sehen können, ist es sehr einfach eine Instanz von Smarty zu erstellen.
+ Mit Hilfe von Smarty_GuestBook werden alle Variablen automatisch initialisiert.
+
+
+
+
+
+
diff --git a/docs/de/language-defs.ent b/docs/de/language-defs.ent
new file mode 100644
index 00000000..3cb41d88
--- /dev/null
+++ b/docs/de/language-defs.ent
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git a/docs/de/preface.xml b/docs/de/preface.xml
new file mode 100644
index 00000000..da42027a
--- /dev/null
+++ b/docs/de/preface.xml
@@ -0,0 +1,73 @@
+
+
+
+
+
+
+ Vorwort
+
+ Die Frage, wie man die Applikations-Logik eines PHP-Scriptes vom Layout trennt, ist unzweifelhaft
+ eines der am häfigsten diskutierten Themen. Da PHP als
+ "in HTML eingebettete Scripting-Sprache" angepriesen wird, ergibt sich
+ nach einigen Projekten in denen man HTML und PHP gemischt hat schnell die Idee,
+ Funktionalität und Darstellung zu trennen. Dazu kommt, dass in vielen Firmen Applikationsentwickler
+ und Designer nicht die selbe Person sind. In Konsequenz beginnt die Suche nach einer Template-Lösung.
+
+
+ Als Beispiel: In unserer Firma funktioniert die Entwicklung einer Applikation
+ wie folgt: Nachdem die Spezifikationen erstellt sind, entwickelt der
+ Interface Designer einen Prototypen des Interfaces und übergibt dieses
+ dem Programmierer. Der Programmierer implementiert die Geschäftslogik
+ in PHP und verwendet den Interface-Prototypen zur Erstellung eines Template-Skeletts.
+ Danach übergibt der Programmierer die Templates dem HTML/Webseiten-Designer
+ welcher ihnen den letzten Schliff verleiht. Das Projekt kann mehrfach zwischen
+ dem Programmieren und dem Designer ausgetauscht werden. Deshalb ist es wichtig,
+ dass die Trennung von Logik und Design klar stattfindet. Der Programmierer will
+ sich normalerweise nicht mit HTML herumschlagen müssen und möchte auch
+ nicht, dass der Designer seinen PHP-Code verändert. Designer selbst
+ benötigen Konfigurationsdateien, dynamische Blöcke und andere Interface spezifische
+ Eigenheiten, möchten aber auch nicht direkt mit PHP in Berührung kommen.
+
+
+ Die meisten Template-Engines die heutzutage angeboten werden, bieten eine
+ rudimentäre Möglichkeit Variablen in einem Template zu ersetzen
+ und beherschen eine eingeschränkte Funktionalität für dynamische
+ Blöcke. Unsere Anforderungen forderten jedoch ein wenig mehr. Wir wollten
+ erreichen, dass sich Programmierer überhaupt nicht um HTML Layouts
+ kümmern müssen. Dies war aber fast unumgänglich. Wenn ein
+ Designer zum Beispiel alternierende Farben in einer Tabelle einsetzen wollte,
+ musste dies vorhergehend mit dem Programmierer abgesprochen werden. Wir wollten
+ weiter, dass dem Designer Konfigurationsdateien zur Verfügung stünden,
+ aus denen er Variablen für seine Templates extrahieren kann. Die Liste ist endlos.
+
+
+ Wir begannen 1999 mit der Spezifikation der Template Engine. Nachdem dies
+ erledigt war, fingen wir an eine Engine in C zu schreiben, die - so hofften
+ wir - in PHP eingebaut würde. Nach einer hitzigen Debatte darüber
+ was eine Template Engine können sollte und was nicht, und nachdem wir feststellen
+ mussten, dass ein paar komplizierte technische Probleme auf uns zukommen
+ würden, entschlossen wir uns die Template Engine in PHP als Klasse
+ zu realisieren, damit sie von jederman verwendet und angepasst werden kann.
+ So schrieben wir also eine Engine, die wir SmartTemplate
+ nannten (anm: diese Klasse wurde nie veröffentlicht). SmartTemplate
+ erlaubte uns praktisch alles zu tun was wir uns vorgenommen hatten: normale
+ Variablen-Ersetzung, Möglichkeiten weitere Templates einzubinden,
+ Integration von Konfigurationsdateien, Einbetten von PHP-Code, limitierte 'if'-Funktionalität
+ und eine sehr robuste Implementation von dynamischen Blöcken die
+ mehrfach verschachtelt werden konnten. All dies wurde mit Regulären Ausdrücken
+ erledigt und der Sourcecode wurde ziemlich unübersichtlich. Für grössere
+ Applikationen war die Klasse auch bemerkenswert langsam, da das Parsing bei jedem
+ Aufruf einer Seite durchlaufen werden musste. Das grösste Problem aber war,
+ dass der Programmierer das Setup, die Templates und dynamische Blöcke in seinem
+ PHP-Skript definieren musste. Die nächste Frage war: wie können wir dies
+ weiter vereinfachen?
+
+
+ Dann kam uns die Idee, aus der schließlich Smarty wurde. Wir wussten
+ wie schnell PHP-Code ohne den Overhead des Template-Parsing ist. Wir wussten
+ ebenfalls wie pedantisch PHP aus Sicht eines durchschnittlichen
+ Designers ist und dass dies mit einer einfacheren Template-Syntax
+ verborgen werden kann. Was wäre also, wenn wir diese
+ beiden Stärken vereinten? Smarty war geboren...
+
+