Fonctions intégrées et E/S
Raml fournit un petit ensemble de mots-clés et fonctions intégrés pour les E/S, les opérations sur les chaînes et les mathématiques.
Aperçu
Cette section couvre les intégrés en un coup d'œil — assez pour les utiliser dans des programmes.
Référence rapide
| Intégré | Catégorie | Type retour | Description |
|---|---|---|---|
keyboard | E/S | bs_t | Lire une ligne depuis stdin |
print | E/S | — | Afficher des valeurs sur stdout |
save | E/S | — | Écrire un bitstream dans un fichier |
load | E/S | bs_t | Lire un bitstream depuis un fichier |
len | Chaîne | uint32_t | Longueur du bitstream en bits |
abs | Math | uint32_t | Valeur absolue |
min | Math | uint32_t | Minimum de deux valeurs |
max | Math | uint32_t | Maximum de deux valeurs |
pow | Math | uint32_t | Fonction puissance |
make | Mémoire | struct | Allouer une struct |
free | Mémoire | — | Libérer la mémoire tas |
Motifs courants
:start:
name = keyboard
print "bonjour" name
data = "hello world"
save "sortie.bin" data
loaded = load "sortie.bin"
l = len loaded
m = max 3 7
p = pow 2 8
Référence détaillée
Mots-clés E/S
keyboard
Lit une ligne depuis l'entrée standard et la retourne comme bs_t (bitstream) :
:start:
input = keyboard
print "vous avez tapé" input
La valeur retournée est un bitstream contenant les données de la chaîne d'entrée.
print
Affiche des valeurs sur la sortie standard. Les éléments sont séparés par des espaces et un saut de ligne est ajouté :
print "bonjour" 42 "monde"
// sortie : bonjour 42 monde
Print peut aussi afficher le contenu d'une struct en appelant sa méthode d'impression implicite :
counter:
value
functions:
prints:
print "counter" value
:start:
c = make counter 5
print c // appelle counter_prints(&c)
save
Écrit un bitstream dans un fichier :
data = "hello world"
save "sortie.bin" data
Le chemin de la chaîne est extrait du champ .data du bitstream.
load
Lit un bitstream depuis un fichier et le retourne :
data = load "entree.bin"
print "chargé" data
Retourne un bs_t. Le chemin est extrait du champ .data du bitstream.
Fonctions intégrées
len expr
Retourne la longueur d'un bitstream en bits :
bs s = "hello"
l = len s // l = 40 (5 octets * 8 bits)
abs x
Retourne la valeur absolue :
a = abs (0 - 42) // a = 42
min a b / max a b / pow base exp
m = min 3 7 // m = 3
m = max 3 7 // m = 7
p = pow 2 8 // p = 256
Conversion automatique de type
Quand des variables bs (bitstream) sont passées comme arguments à des méthodes ou fonctions attendant des types numériques, elles sont automatiquement converties en uint32_t :
:start:
move = keyboard // move est bs_t
b:set move player // move converti en uint32_t
Cette conversion est effectuée via raml_bs_to_uint32() dans le code C généré.
Exclus de la conversion (attendent des arguments bs_t directement) :
| Intégré | Raison |
|---|---|
load | Attend un chemin de chaîne via .data |
len | Opère sur la propriété .len du bitstream |
print | Affiche le contenu du bitstream directement |
Plongée Technique
Cette section couvre l'implémentation à l'exécution, les détails de conversion interne de type, et les cas limites.
Implémentation à l'exécution
Les intégrés sont mappés à des fonctions runtime C. Signatures principales :
typedef struct {
uint8_t* data; // pointeur vers les octets bruts
size_t len; // longueur en octets
} bs_t;
bs_t raml_keyboard(void);
void raml_print_bs(bs_t s);
void raml_print_int(uint64_t n);
void raml_save(bs_t path, bs_t data);
bs_t raml_load(bs_t path);
bs_t raml_make_bs(const char* s);
bs_t raml_bs_concat(bs_t a, bs_t b);
uint32_t raml_bs_to_uint32(bs_t bs);
size_t raml_bs_length(bs_t bs);
uint64_t raml_abs(int64_t x);
uint64_t raml_min(uint64_t a, uint64_t b);
uint64_t raml_max(uint64_t a, uint64_t b);
uint64_t raml_pow(uint64_t base, uint64_t exp);
void* raml_alloc(size_t size);
void raml_free(void* ptr);
Génération de code pour print
L'instruction print est traduite en une série d'appels d'impression typés. Chaque argument génère un appel approprié à son type :
print "boucle" i
Génère :
raml_print_bs(_string_0); // "boucle" comme bs_t
raml_print_int(i); // variable entière
Print via objets : En utilisant print obj sur une struct, le générateur de code appelle la méthode prints de la struct (doit exister). Signature : void obj_prints(struct obj_t* self).
À l'intérieur de la conversion automatique des bitstreams
Quand un bs_t est passé à une fonction attendant un type numérique, le générateur de code l'enveloppe avec raml_bs_to_uint32() :
// Raml : b:set move player
// C : board_set(&b, raml_bs_to_uint32(move), player);
La fonction convertit à partir d'une chaîne numérique :
uint32_t raml_bs_to_uint32(bs_t bs) {
if (!bs.data || bs.len == 0) return 0;
char* buf = malloc(bs.len + 1);
memcpy(buf, bs.data, bs.len);
buf[bs.len] = '\0';
uint32_t result = (uint32_t)atol(buf);
free(buf);
return result;
}
Localisation des mots-clés intégrés
Les mots-clés intégrés sont localisables via les fichiers keywords.raml.lang :
| Anglais | Arabe |
|---|---|
print | اطبع |
keyboard | لوحة_المفاتيح |
save | احفظ |
load | حمل |
len | طول |
make | اصنع |
free | احذف |
La localisation est une substitution au niveau du lexer — le parseur ne voit jamais les noms traduits.
Cas limites
keyboardà EOF : Retourne un bitstream vide (data=NULL, len=0). Les programmes devraient vérifierlenavant d'utiliser le résultat.saveavec données vides : Écrit un fichier de zéro octet.loaddepuis un fichier inexistant : Provoque une erreur à l'exécution (fopenretourne NULL).lensurbsnon initialisé : Retourne 0 (champ.leninitialisé à zéro).absdu plus petit int64 :abs(-9223372036854775808)boucle (pas de positif pour le plus petit int64 négatif) — cohérent avec le comportement C.- Conversion automatique sur chaînes non numériques :
raml_bs_to_uint32("bonjour")retourne 0 (atolretourne 0 sur une entrée non numérique).