Merge pull request #8 from DDP-Projekt/dev

Mehr Dokumentation
DDP-Projekt · Jul 11, 2024 · 0d1266c · 0d1266c
2 parents f887437 + ca41d3a
commit 0d1266c
Show file tree

Hide file tree

Showing 6 changed files with 134 additions and 44 deletions.
diff --git a/content/DE/Programmierung/Funktionen/Anwendung.md b/content/DE/Programmierung/Funktionen/Anwendung.md
@@ -83,6 +83,26 @@ Und kann so benutzt werden:
 Das Komma und 'oder' können darin synonym verwendet werden.
 Wenn eine Funktion Parameter besitzt, müssen diese alle im Alias vorhanden sein in der Form `<parameter-name>`.
 
+### Aliasnegationen
+
+Für Funktionen, die einen Wahrheitswert zurückgeben gibt es spezielle Syntax um die Funktion zu negieren:
+```ddp
+Die öffentliche Funktion Ist_Text_Leer mit dem Parameter text vom Typ Text, gibt einen Wahrheitswert zurück, macht:
+	Gib wahr, wenn die Länge von text gleich 0 ist zurück.
+Und kann so benutzt werden:
+	"<text> <!nicht> leer ist"
+
+Schreibe ("" leer ist). [wahr]
+Schreibe ("" nicht leer ist). [falsch]
+
+[ Eine Aliasnegation entspricht einem zusätzlichen "nicht" Operator ]
+Schreibe ( ("" nicht leer ist) gleich (nicht "" leer ist) ). [wahr]
+```
+
+Wenn das Token mit dem Ausrufezeichen (`!`) aus dem Alias vorhanden ist, wird vor dem Funktionsaufruf ein `nicht` eingefügt.
+
+### Nachträgliche Aliase
+
 Aliase können auch außerhalb der Funktionsdeklaration definiert werden, mit der Form:
 ```ddp
 Der Alias "<Alias>" steht für die Funktion <Funktionsname>.

diff --git a/content/DE/Programmierung/Funktionen/Externe Funktionen.md b/content/DE/Programmierung/Funktionen/Externe Funktionen.md
@@ -31,4 +31,28 @@ Sollte die gegebene Datei eine .c Datei sein, so wird diese mit GCC zu einer .o
 
 Purer DDP-Quellcode könnte nicht viel tun, nichtmal etwas auf die Konsole schreiben.
 Deshalb sind Externe Funktionen enorm wichtig, da sie Schnittstellen zum Betriebssystem und vielen Bibliotheken bilden.
-Ein gutes Beispiel dafür ist der Duden. Sehr viele Funktionen darin sind extern und in C geschrieben. Der Duden bildet einen guten Einstiegspunkt um das Nutzen von externen Funktionen zu lernen und sich Beispiele in C anzusehen wie sie mit der DDP-Runtime interagieren.
+Ein gutes Beispiel dafür ist der Duden. Sehr viele Funktionen darin sind extern und in C geschrieben. Der Duden bildet einen guten Einstiegspunkt um das Nutzen von externen Funktionen zu lernen und sich Beispiele in C anzusehen wie sie mit der DDP-Runtime interagieren.
+
+# Extern sichtbare Funktionen
+
+Der DDP Kompilierer benutzt eine Technik namens [name mangling](https://en.wikipedia.org/wiki/Name_mangling). Das heißt, die Namen von Funktionen und Variablen
+sind im Quellcode nicht dieselben wie in der entstehenden Binärdatei.
+
+Wenn man also eine nicht-externe DDP Funktion aus C-Code benutzen will, muss man das name-mangling ausschalten:
+```ddp
+[test.ddp]
+Die Funktion ddp_funktion gibt nichts zurück, macht:
+    Schreibe "Ich bin eine DDP Funktion" auf eine Zeile.
+Und kann so benutzt werden:
+    "ddp_funktion"
+```
+
+```c
+// test.c
+extern void ddp_funktion(void);
+
+int main(void) {
+    ddp_funktion();
+    return 0;
+}
+```
diff --git a/content/DE/Programmierung/Operatoren.md b/content/DE/Programmierung/Operatoren.md
@@ -13,12 +13,13 @@ in diesen und späteren Tabellen jeweils der C-Operator dabei.
 
 ## Unäre Operatoren
 
-| Funktion                              | Verwendung                         | C Equivalent | Typ vom Operanden | Rückgabetyp | Beispiel                   | Ergebnis |
-| ------------------------------------- | ---------------------------------- | ------------ | ----------------- | ----------- | -------------------------- | -------- |
-| Logische NICHT verknüpfung            | `logisch nicht a`                  | `~a`         | Zahl              | Zahl        | `logisch nicht 1`          | -2       |
-| Listen/Text Element/Buchstaben Anzahl | `die Länge von a`                  | -            | Liste, Text       | Zahl        | `Die Länge von "Hallo"`    | 5        |
-| Byte Größe                            | `die Größe einem/einer <Typname>`  | `sizeof(a)`  | Typename          | Zahl        | `Die Größe von einer Zahl` | 8        |
-| Betrag                                | `der Betrag von a`                 | `abs(a)`     | numerisch         | numerisch   | `der Betrag von -5`        | 5        |
+| Funktion                              | Verwendung                                   | C Equivalent | Typ vom Operanden | Rückgabetyp                 | Beispiel                              | Ergebnis |
+| ------------------------------------- | -------------------------------------------- | ------------ | ----------------- | --------------------------- | ------------------------------------- | -------- |
+| Logische NICHT verknüpfung            | `logisch nicht a`                            | `~a`         | Zahl              | Zahl                        | `logisch nicht 1`                     | -2       |
+| Listen/Text Element/Buchstaben Anzahl | `die Länge von a`                            | -            | Liste, Text       | Zahl                        | `Die Länge von "Hallo"`               | 5        |
+| Byte Größe                            | `die Größe von einem/einer <Typname>`        | `sizeof(a)`  | Typename          | Zahl                        | `Die Größe von einer Zahl`            | 8        |
+| Standardwert                          | `der Standardwert von einem/einer <Typname>` | -            | Typename          | passend zum Typnamen        | `Der Standardwert von einer Zahl`     | 0        |
+| Betrag                                | `der Betrag von a`                           | `abs(a)`     | numerisch         | numerisch                   | `Der Betrag von -5`                   | 5        |
 
 ## Binäre Operatoren
 
@@ -42,11 +43,12 @@ in diesen und späteren Tabellen jeweils der C-Operator dabei.
 
 Mithilfe von Bool'schen Operatoren können komplexe Bedingungen ausgedrückt und zusammengefasst werden und z.B. für Verzweigungen oder Schleifen verwendet werden.
 
-| Operator | Beschreibung                                    | C Equivalent      | Beispiel                                                                             | Ergebnis                                   |
-| -------- | ----------------------------------------------- | ----------------- | ------------------------------------------------------------------------------------ | ------------------------------------------ |
-| und      | Wahr, wenn beide Argumente wahr sind.           | `true && false`   | `wahr und wahr`<br>`wahr und falsch`<br>`falsch und wahr`<br>`falsch und falsch`     | `wahr`<br>`falsch`<br>`falsch`<br>`falsch` |
-| oder     | Wahr, wenn eines der Beiden Argumente wahr ist. | `true \|\| false` | `wahr oder wahr`<br>`wahr oder falsch`<br>`falsch oder wahr`<br>`falsch oder falsch` | `wahr`<br>`wahr`<br>`wahr`<br>`falsch`     |
-| nicht    | Der Wert des Arguments wird umgekehrt.          | `!true`           | `nicht wahr` <br>`nicht falsch`                                                      | `falsch`<br>`wahr`                         |
+| Operator            | Beschreibung                                          | C Equivalent      | Beispiel                                                                                                                  | Ergebnis                                   |
+| ------------------- | ----------------------------------------------------- | ----------------- | ------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------ |
+| und                 | Wahr, wenn beide Argumente wahr sind.                 | `true && false`   | `wahr und wahr`<br>`wahr und falsch`<br>`falsch und wahr`<br>`falsch und falsch`                                          | `wahr`<br>`falsch`<br>`falsch`<br>`falsch` |
+| oder                | Wahr, wenn eines der Beiden Argumente wahr ist.       | `true \|\| false` | `wahr oder wahr`<br>`wahr oder falsch`<br>`falsch oder wahr`<br>`falsch oder falsch`                                      | `wahr`<br>`wahr`<br>`wahr`<br>`falsch`     |
+| `entweder ... oder` | Wahr, wenn *nur* eines der Beiden Argumente wahr ist. | `true != false`   | `entweder wahr oder wahr`<br>`entweder wahr oder falsch`<br>`entweder falsch oder wahr`<br>` entweder falsch oder falsch` | `falsch`<br>`wahr`<br>`wahr`<br>`falsch`   |
+| nicht               | Der Wert des Arguments wird umgekehrt.                | `!true`           | `nicht wahr` <br>`nicht falsch`                                                                                           | `falsch`<br>`wahr`                         |
 
 # Vergleichsoperatoren
 
@@ -61,6 +63,11 @@ Mithilfe von Bool'schen Operatoren können komplexe Bedingungen ausgedrückt und
 | zwischen          | Wahr, wenn das Linke Argument zwischen den beiden Rechten liegt.                      | `(4 < 5 && 4 > 3)`     | `4 zwischen 3 und 5 ist`                                                                     | `wahr`<br>`falsch`           |
 
 Vergleichsoperatoren haben alle ein "ist" am Ende um der Grammatik in jedem Kontext gerecht zu werden.
+Falls das zu mehreren "ist"s hintereinander führen sollte reicht ein einziges aus:
+```ddp
+2 größer als 2 ist gleich 4 größer als 4 ist ist. [hässlich]
+2 größer als 2 ist gleich 4 größer als 4 ist. [schön]
+```
 
 # Listen und Text Operatoren
 
@@ -81,16 +88,16 @@ Die Operanden Typen einer Verkettung können nicht beliebig kombiniert werden.
 - Verkettet man einen Text mit einem Buchstaben oder umgekehrt entsteht ein Text.
 - Verkettet man eine Liste und einen beliebigen Wert vom Element Typ der Liste oder umgekehrt entsteht eine Liste.
 
-Bei Indizierungen und `von ... bis` sind die Indizes immer inklusiv und fangen bei 1 an.
+Bei Indizierungen und `im Bereich von ... bis` sind die Indizes immer inklusiv und fangen bei 1 an.
 Eine Liste von 1 bis 5 sind also das erste, das fünfte und alle Element dazwischen.
 Eine Liste an der Stelle 0 wäre ein Laufzeitfehler, genauso wie ein Index, der die Länge der Liste überschreitet.
 
-Bei `von ... bis` gibt es keine Laufzeitfehler bei zu kleinen oder zu großen Indizes.
+Bei `im Bereich von ... bis` gibt es keine Laufzeitfehler bei zu kleinen oder zu großen Indizes.
 Die Indizes werden automatisch in den Bereich [1, Länge der Liste/Text] gebracht.
 Sollte danach der 2. Index kleiner als der 1. sein, so gibt es einen Laufzeitfehler.
 Wenn also beide Indizes größer als die Länge der Liste sind, so ist das Ergebnis also das Letzte Element der Liste.
 
-`... ab dem ...` und `... bis zum ...` sind nur Kurzschreibweisen von `von ... bis` mit dem zweiten bzw. ersten Operanden
+`... ab dem ...` und `... bis zum ...` sind nur Kurzschreibweisen von `im Bereich von ... bis` mit dem zweiten bzw. ersten Operanden
 auf die Länge der Liste bzw. 1 gesetzt ist.
 
 ## Beispiele
@@ -106,6 +113,14 @@ Schreibe ("Hallo" von 1 bis 3 verkettet mit 'ö'). [Zeigt "Halö" in der Konsole
 Schreibe ('b' verkettet mit 'a'). [Zeigt "b, a" in der Konsole]
 ```
 
