Updates the German and English documentation.

src/test/resources/docu/static_de.xml

@@ -494,24 +494,22 @@
             Es kommt vor, dass eine Teilschaltung erstellt wurde, und diese soll in
             veschiedenen Varianten verwendet werden. Vorstellbar ist z.B. ein spezieller Zähler, der für verschiedene
             Bitbreiten benötigt wird. Würde man nun je eine Teilschaltung für 4,5 und 6 Bits erstellen, wäre die
-            Pflege der Schaltung in Zukunft schwierig, da man immer mehrere Teilschaltungen bearbeiten muss, die bis auf
-            einen Parameter - die Bitbreite - identisch sind.
+            Pflege der Schaltung in Zukunft schwierig, da bei jeder Änderung mehrere Teilschaltungen zu bearbeiten sind,
+            die bis auf einen Parameter - die Bitbreite - identisch sind.
         </par>
         <par>
             Um dies zu verhindern, kann eine generische Teilschaltung erstellt werden, die sich parametrisieren
             lässt. Dazu muss in den Schaltungseinstellung der Schaltung das Häckchen "Schaltung ist generisch" gesetzt
             werden. Danach enthält der Parameter-Dialog jeder Komponente der Schaltung das zusätzliche Feld
-            "generische Parametrisierung". In diesem Feld kann Programmcode eingegeben werden, welcher die Parameter
+            "generische Parametrisierung". In diesem Feld kann Programmcode angegeben werden, welcher die Parameter
             der Komponente verändern kann. Jeder Parameter hat einen Namen und kann als Attribut des Feldes <e>this</e>
             modifiziert werden. Wie die Parameter benannt sind, kann dem Hilfedialog der Komponente entnommen werden.
-            Möchte man die Bitbreite eines Addierers ändern, kann die Zeile <e>this.Bits=int(1);</e> verwendet werden.
-            Konstanten - hier die Eins - sind immer vom Typ <e>long</e>, die Bitbreite ist aber ein <e>int</e>. Daher
-            ist die Typkonvertierung auf ein <e>int</e> erforderlich.
+            Möchte man die Bitbreite eines Addierers ändern, kann die Zeile <e>this.Bits=1;</e> verwendet werden.
         </par>
         <par>
             Auf diese Weise kann man jedoch noch keine parametrisierbare Schaltung erstellen. Es ist noch erforderlich
             auf Parameter zuzugreifen, die gesetzt werden, wenn die Schaltung verwendet wird. Dies geschieht über das
-            Feld "args". Will man die Bitbreite von außen setzen, kann man schreiben: <e>this.Bits=int(args.bitWidth);</e>.
+            Feld "args". Will man die Bitbreite von außen setzen, kann man schreiben: <e>this.Bits=args.bitWidth;</e>.
             Der Name des Argumentes - hier <e>bitWidth</e> - ist dabei beliebig. Wenn diese Teilschaltung verwendet wird,
             ist dieses Argument zu setzen.
         </par>
@@ -521,10 +519,34 @@
             verwendende Bitbreite gesetzt werden.
         </par>
         <par>
