lny-interpreter 0.99.0

package/docs/INTERPRETER.md

@@ -0,0 +1,240 @@
+# Lny 1.0 Interpreter
+
+Ein vollständig funktionsfähiger Interpreter für die Programmiersprache **Lny 1.0**, implementiert in TypeScript. Der Interpreter unterstützt mehrere Sprachen (Deutsch, Englisch, Französisch, Spanisch, Italienisch) und kann sowohl als Konsolen-REPL als auch als Web-Anwendung verwendet werden.
+
+## Features
+
+✅ **Mehrsprachige Unterstützung** - Alle Befehle und Meldungen in 5 Sprachen  
+✅ **Vollständiger Lexer & Parser** - Robuste Syntaxanalyse mit Fehlerbehandlung  
+✅ **AST-basierter Interpreter** - Sichere Codeausführung  
+✅ **Verschachtelte Ausdrücke** - Unterstützung für komplexe Ausdrücke mit Operatorpriorität  
+✅ **Weltbefehle** - Lenny-spezifische Bewegungs- und Sensorbefehle  
+✅ **REPL Konsole** - Interaktive Konsolenanwendung  
+✅ **Browser-Version** - Web-basierte Benutzeroberfläche  
+
+## Installation und Verwendung
+
+### Voraussetzungen
+- Node.js 14+
+- npm
+
+### Build und Ausführung
+
+```bash
+# Installation der Dependencies
+npm install
+
+# TypeScript kompilieren
+npm run build
+
+# REPL starten
+npm start:repl
+```
+
+## Sprachelemente
+
+### Kernbefehle (in allen unterstützten Sprachen)
+
+| Befehl | Bedeutung |
+|--------|-----------|
+| **VAR** | Variablendefinition |
+| **SETZE** (`<<`) | Wertzuweisung |
+| **WENN/DANN/SONST/ENDE** | Bedingter Block |
+| **SOLANGE/ENDE** | While-Schleife |
+| **FÜR/IN/ENDE** | For-Schleife |
+| **PROZEDUR/ENDE** | Funktionsdefinition |
+| **SCHREIB** | Ausgabe auf Konsole |
+| **REM** | Kommentar |
+
+### Weltbefehle (Lenny-spezifisch)
+
+| Befehl | Bedeutung | Rückgabe |
+|--------|-----------|---------|
+| **LAUF** | Lenny läuft nach vorne | nothing |
+| **DREH_LINKS** | Laufdirection nach links drehen | nothing |
+| **NIMM** | Knochen vom Feld aufnehmen | nothing |
+| **GIB** | Knochen auf das Feld legen | nothing |
+| **IST_FREI** | Prüfe ob Feld frei ist | true/false |
+| **IST_KNOCHEN** | Prüfe ob Knochen vorhanden | true/false |
+| **SPRING** | Über Hindernis springen | nothing |
+| **SCHAU** | Feld in Laufrichtung betrachten | string |
+
+### Operatoren
+
+#### Arithmetisch
+- `+` Addition
+- `-` Subtraktion
+- `*` Multiplikation
+- `/` Division
+- `%` Modulo
+- `**` Potenzierung
+
+#### Vergleich
+- `<` Kleiner als
+- `>` Größer als
+- `<=` Kleiner gleich
+- `>=` Größer gleich
+- `==` Gleich
+- `<>` Ungleich
+
+#### Logisch
+- `UND` und
+- `ODER` oder
+- `NICHT` nicht
+
+#### Zuweisungen
+- `<<` Wertzuweisung
+- `+=` Addition und Zuweisung
+- `-=` Subtraktion und Zuweisung
+- `*=` Multiplikation und Zuweisung
+- `/=` Division und Zuweisung
+
+## Beispiele
+
+### Variablen und mathematische Operationen
+
+```lny
+VAR x << 10
+VAR y << 20
+VAR ergebnis << x + y * 2
+SCHREIB ergebnis
+```
+
+### Bedingter Block
+
+```lny
+VAR alter << 18
+
+WENN alter >= 18 DANN
+  SCHREIB "Erwachsen"
+SONST
+  SCHREIB "Minderjährig"
+ENDE
+```
+
+### While-Schleife
+
+```lny
+VAR zaehler << 0
+
+SOLANGE zaehler < 5
+  SCHREIB zaehler
+  zaehler += 1
+ENDE
+```
+
+### For-Schleife
+
+```lny
+VAR liste << [10, 20, 30, 40, 50]
+
+FÜR element IN liste
+  SCHREIB element
+ENDE
+```
+
+### Prozedur (Funktion)
+
+```lny
+PROZEDUR quadrat(n)
+  VAR ergebnis << n * n
+  SCHREIB ergebnis
+ENDE
+
+quadrat(5)
+```
+
+### Lenny Bewegung
+
+```lny
+REM Lenny läuft auf freiem Feld
+WENN IST_FREI DANN
+  LAUF
+SONST
+  DREH_LINKS
+ENDE
+```
+
+## REPL Befehle
+
+In der interaktiven REPL:
+
+```
+:exit       - REPL beenden
+:lang <xx>  - Sprache ändern (en, de, fr, es, it)
+:clear      - Ausgabe löschen
+:state      - Lenny-Status anzeigen
+:help       - Hilfemeldung anzeigen
+```
+
+## Sprachunterstützung
+
+Der Interpreter unterstützt die folgenden Sprachen:
+
+- **Deutsch** (de) - Standard
+- **English** (en)
+- **Français** (fr)
+- **Español** (es)
+- **Italiano** (it)
+
+Die Landessprache wird automatisch erkannt. Sie kann mit `:lang <xx>` angegeben werden.
+
+## Architektur
+
+```
+src/
+├── lexer/        - Tokenisierung und lexikalische Analyse
+├── parser/       - Syntaxanalyse (AST-Generierung)
+├── interpreter/  - AST-Interpretation und Ausführung
+├── ast/          - AST-Knotendefinitionen
+├── i18n/         - Mehrsprachige Unterstützung
+├── world/        - Lenny-Welt und Weltbefehle
+├── repl.ts       - Interaktive Konsolenanwendung
+└── index.ts      - Public API
+```
+
+## TypeScript Typsicherheit
+
+Das Projekt nutzt strikte TypeScript-Konfiguration für Typsicherheit:
+- `strict: true`
+- `esModuleInterop: true`
+- `forceConsistentCasingInFileNames: true`
+
+## Erweiterungsmöglichkeiten
+
+Das System ist modular aufgebaut und kann einfach erweitert werden:
+
+1. **Neue Sprachen hinzufügen** - In `src/i18n/i18n.ts` neue Übersetzungen hinzufügen
+2. **Neue Built-In Befehle** - In `src/world/world.ts` neue Methoden registrieren
+3. **Neue Kernbefehle** - In `src/parser/parser.ts` neue Statement-Typen behandeln
+4. **Neue Operatoren** - In `src/interpreter/interpreter.ts` neue Operatoren hinzufügen
+
+## Testing
+
+```bash
+npm test  # (wird noch implementiert)
+```
+
+## Browser-Version
+
+Eine Web-basierte Version ist unter `index.html` verfügbar. Sie kann lokal mit einem HTTP-Server geöffnet werden:
+
+```bash
+python -m http.server 8000
+# oder
+npx http-server
+```
+
+Dann `http://localhost:8000` im Browser öffnen.
+
+## Lizenz
+
+MIT
+
+## Autor
+
+Erstellt für das Lny 1.0 Sprachprojekt
+
+---
+
+**Viel Spaß beim Programmieren mit Lny!** 🐕

