KITE : langage en C pour Termux et Android

KITE : Un langage de programmation artisanal en C pour Termux

Un développeur a implémenté le langage de programmation KITE en C pur, le compilant pour fonctionner dans Termux sur Android. L'interpréteur utilise une architecture classique : lexer, parser et interpréteur à arbre syntaxique. La base de code totale est d'environ 3200 lignes, avec un accent sur les performances via le comptage de références plutôt que le ramasse-miettes.

La syntaxe est conçue pour la lisibilité : pas de points-virgules, les blocs utilisent des deux-points et end. Les variables sont déclarées avec set, les structures conditionnelles sont when/orwhen/else, et le retour est give.

Exemple de code basique :

set name = "world"
say("Hello, ${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

Architecture de l'interpréteur

Lexer

Le lexer (lexer.c, ~200 lignes) tokenise le code source. Il prend en charge l'interpolation de chaînes ${} : "Hello, ${name}!" devient TK_FMTSTR avec des sous-expressions. Tokens : TK_SET, TK_IDENT, TK_NUM, TK_PLUS, etc.

Parser

Un parser récursif descendant (parser.c, ~700 lignes) construit l'AST. Les nœuds sont l'énumération 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;

Précédence des expressions : assign → or → and → not → cmp → add → mul → pow → unary → postfix → primary.

Interpréteur

L'interpréteur à arbre syntaxique (interp.c, ~1600 lignes) parcourt récursivement l'AST :

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();
        }
        /* ... */
    }
}

Gestion de la mémoire et fermetures

Comptage de références dans la structure Value :

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

val_ref() / val_unref() gèrent la désallocation. Les fermetures capturent Env :

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

Exemple :

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

Programmation orientée objet

POO via obj : les classes sont KiteClass avec des méthodes, les instances sont KiteInstance avec des champs. Héritage, super, champs privés avec _.

obj Animal:
    set name = nil

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

    def speak(self):
        say("${self.name} fait un bruit")
    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} : Ouaf !")
    end
end

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

Gestion des erreurs et bibliothèques standard

Blocs do/err :

do:
    set data = file_read("config.txt")
err IOError:
    say("Fichier non trouvé, création...")
    file_create("config.txt")
err:
    say("Erreur inattendue : ${err_msg}")
end

Types d'erreur : ZeroDivisionError, NameError, IndexError, TypeError, IOError, AccessError.

Modules standard :

• 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

Compilation et exécution dans 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

Support REPL, vim/micro avec coloration syntaxique.

Statistiques des fichiers :

| Fichier | Lignes | Rôle |

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

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

| lexer.c | ~200 | Tokeniseur |

| parser.c | ~700 | Parseur |

| value.c | ~300 | Valeurs, comptage de ref |

| interp.c | ~1600 | Interpréteur |

| main.c | ~120 | REPL, point d'entrée |

Total : ~3200 lignes.

Points clés à retenir

• Syntaxe minimaliste avec set/when/give pour la lisibilité et la prévention des erreurs.
• Comptage de références sans GC garantit des performances prévisibles.
• POO complète avec héritage, fermetures et encapsulation.
• Compilation sur Android/Termux sans dépendances.
• Open source (MIT), prêt pour les forks et PRs.

— Editorial Team