Aller au contenu principal

Types et valeurs

Le système de types de Raml est construit autour d'un type scalaire unique (bs) et de types composites (structs).


Aperçu​

Cette section couvre les bases — types disponibles, formes de déclaration, et syntaxe des littéraux.

Type bitstream (bs)​

bs (bitstream) est le seul type scalaire de Raml. Il contient des données de longueur variable — chaînes, motifs binaires, ou entiers. En l'absence de type spécifié, le type par défaut est bs :

msg = "hello" // bs contenant des données de chaîne
bs data = "binary" // type explicite
x = "text" // x est bs
y = 42 // y est aussi bs (inféré)

Les variables bs sont automatiquement converties en uint32_t lorsqu'elles sont passées comme arguments numériques à des méthodes ou fonctions.

Types pointeurs​

Les types pointeurs sont formés en ajoutant le suffixe # à un type nommé :

node# np // pointeur vers un objet node

Formes de déclaration​

FormeExempleNotes
Inféréx y z = 10Variables multiples, type inféré
Explicitebs data = "hello"Type bitstream explicite
Inférévalue = 42Type inféré de l'expression (défaut bs)

Littéraux​

42 // décimal
0xFF // hexadécimal (255)
0b1010 // binaire (10)
"hello" // double guillemets
'world' // simple guillemets
"""multi
line""" // triple double guillemets

Le symbole = sert aussi de littéral vrai :

if x =:
print "x est vrai"

Plongée Technique​

Cette section couvre les détails d'implémentation — mapping des types C, règles d'inférence, alignement mémoire, et cas limites.

Mapping des types C​

Type RamlType C généré
bsbs_t (struct { uint8_t* data; size_t len; })
type#struct type_t*

Les types nommés (structs) sont mappés à des struct C :

counter:
value

Devient :

typedef struct { uint64_t value; } counter_t;

Les champs sont accessibles avec l'opérateur . (accès direct) ou -> (accès par pointeur).

Règles d'inférence de type​

ContexteType inféré
Littéral entier dans une affectationbs
Littéral chaînebs
Appel keyboardbs
Appel loadbs
Expression arithmétiquebs
Expression de comparaisonbs
Référence de variableMême que le type déclaré
Retour de méthode/fonctionType de la dernière expression

Note d'implémentation : toutes les variables non typées sont bs, avec conversion automatique en uint32_t lorsqu'elles sont passées comme arguments numériques.

Alignement et disposition en mémoire​

Les champs de struct sont disposés séquentiellement avec l'alignement de l'ABI C. Le générateur de code calcule les décalages de champs en fonction de leurs tailles de type C :

struct counter_t {
uint32_t value; // décalage 0, taille 4
uint8_t flag; // décalage 4, taille 1
// padding de 3 octets
uint64_t big; // décalage 8, taille 8
};

Détails d'implémentation du = littéral​

Le jeton ASSIGN (=) sert à la fois d'opérateur d'affectation et de littéral vrai. Dans le code généré :

// Raml : if x =:
// C : if (x) {

Le parseur distingue ces utilisations par contexte : le littéral = apparaît uniquement comme opérande dans une expression (par ex. après if, ou à droite d'une comparaison).

Cas limites​

  • Surcharge d'inférence : Toutes les variables non typées sont bs, ce qui peut mener à une manipulation involontaire de bitstream. Préférez toujours les déclarations typées explicites pour les structs.
  • Valeur limite de len : Pour un bitstream vide (data=NULL, len=0), len retourne 0.