package/docs/README.md

@@ -0,0 +1,68 @@
+# Lenny2
+
+Letzte Aktualisierung: **11/03/2026**
+
+Interpreter-Implementierung fuer **Lny 1.0** in TypeScript mit:
+
+- Lexer + Parser + AST + Evaluator
+- Mehrsprachigen Kernbefehlen (de, en, fr, es, it)
+- Mehrsprachigen Weltbefehlen (LennyWorld)
+- REPL fuer die Konsole
+- Browser-UI (index.html)
+
+## Schnellstart
+
+```bash
+npm install
+npm run build
+npm run test
+npm run start:repl
+# optional: direkt ein Skript starten
+npm run start:repl -- examples/00-demo.lny
+```
+
+## Projektstruktur
+
+- `src/lexer/lexer.ts`: Tokenizer mit sprachuebergreifender Keyword-Erkennung
+- `src/parser/parser.ts`: Parser mit Operator-Prioritaet und Klammerausdruecken
+- `src/interpreter/interpreter.ts`: AST-Interpreter inkl. Kontrollfluss
+- `src/world/world.ts`: LennyWorld + Built-ins (`RUN`, `TURN_LEFT`, ...)
+- `src/i18n/i18n.ts`: Uebersetzungen fuer Befehle und Meldungen
+- `src/repl.ts`: Interaktive Konsolen-REPL
+- `examples/*.lny`: Ausfuehrbare Lny-Skriptdateien (Beispiel: `examples/00-demo.lny`)
+- `index.html`: Browser-Oberflaeche
+
+## Spracheigenschaften
+
+- Kernbefehle intern auf Englisch modelliert (Token/AST)
+- Eingabe in einer der unterstuetzten Landessprachen
+- Auswertung von verschachtelten Ausdruecken inkl. Klammern
+- Unterstuetzung fuer:
+	- `IF/THEN/ELSE/END`
+	- `WHILE/END`
+	- `FOR/IN/END`
+	- `VAR`, `SET` (per `<<`)
+	- `LOG`, `PROC`, `REM`
+	- Arithmetik, Vergleich, Logik, Potenz, zusammengesetzte Zuweisungen
+
+## Hinweise
+
+- Die REPL unterstuetzt zusaetzlich:
+	- `:lang <de|en|fr|es|it>`
+	- `:state`
+	- `:clear`
+	- `:run <pfad/zum/skript.lny>`
+	- `:help`
+	- `:exit`
+
+- Konfiguration ueber `lny-config.yml`:
+	- `language: de`
+	- `field_size: 10x10` (Default)
+
+- `.lny`-Skripte ausfuehren:
+	- Beim Start: `npm run start:repl -- examples/00-demo.lny`
+	- In der REPL: `:run examples/00-demo.lny`
+
+- Eine ausfuehrliche Dokumentation liegt in `INTERPRETER.md`.
+
+