-            Auf diese Weise können keine Leitungen oder Komponenten entfernt oder hinzugefügt werden. Dennoch lassen
-            sich mit einem Trick viele Schaltungen umsetzen. Erreicht wird dies, indem, abhängig von den Argumenten,
-            eine Schaltung durch eine andere ersetzt wird. Zu diesem Zweck steht die Funktion <e>setCircuit([Name])</e>
-            zur Verfügung. Wird sie im Definitionsteil einer Teilschaltung aufgerufen, kann die einzufügende Schaltung
+            Wenn eine generische Schaltung direkt gestartet werden soll, ist das ohne Weiteres nicht möglich, da die
+            erforderlichen Argumente fehlen, die bei der Einbettung der Schaltung angegeben werden müssen.
+            Diese fehlenden Argumente würden zu entsprechenden Fehlermeldungen führen.
+            Um den Test der Schaltung zu vereinfachen, kann daher die
+            Komponente <e>Generische Initialisierung</e> der Schaltung hinzugefügt werden. In dieser Komponente lassen sich
+            die Argumente setzen, die aus einer einbettenden Schaltung kommen würden.
+            Auf diese Weise kann auch eine generische Schaltung direkt simuliert werden, was die Erstellung sehr
+            erleichtert. Wird die Schaltung eingebettet, wird diese Komponente ignoriert.
+            Sie wird nur für den direkten Start der Simulation benötigt.
+        </par>
+        <par>
+            Unter Umständen kann es sinnvoll sein, nicht nur die Attribute der Komponenten einer Schaltung zu verändern,
+            sondern ganz neue Komponenten und Leitungen abhängig von den übergebenen Argumenten hinzuzufügen.
+            Dazu kann die Komponente <e>Code</e> verwendet werden. Wird sie der Schaltung hinzugefügt, wird der enhaltene
+            Code beim Start der Simulation ausgeführt.
+            Hier kann mit der Funktion <e>addWire([x1],[y1],[x2],[y2])</e> eine Leitung hinzugefügt werden und über
+            die Funktionen <e>addComponent([Name],[x],[y])</e> kann eine neue Komponente <e>[Name]</e> an der
+            Position ([x],[y]) hinzugefügt werden. Der Rückgabewert der Funktion <e>addComponent([Name],[x],[y])</e>
+            erlaubt das Setzen der Parameter der Komponente.
+        </par>
+        <par>
+            Die Beispielschaltung <e>examples/generic/modify/Conway/GenericConway.dig</e> zeigt, wie auf diese Weise
+            auch eine komplexere Schaltung zusammengesetzt werden kann.
+        </par>
+        <par>
+            Eine andere Möglichkeit eine Schaltung zu erzeugen ist Rekursion: Es ist möglich, abhängig von den Argumenten,
+            eine Schaltung durch eine andere zu ersetzen. Zu diesem Zweck steht die Funktion <e>setCircuit([Name])</e>
+            zur Verfügung. Wird sie im Definitionsteil einer eingebetteten Schaltung aufgerufen, kann die einzufügende Schaltung
             durch eine andere ersetzt werden. Dies erlaubt die rekursive Definition einer Schaltung. Wie in anderen
             Programmiersprachen auch, ist auf eine geeignete Abbruchbedingung zu achten.
         </par>

src/test/resources/docu/static_en.xml

@@ -470,15 +470,13 @@
             parameterization". In this field program code can be entered, which can change the parameters of the
             component. Each parameter has a name and can be modified as an attribute of the field <e>this</e>.
             The names of the parameters can be found in the help dialog of the component.
-            If you want to change the bit width of an adder, the line <e>this.Bits=int(1);</e> can be used.
-            Constants - here the one - are always of type <e>long</e>, but the bit width is an <e>int</e>.
-            Therefore the type conversion to an <e>int</e> is necessary.
+            If you want to change the bit width of an adder, the line <e>this.Bits=1;</e> can be used.
         </par>
         <par>
             In this way, however, it is not yet possible to create a circuit that can be parameterized.
             It is still necessary to access parameters that are set when the circuit is used.
             This is done via the field "args". If you want to set the bit width from outside, you can write:
-            <e>this.Bits=int(args.bitWidth);</e>. The name of the argument - here <e>bitWidth</e> is arbitrary.
+            <e>this.Bits=args.bitWidth;</e>. The name of the argument - here <e>bitWidth</e> is arbitrary.
             If such a subcircuit is used, this argument must be set.
         </par>
         <par>
@@ -487,9 +485,32 @@
             <e>bitWidth:=5;</e>.
         </par>
         <par>
