KITE: lenguaje en C para Termux y Android

KITE: Un lenguaje de programación artesanal en C para Termux

Un desarrollador ha implementado el lenguaje de programación KITE en C puro, compilándolo para ejecutarse en Termux en Android. El intérprete utiliza una arquitectura clásica: lexer, parser e intérprete de recorrido de árbol. La base de código total es de unas 3200 líneas, con un enfoque en el rendimiento mediante conteo de referencias en lugar de recolección de basura.

La sintaxis está diseñada para legibilidad: sin punto y coma, bloques usando dos puntos y end. Las variables se declaran con set, las construcciones condicionales son when/orwhen/else, y el retorno es give.

Ejemplo de código básico:

set nombre = "mundo"
say("¡Hola, ${nombre}!")

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

Arquitectura del intérprete

Lexer

El lexer (lexer.c, ~200 líneas) tokeniza el código fuente. Soporta interpolación de cadenas ${}: "¡Hola, ${nombre}!" se convierte en TK_FMTSTR con subexpresiones. Tokens: TK_SET, TK_IDENT, TK_NUM, TK_PLUS, etc.

Parser

Un parser descendente recursivo (parser.c, ~700 líneas) construye el AST. Los nodos son 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;

Precedencia de expresiones: assign → or → and → not → cmp → add → mul → pow → unary → postfix → primary.

Intérprete

El intérprete de recorrido de árbol (interp.c, ~1600 líneas) recorre recursivamente el 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();
        }
        /* ... */
    }
}

Gestión de memoria y clausuras

Conteo de referencias en la estructura Value:

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

val_ref() / val_unref() gestionan la desasignación. Las clausuras capturan Env:

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

Ejemplo:

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

Programación orientada a objetos

POO mediante obj: las clases son KiteClass con métodos, las instancias son KiteInstance con campos. Herencia, super, campos privados con _.

obj Animal:
    set nombre = nil

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

    def speak(self):
        say("${self.nombre} hace un sonido")
    end
end

obj Dog extends Animal:
    set _trucos = 0

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

    def speak(self):
        super.speak(self)
        say("${self.nombre}: ¡Guau!")
    end
end

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

Manejo de errores y bibliotecas estándar

Bloques do/err:

do:
    set datos = file_read("config.txt")
err IOError:
    say("Archivo no encontrado, creando...")
    file_create("config.txt")
err:
    say("Error inesperado: ${err_msg}")
end

Tipos de error: ZeroDivisionError, NameError, IndexError, TypeError, IOError, AccessError.

Módulos estándar:

• 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

Compilación y ejecución en Termux

Instalación:

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

Soporte REPL, vim/micro con resaltado de sintaxis.

Estadísticas de archivos:

| Archivo | Líneas | Rol |

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

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

| lexer.c | ~200 | Tokenizador |

| parser.c | ~700 | Parser |

| value.c | ~300 | Valores, conteo de refs |

| interp.c | ~1600 | Intérprete |

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

Total: ~3200 líneas.

Conclusiones clave

• Sintaxis minimalista con set/when/give para legibilidad y prevención de errores.
• Conteo de referencias sin GC garantiza rendimiento predecible.
• POO completa con herencia, clausuras y encapsulación.
• Compilación en Android/Termux sin dependencias.
• Código abierto (MIT), listo para forks y PRs.

— Editorial Team