package/docs/i18n/README.md

@@ -0,0 +1,20 @@
+# Lokalisierte Help-Dateien
+
+Die Browser-Hilfe laedt pro Sprache zuerst diese Dateien:
+
+- `docs/i18n/en/lny-referenz.md`
+- `docs/i18n/en/INTERPRETER.md`
+- `docs/i18n/fr/lny-referenz.md`
+- `docs/i18n/fr/INTERPRETER.md`
+- `docs/i18n/es/lny-referenz.md`
+- `docs/i18n/es/INTERPRETER.md`
+- `docs/i18n/it/lny-referenz.md`
+- `docs/i18n/it/INTERPRETER.md`
+
+Wenn eine lokalisierte Datei fehlt, faellt die Hilfe automatisch auf die Standarddatei in `docs/` zurueck.
+
+Empfohlener Start:
+
+1. Kopiere `docs/lny-referenz.md` und `docs/INTERPRETER.md` in den gewuenschten Sprachordner.
+2. Uebersetze die Texte dort.
+3. Lade die Browser-Seite neu und oeffne die Hilfe in der gewuenschten Sprache.

package/docs/lny-referenz.md

@@ -0,0 +1,161 @@
+# Lny 1.0 Befehlsreferenz
+
+Letzte Aktualisierung: **25/02/2026**
+
+# Der Befehlssatz von Lny 1.0
+
+## Quick Reference - Alle Befehle
+
+### Kernbefehle
+- **IF** – Leitet einen IF-ELSE-Befehl ein (es folgt immer eine Bedingung)
+- **THEN** – Leitet den Bedingungszweig ein
+- **ELSE** – Leitet den Alternativzweig ein
+- **END** – Beendet IF, THEN, WHILE, FOR und PROC
+- **WHILE** – Leitet eine Solange-Wiederholung ein (es folgt immer eine Bedingung)
+- **FOR** – Leitet eine FOR-Wiederholung ein (es folgt immer eine Variable)
+- **IN** – Gibt an, was bei FOR durchlaufen werden soll (es folgt immer eine Liste)
+- **VAR** – Definiert eine Variable (es gibt keine Datentypen)
+- **SET** – Weist einer Variablen einen Wert per `<<` zu
+- **LIST** – Definiert eine Liste (Werte stehen immer in eckigen Klammern)
+- **LOG** – Gibt eine Meldung in der Konsole aus
+- **PROC** – Leitet eine Prozedur ein (es folgt immer ein Name)
+- **REM** – Leitet eine Kommentarzeile ein
+
+### Weltbefehle (built-ins)
+- **RUN** – Lenny läuft in der Laufrichtung nach vorn
+- **TURN_LEFT** – Die Laufrichtung von Lenny dreht sich nach links
+- **TAKE** – Lenny nimmt einen Knochen vom Feld auf
+- **GIVE** – Lenny legt einen Knochen aus der Knochenbox auf das Feld
+- **FREE_AHEAD** – Prüft, ob das Feld in der Laufrichtung frei ist (gibt TRUE/FALSE zurück)
+- **THING_THERE** – Prüft, ob sich auf dem Feld in der Laufrichtung ein Knochen befindet (gibt TRUE/FALSE zurück)
+- **JUMP** – Lenny springt über einen Baumstamm
+- **LOOK** – Lenny schaut auf das Feld in der Laufrichtung
+- **HOLE_POSITION** (EN: GET_POSITION, FR: OBTIENS_POSITION, ES: OBTEN_POSITION, IT: OTTIENI_POSIZIONE) – Gibt die aktuelle Position von Lenny als String x:y zurück
+- **PRIVATE** – Gibt den Wert eines privaten Attributs zurück
+- **GLOBAL** – Gibt den Wert eines globalen Attributs zurück
+- **ZUFALL [max] [min]** – Erzeugt eine Zufallszahl. Ohne Argumente: Zahl zwischen 0 und 1 (float). Mit einem Argument: Ganzzahl zwischen 0 und max (inklusive, auch negativ). Mit zwei Argumenten: Ganzzahl zwischen min und max (inklusive, auch negativ). Synonyme: RANDOM, ALEATOIRE, ALEATORIO, CASUALE|*NUMBER*|
+
+### Operatoren
+- **<<** – Wertzuweisung
+- **<, >, <=, >=** – Kleiner, größer, Kleiner-Gleich, Größer-Gleich
+- **==** – Gleich
+- **<>** – Ungleich
+- **+, -, /, *** – Grundrechenarten
+- **%** – Modulo
+- `**` – Potenz
+- **NICHT** – Umkehrung (Unär)
+- **UND** – Und-Verknüpfung
+- **ODER** – Oder-Verknüpfung
+- **+=** – Inkrement
+- **-=** – Dekrement
+- ***=** – Multipliation und Zuweisung
+- **/=** – Division und Zuweisung
+
+### Private Attribute von Lenny
+- **name** – Der Name des Hundes (aktuell immer "Lenny")
+- **birthday** – Der Geburtstag des Hundes
+- **hungry** – Wie hungrig ist der Hund
+- **thirsty** – Wie durstig ist der Hund
+- **howManyRun** – Wie oft ist der Hund bereits gelaufen
+- **howManyTurn** – Wie oft hat sich der Hund bereits gedreht
+- **howManyJump** – Wie oft ist der Hund bereits gesprungen
+
+---
+
+### Weltbefehle (built-ins) - Detailliert
+
+Weltbefehle (built-ins) sind Befehle, die mit einer bestimmten "Welt" geladen werden. Eine Welt stellt eine Umgebung zur Verfügung, auf die die Kernbefehle angewendet werden.
+
+Am Anfang gibt es nur eine Welt, die "LennyWorld". Sie besteht aus einem Terrain, auf dem Lenny laufen, über Hindernisse springen und Knochen einsammeln und ablegen kann.
+
+Die Menge der Weltbefehle wird absichtlich klein gehalten. In der "LennyWorld" gibt es z.B. nur einen `TURN_LEFT`-Befehl und kein *TURN_RIGHT*-Pendant. Auch wenn dadurch die Programmierung etwas umständlicher wird, soll damit das algorithmische Denkvermögen trainiert werden.
+
+Zu einer Welt gehören auch globale Variablen.
+
+|Built-In|Bedeutung|Rückgabe|
+|------|---------|--------|
+|RUN|Lenny läuft in der Laufrichtung nach vorn|*NOTHING*|
+|TURN_LEFT|Die Laufrichtung von Lenny dreht sich nach links|*NOTHING*|
+|TAKE|Lenny nimmt einen Knochen vom Feld auf|*NOTHING*|
+|GIVE|Lenny legt einen Knochen aus der Knochenbox auf das Feld|*NOTHING*|
+|FREE_AHEAD|Prüft,ob das Feld in der Laufrichtung frei ist|*TRUE*/*FALSE*|
+|THING_THERE|Prüft, ob sich auf dem Feld in der Laufrichtung ein Knochen befindet|*TRUE*/*FALSE*|
+|JUMP|Lenny springt über einen Baumstamm (bzw. allgemein ein Hinderniss), das sich auf dem Feld vor ihm in der Laufrichtung befindet|*NOTHING*|
+|LOOK|Lenny schaut auf das Feld, das sich vor ihm in der Laufrichtung befindet|Gegenstand als enum|*NOTHING*|
+|HOLE_POSITION<br>EN: GET_POSITION<br>FR: OBTIENS_POSITION<br>ES: OBTEN_POSITION<br>IT: OTTIENI_POSIZIONE|Gibt die aktuelle Position von Lenny als String im Format x:y zurück (z.B. 0:0 für Start)|*STRING*|
+|PRIVATE <name>|Gibt den Wert eines privaten Attributs zurück|Variabel|
+|GLOBAL <name>|Gibt den Wert eines globalen Attributs zurück|Variabel|
+
+*TRUE*, *FALSE* und *NOTHING* sind Konstanten.
+
+### Globale Attribute
+
+Damit alles so einfach wie möglich bleibt, gibt es kein globales Objekt mit mehreren Attributen. Statt dessen gibt es mehrere globale Attribute, die über das Built-In *GLOBAL* angesprochen werden.
+
+Ein Beispiel ist *Territory*. Es steht für eine Liste, deren Elemente entweder über ein *(x,y)*-Tupel oder über die interne Bezeichnung, z.B. "A1", angesprochen werden.3
+
+Jedes Element ist vom Typ *Field*. Es enthält eine Liste aller Gegenstände, z.B. Doghut, Log, Bones, die über die privaten Attribute dieses Elements angesprochen werden (die genaue Syntax steht noch nicht fest).
+
+|Attribut|Bedeutung|Typ|
+|--------|---------|---|
+|Doghut|*TRUE*, wenn sich auf dem Feld eine Hundehuette befindet|*NUMBER*|
+|Log|*TRUE*, wenn sich auf dem Feld ein Baumstamm befindet|*NUMBER*|
+|Bones|Anzahl Knochen auf dem Feld|*LOGIC*|
+
+### Kernbefehle
+
+Die Kernbefehle steuern den Programmablauf und sind unabhängig von den Built-Ins einer bestimmten World.
+
+|Befehl|Bedeutung|Kommentar|
+|------|---------|--------------|
+|IF  |Leitet einen IF-ELSE-Befehl ein|Es folgt immer Bedingung|
+|THEN  |Leitet den Bedigungszweig ein| |
+|ELSE  |Leitet den Alternativzweig ein| |
+|END  |Beendet IF, THEN, WHILE, FOR und PROC|   |
+|WHILE|Leitet eine Solange-Wiederholung ein|Es folgt immer eine Bedingung|
+|FOR|Leitet eine FOR-Wiederholung ein|Es folgt immer eine Variable|
+|IN|Gibt an, was bei FOR durchlaufen werden soll|Es folgt immer eine Liste|
+|VAR|Definiert eine Variable|Es gibt keine Datentypen|
+|SET|Weist einer Variablen einen Wert per << zu|Es gibt keine Datentypen|
+|LIST|Definiert eine Liste|Die Werte stehen immer in eckigen Klammern|
+|LOG|Gibt eine Meldung in der Konsole aus|
+|PROC|Leitet eine Prozedur ein|Es folgt immer ein Name|
+|REM|Leitet eine Kommentarzeile ein|Es gibt nur Kommentarzeilen|
+
+### Operatoren
+
+|Operator|Bedeutung|
+|--------|---------|
+|<<      |Wertzuweisung|
+|<,>     |Kleiner, größer|
+|<=,>=   |Kleiner-Gleich, Größer-Gleich|
+|==      |Gleich   |
+|<>      |Ungleich |
+|+,-,/,* |Grundrechenarten|
+|%       |Modulo|
+|**      |Potenz|
+|NOT     |Umkehrung (Unär)|
+|UND     |Und-Verknüpfung|
+|ODER    |Oder-Verknüpfung|
+|+=      |Inkrement|
+|-=      |Dekrement|
+|*=      |Multipliation und Zuweisung|
+|/=      |Division und Zuweisung|
+
+### Private Attribute
+
+*Lenny* ist ein globales Objekt.
+
+*Lenny* besitzt eine Reihe privater Attribute, die über das Built-Ins *PRIVATE* angesprochen werden.
+
+|Attribut|Bedeutung|Typ|
+|--------|---------|---|
+|name|Der Name des Hundes, aktuell immer "Lenny"|STRING|
+|birthday|Der Geburtstag des Hundes, aktuell aktuelles Datum - 1 Jahr|DATE|
+|hungry|Wie hunrig ist der Hund|NUMBER|
+|thirsty|Wie durstig ist der Hund|NUMBER|
+|howManyRun|Wie oft ist der Hund bereits gelaufen|NUMBER|
+|howManyTurn|Wie oft hat sich der Hund bereits gedreht|NUMBER|
+|howManyJump|Wie oft ist der Hund bereits gesprungen|NUMBER|
+
+