-            In this way, no wires or components can be removed or added. Nevertheless, many circuits can be
-            realized with a trick. This is achieved by replacing one circuit with another, depending on the
-            arguments. For this purpose the function <e>setCircuit([Name])</e> is available.
+            If a generic circuit is to be started directly, this is not possible straight away, since the required
+            arguments are missing, which have to be specified when embedding the circuit. These missing arguments
+            would lead to corresponding error messages.
+            Therefore, to simplify the testing of the circuit, the <e>Generic Initialization</e> component can be
+            added to the circuit. In this component you can set the arguments that would come from an embedding circuit.
+            In this way, a generic circuit can also be simulated directly.
+            If the circuit is embedded, this component is ignored.
+            It is only needed for the direct start of the simulation.
+        </par>
+        <par>
+            Under certain circumstances it may be useful not only to change the attributes of the components of a
+            circuit, but to add completely new components and wires depending on the passed arguments.
+            The <e>Code</e> component can be used for this purpose. If it is added to the circuit, the contained
+            Code will be executed when the simulation is started.
+            Here, a wire can be added using the <e>addWire([x1],[y1],[x2],[y2])</e> function, and using the function
+            <e>addComponent([name],[x],[y])</e> a new component <e>[name]</e> can be added at the position ([x],[y]).
+            The return value of the <e>addComponent([Name],[x],[y])</e> function allows to set the parameters of the
+            component.
+        </par>
+        <par>
+            The example circuit <e>examples/generic/modify/Conway/GenericConway.dig</e> shows how a more complex
+            circuit can be assembled in this way.
+        </par>
+        <par>
+            Another way to create a circuit is recursion: it is possible, depending on the arguments, to replace one
+            circuit by another. For this purpose the function <e>setCircuit([Name])</e> is available.
             If it is called in the definition part of a subcircuit, the circuit to be inserted can be replaced
             by another circuit. This allows the recursive definition of a circuit. As in other programming
             languages, a suitable termination condition must be ensured.

src/test/resources/docu/static_fr.xml

@@ -479,15 +479,13 @@
             nommé "paramétrisation générique". Dans ce champ, un code de programme peut être entré, celui-ci servant
             à changer les paramètres de la composante. Chaque paramètre a un nom et peut être modifié comme un attribut
             du champ <e>this</e>. Le nom des paramètres peut être trouvé dans le dialogue d'aide de la composante.
-            Pour changer la largeur binaire d'un additionneur, la ligne <e>this.Bits=int(1);</e> peut être utilisée.
-            Les constantes, comme le 1 ici, sont toujours du type <e>long</e>, mais la largeur binaire est un <e>int</e>.
-            Donc, une conversion vers le type <e>int</e> est nécessaire.
+            Pour changer la largeur binaire d'un additionneur, la ligne <e>this.Bits=1;</e> peut être utilisée.
         </par>
         <par>
             Cependant, cela en tant que tel ne permet pas encore de paramétrer le circuit.
             Il encore nécessaire de pouvoir accéder aux paramètres établis lorsque le circuit est utilisé.
             Ceci est fait grâce au champ "args". Si vous voulez accéder à la largeur binaire de l'extérieur, vous pouvez écrire:
-            <e>this.Bits=int(args.largeurBinaire);</e>. Le nom de l'argument, <e>largeurBinaire</e> ici, est arbitraire.
+            <e>this.Bits=args.largeurBinaire;</e>. Le nom de l'argument, <e>largeurBinaire</e> ici, est arbitraire.
             Si le sous-circuit est utilisé, cet argument doit être mis.
         </par>
         <par>

src/test/resources/docu/static_fr_ref.xml

@@ -470,15 +470,13 @@
             parameterization". In this field program code can be entered, which can change the parameters of the
             component. Each parameter has a name and can be modified as an attribute of the field <e>this</e>.
             The names of the parameters can be found in the help dialog of the component.
-            If you want to change the bit width of an adder, the line <e>this.Bits=int(1);</e> can be used.
-            Constants - here the one - are always of type <e>long</e>, but the bit width is an <e>int</e>.
-            Therefore the type conversion to an <e>int</e> is necessary.
+            If you want to change the bit width of an adder, the line <e>this.Bits=1;</e> can be used.
         </par>
         <par>
             In this way, however, it is not yet possible to create a circuit that can be parameterized.
             It is still necessary to access parameters that are set when the circuit is used.
             This is done via the field "args". If you want to set the bit width from outside, you can write:
-            <e>this.Bits=int(args.bitWidth);</e>. The name of the argument - here <e>bitWidth</e> is arbitrary.
+            <e>this.Bits=args.bitWidth;</e>. The name of the argument - here <e>bitWidth</e> is arbitrary.
             If such a subcircuit is used, this argument must be set.
         </par>
         <par>