KITE: Sprache in C für Termux und Android

KITE: Eine handgefertigte Programmiersprache in C für Termux

Ein Entwickler hat die Programmiersprache KITE in reinem C implementiert und sie so kompiliert, dass sie in Termux auf Android läuft. Der Interpreter nutzt eine klassische Architektur: Lexer, Parser und einen baumdurchlaufenden Interpreter. Der gesamte Code umfasst etwa 3200 Zeilen, wobei der Fokus auf Leistung durch Referenzzählung statt Garbage Collection liegt.

Die Syntax ist auf Lesbarkeit ausgelegt: keine Semikolons, Blöcke mit Doppelpunkten und end. Variablen werden mit set deklariert, bedingte Konstrukte sind when/orwhen/else, und Rückgabe erfolgt mit give.

Beispiel für einfachen Code:

set name = "Welt"
say("Hallo, ${name}!")

def factorial(n):
    when n <= 1: give 1 end
    give n * factorial(n - 1)
end

loop for i in range(10):
    say("${i}! = ${factorial(i)}")
end

Interpreter-Architektur

Lexer

Der Lexer (lexer.c, ~200 Zeilen) tokenisiert den Quellcode. Er unterstützt String-Interpolation ${}: "Hallo, ${name}!" wird zu TK_FMTSTR mit Subausdrücken. Token: TK_SET, TK_IDENT, TK_NUM, TK_PLUS, usw.

Parser

Ein rekursiver Abstiegsparser (parser.c, ~700 Zeilen) baut den AST auf. Knoten sind Enum NKind:

typedef enum {
    ND_NUM, ND_STR, ND_FMTSTR, ND_BOOL, ND_NIL,
    ND_SET, ND_ASSIGN, ND_BINOP, ND_UNOP,
    ND_CALL, ND_INDEX, ND_PROP,
    ND_DEF, ND_WHEN, ND_LOOP_WHILE, ND_LOOP_FOR,
    ND_DO, ND_OBJ, ND_GIVE, ND_BREAK, ND_NEXT,
    /* ... */
} NKind;

Ausdruckspräzedenz: assign → or → and → not → cmp → add → mul → pow → unary → postfix → primary.

Interpreter

Der baumdurchlaufende Interpreter (interp.c, ~1600 Zeilen) durchläuft den AST rekursiv:

Value *eval(Interp *ip, Node *n, Env *env) {
    switch (n->kind) {
        case ND_NUM:  return val_num(n->num);
        case ND_SET: {
            Value *v = eval(ip, n->set.val, env);
            env_def(env, n->set.name, v);
            return val_nil();
        }
        /* ... */
    }
}

Speicherverwaltung und Closures

Referenzzählung in der Value-Struktur:

struct Value {
    VType type;
    int   refs;
    union { double num; char *str; KiteList *list; /* ... */ };
};

val_ref() / val_unref() verwalten die Freigabe. Closures erfassen Env:

typedef struct KiteFn {
    char  *name;
    char **params;
    int    nparams;
    Node  *body;
    Env   *closure;
    int    refs;
} KiteFn;

Beispiel:

def make_counter(start):
    set count = start
    def inc():
        count += 1
        give count
    end
    give inc
end

set c = make_counter(0)
say(c())   # 1
say(c())   # 2

Objektorientierte Programmierung

OOP über obj: Klassen sind KiteClass mit Methoden, Instanzen sind KiteInstance mit Feldern. Vererbung, super, private Felder mit _.

obj Animal:
    set name = nil

    def init(self, name):
        self.name = name
    end

    def speak(self):
        say("${self.name} macht ein Geräusch")
    end
end

obj Dog extends Animal:
    set _tricks = 0

    def learn(self):
        self._tricks += 1
    end

    def speak(self):
        super.speak(self)
        say("${self.name}: Wuff!")
    end
end

set d = Dog.new("Buddy")
d.learn()
d.speak()
say(d is Dog)       # true

Fehlerbehandlung und Standardbibliotheken

do/err-Blöcke:

do:
    set data = file_read("config.txt")
err IOError:
    say("Datei nicht gefunden, erstelle...")
    file_create("config.txt")
err:
    say("Unerwarteter Fehler: ${err_msg}")
end

Fehlertypen: ZeroDivisionError, NameError, IndexError, TypeError, IOError, AccessError.

Standardmodule:

• math: tan, log2, clamp, lerp
• rand: rand(), rand_choice()
• string: str_pad_left, str_count
• list: list_sum, list_zip
• io: file_read, file_lines
• os: os_env, os_shell

Kompilierung und Ausführung in Termux

Installation:

• pkg install clang make
• tar -xzf kite-lang.tar.gz
• cd kite-lang
• make CC=clang
• cp kite $PREFIX/bin/kite
• kite --version

REPL-Unterstützung, vim/micro mit Syntax-Hervorhebung.

Dateistatistiken:

| Datei | Zeilen | Rolle |

|-----------|--------|------------------------|

| kite.h | ~250 | Typen, AST |

| lexer.c | ~200 | Tokenizer |

| parser.c | ~700 | Parser |

| value.c | ~300 | Werte, Referenzzählung |

| interp.c | ~1600 | Interpreter |

| main.c | ~120 | REPL, Einstieg |

Gesamt: ~3200 Zeilen.

Wichtige Erkenntnisse

• Minimalistische Syntax mit set/when/give für Lesbarkeit und Fehlervermeidung.
• Referenzzählung ohne GC sorgt für vorhersehbare Leistung.
• Vollwertige OOP mit Vererbung, Closures und Kapselung.
• Kompilierung auf Android/Termux ohne Abhängigkeiten.
• Open Source (MIT), bereit für Forks und PRs.

— Editorial Team