package/docs/lny_ueberblick.md

@@ -0,0 +1,33 @@
+# Lny 1.0 im Überblick
+
+ _     _____ _   _ _   _ _   __   ___
+| |   | ____| \ | | \ | | \ / /  / _ \
+| |   |  _| |  \| |  \| |  V /  | | | |
+| |___| |___| |\  | |\  | /| \ | |_| |
+|_____|_____|_| \_|_| \_|/__| \_|\___/
+
+**Lny** ist eine einfache Interpreter-Sprache, die aus einer Reihe von Kernbefehlen besteht:
+
+- **IF** – Leitet einen IF-ELSE-Befehl ein (es folgt immer eine Bedingung)
+- **THEN** – Leitet den Bedingungszweig ein
+- **ELSE** – Leitet den Alternativzweig ein
+- **END** – Beendet IF, THEN, WHILE, FOR und PROC
+- **WHILE** – Leitet eine Solange-Wiederholung ein (es folgt immer eine Bedingung)
+- **FOR** – Leitet eine FOR-Wiederholung ein (es folgt immer eine Variable)
+- **IN** – Gibt an, was bei FOR durchlaufen werden soll (es folgt immer eine Liste)
+- **VAR** – Definiert eine Variable (es gibt keine Datentypen)
+- **SET** – Weist einer Variablen einen Wert per `<<` zu
+- **LIST** – Definiert eine Liste (Werte stehen immer in eckigen Klammern)
+- **LOG** – Gibt eine Meldung in der Konsole aus
+- **PROC** – Leitet eine Prozedur ein (es folgt immer ein Name)
+- **REM** – Leitet eine Kommentarzeile ein
+
+Offiziell gibt es bei *Lny* keine Datentypen, intern gibt es 
+
+- *NUMBER* any Integer number
+- *DATE*  a date time 
+- *STRING* a string with a length of 65356 to keep everything simple
+- *LOGIC* either *TRUE* or *FALSE*
+
+Um *Lny* so einfach wie möglich zu halten, gibt es in der Version 1.0 keine Klassen.
+

