Aller au contenu principal

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égorieType retourDescription
keyboardE/Sbs_tLire une ligne depuis stdin
printE/S—Afficher des valeurs sur stdout
saveE/S—Écrire un bitstream dans un fichier
loadE/Sbs_tLire un bitstream depuis un fichier
lenChaîneuint32_tLongueur du bitstream en bits
absMathuint32_tValeur absolue
minMathuint32_tMinimum de deux valeurs
maxMathuint32_tMaximum de deux valeurs
powMathuint32_tFonction puissance
makeMémoirestructAllouer une struct
freeMé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
loadAttend un chemin de chaîne via .data
lenOpère sur la propriété .len du bitstream
printAffiche 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 :

AnglaisArabe
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érifier len avant d'utiliser le résultat.
  • save avec données vides : Écrit un fichier de zéro octet.
  • load depuis un fichier inexistant : Provoque une erreur à l'exécution (fopen retourne NULL).
  • len sur bs non initialisé : Retourne 0 (champ .len initialisé à zéro).
  • abs du 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 (atol retourne 0 sur une entrée non numérique).