+# Falls
+
+Der `Falls` Operator entspricht dem Ternary Operator (`a ? b : c`) in anderen Sprachen.
+Seine Parameter sind ein Wahrheitswert und 2 Ausdrücke beliebigen (aber des gleich) Typs:
+```ddp
+Der Text t ist "2 > 3", falls 2 größer als 3 ist, ansonsten "2" verkettet mit " < " verkettet mit "3".
+```
+
 # Operator Priorisierung
 
 Verschiedene Operatoren werden verschieden Priorisiert.
@@ -115,28 +130,30 @@ Potenzen haben wiederrum Vorrang vor Multiplikationen und Divisionen.
 Bei den mathemathischen Operatoren hält DDP sich weitestgehend an die mathemathische Reihenfolge.
 Hier ist eine Tabelle mit allen Operatoren und ihrer Priorisierung (hoch priorisierte Operatoren oben):
 
-| Rang | Operator                                          |
-| ---- | ------------------------------------------------- |
-| 1    | Funktionsaufruf                                   |
-| 2    | Literale, Konstante                               |
-| 3    | Klammern                                          |
-| 4    | Typkonvertierungen                                |
-| 5    | Feld Zugriff von Kombinationen                    |
-| 6    | Indizierung                                       |
-| 7    | `von ... bis`, `ab ... dem`, `bis ... zum`        |
-| 8    | Potenzieren, Wurzelziehen, Logarithmus            |
-| 9    | Negation,                                         |
-| 10   | Betrag, Größe, Länge, Logisches-/Bool'sches nicht |
-| 11   | Multiplikation, Division, Rest,                   |
-| 12   | Addition, Subtrakion, Verkettung,                 |
-| 13   | Bit-Verschiebung                                  |
-| 14   | Größen Vergleich (kleiner, größer, ect.)          |
-| 15   | Gleichheit (gleich und ungleich)                  |
-| 16   | Logische UND Verknüpfung                          |
-| 17   | Logische XOR Verknüpfung                          |
-| 18   | Logische ODER Verknüpfung                         |
-| 19   | Bool'sches UND                                    |
-| 20   | Bool'sches ODER                                   |
+| Rang | Operator                                                        |
+| ---- | --------------------------------------------------------------- |
+| 1    | Funktionsaufruf                                                 |
+| 2    | Literale, Konstante                                             |
+| 3    | Klammern                                                        |
+| 4    | Typkonvertierungen                                              |
+| 5    | Feld Zugriff von Kombinationen                                  |
+| 6    | Indizierung                                                     |
+| 7    | `von ... bis`, `ab ... dem`, `bis ... zum`                      |
+| 8    | Potenzieren, Wurzelziehen, Logarithmus                          |
+| 9    | Negation,                                                       |
+| 10   | Betrag, Größe, Länge, Standardwert, Logisches-/Bool'sches nicht |
+| 11   | Multiplikation, Division, Rest,                                 |
+| 12   | Addition, Subtrakion, Verkettung,                               |
+| 13   | Bit-Verschiebung                                                |
+| 14   | Größen Vergleich (kleiner, größer, ect.)                        |
+| 15   | Gleichheit (gleich und ungleich)                                |
+| 16   | Logische UND Verknüpfung                                        |
+| 17   | Logische XOR Verknüpfung                                        |
+| 18   | Logische ODER Verknüpfung                                       |
+| 19   | Bool'sches UND                                                  |
+| 20   | Bool'sches ODER                                                 |
+| 21   | `entweder ... oder`                                             |
+| 22   | Falls                                                           |
 
 ## Operator Priorisierung Beispiel
 