package/examples/00-demo.lny

@@ -0,0 +1,3 @@
+VAR x << 2
+SETZE x << x + 5
+SCHREIB x

package/examples/01-variable-assignment.lny

@@ -0,0 +1,4 @@
+VAR a << 5
+VAR b << 10
+VAR sum << a + b
+SCHREIB sum

package/examples/02-conditional.lny

@@ -0,0 +1,7 @@
+VAR age << 25
+
+IF age >= 18 THEN
+  SCHREIB "Erwachsen"
+ELSE
+  SCHREIB "Minderjaehrig"
+END

package/examples/03-while-loop.lny

@@ -0,0 +1,6 @@
+VAR count << 0
+
+WHILE count < 5
+  SCHREIB count
+  count += 1
+END

package/examples/04-for-loop.lny

@@ -0,0 +1,5 @@
+VAR listx << [1, 2, 3, 4, 5]
+
+FOR item IN listx
+  SCHREIB item
+END

package/examples/05-lenny-movement.lny

@@ -0,0 +1,10 @@
+IF FREE_AHEAD THEN
+  RUN
+  RUN
+  SCHREIB HOLE_POSITION
+  SCHREIB "Ich gehe vorwaerts.."
+ELSE
+  TURN_LEFT
+  SCHREIB "Ich drehe nach links.."
+  SCHREIB HOLE_POSITION
+END

package/examples/06-procedure.lny

@@ -0,0 +1,6 @@
+PROZEDUR greet(name)
+  SCHREIB "Hallo, "
+  SCHREIB name
+END
+
+greet("Alice")

package/examples/fuer-range-1.lny

@@ -0,0 +1,4 @@
+# Beispiel: Zahlen von 1 bis 5 ausgeben
+FUER i IN [1..5]
+    SCHREIBE i
+ENDE

package/examples/fuer-range-2.lny

@@ -0,0 +1,6 @@
+# Beispiel: Alle geraden Zahlen von 2 bis 10
+FUER n IN [2..10]
+    WENN n % 2 = 0
+        SCHREIBE n
+    ENDE
+ENDE

package/examples/fuer-range-3.lny

@@ -0,0 +1,6 @@
+# Beispiel: Summe der Zahlen von 1 bis 10 berechnen
+summe = 0
+FUER x IN [1..10]
+    summe = summe + x
+ENDE
+SCHREIBE summe

package/examples/fuer-range-4.lny

@@ -0,0 +1,4 @@
+# Beispiel: Rückwärts von 10 bis 1 zählen
+FUER z IN [10..1]
+    SCHREIBE z
+ENDE

package/examples/fuer-range-5.lny

@@ -0,0 +1,6 @@
+# Beispiel: Mit Variablen als Grenzen
+start = 3
+ende = 7
+FUER k IN [start..ende]
+    SCHREIBE k
+ENDE

package/examples/solange-verschachtelt.lny

@@ -0,0 +1,12 @@
+KOM Beispiel für ein verschachaltetes SOLANGE
+VAR i
+VAR j
+SETZE i AUF 1
+SOLANGE i <= 3
+    SETZE j AUF 1
+    SOLANGE j <= 2
+        SCHREIB "i = " + i + ", j = " + j
+        SETZE j AUF j + 1
+    ENDE
+    SETZE i AUF i + 1
+ENDE