diff --git a/content/DE/Programmierung/Variablen.md b/content/DE/Programmierung/Variablen.md
@@ -21,6 +21,15 @@ Wenn man solche Variablen mit einem Ausdruck deklarieren will, sollte man stattd
 ```ddp
 Der Wahrheitswert <Variablenname> ist <wahr oder falsch>, wenn <Ausdruck>. 
 ```
+
+Diese Syntax funktioniert auch mit Rückgaben in [Funktionen](/Bedienungsanleitung/de/Programmierung/Funktionen):
+```ddp
+Die öffentliche Funktion Ist_Leer_Text mit dem Parameter liste vom Typ Text Liste, gibt einen Wahrheitswert zurück, macht:
+	Gib wahr, wenn die Länge von liste gleich 0 ist zurück.
+Und kann so benutzt werden:
+	"<liste> leer ist"
+```
+
 Eine Liste von allen Datentypen findest du im Artikel [Datentypen](/Bedienungsanleitung/de/Programmierung/Datentypen)
 
 ## Beispiele:
@@ -47,6 +56,30 @@ Um einer Variable das Ergebnis eines Ausdrucks zuzuweisen, muss `Speichere ... i
 Speichere pi durch 2 in b.
 ```
 
+# Extern sichtbare Variablen
+
+Der DDP Kompilierer benutzt eine Technik namens [name mangling](https://en.wikipedia.org/wiki/Name_mangling). Das heißt, die Namen von Funktionen und Variablen
+sind im Quellcode nicht dieselben wie in der entstehenden Binärdatei.
+
+Wenn man also eine Variable zwischen DDP und C Quellcode teilen will muss man das name mangling ausschalten, indem man die Variable als "extern sichtbar" markiert:
+```ddp
+[test.ddp]
+Die extern sichtbare Zahl z ist 22.
+```
+
+```c
+// test.c
+#include "ddptypes.h"
+#include <stdio.h>
+
+extern ddpint z;
+
+int main(void) {
+    printf("%ld", z);
+    return 0;
+}
+```
+
 # Spezielle Zuweisungen
 
 Es gibt noch eineige Zuweisungsoperatoren mit deren Hilfe Variablen direkt verändert werden können,

diff --git a/go.mod b/go.mod
@@ -2,6 +2,4 @@ module github.com/DDP-Projekt/Bedienungsanleitung/gen
 
 go 1.22.2
 
-require github.com/DDP-Projekt/Kompilierer v0.3.0-alpha
-
-require github.com/kardianos/osext v0.0.0-20190222173326-2bc1f35cddc0 // indirect
+require github.com/DDP-Projekt/Kompilierer v0.4.0-alpha
diff --git a/go.sum b/go.sum
@@ -1,4 +1,2 @@
-github.com/DDP-Projekt/Kompilierer v0.3.0-alpha h1:w/k3DeSuNKcUUP1C8zZg1rLHIx6A2UQ5CzQjeLCADK4=
-github.com/DDP-Projekt/Kompilierer v0.3.0-alpha/go.mod h1:TQzKKQuclk2+fn9dGZ+XqyoZER8eZLr4iWGD1bXZVTg=
-github.com/kardianos/osext v0.0.0-20190222173326-2bc1f35cddc0 h1:iQTw/8FWTuc7uiaSepXwyf3o52HaUYcV+Tu66S3F5GA=
-github.com/kardianos/osext v0.0.0-20190222173326-2bc1f35cddc0/go.mod h1:1NbS8ALrpOvjt0rHPNLyCIeMtbizbir8U//inJ+zuB8=
+github.com/DDP-Projekt/Kompilierer v0.4.0-alpha h1:zQadWm8wLjOTN3/pWDLDLfNBM/I4Apx8GaxWGNRZfvE=
+github.com/DDP-Projekt/Kompilierer v0.4.0-alpha/go.mod h1:wIQjgAVockUlLS3bRd2WSuJlPUFC+ZTZizIQ1rsEeP4=