Aller au contenu principal

Opérateurs

Les opérateurs de Raml sont organisés par précédence, du plus haut au plus bas.


Aperçu​

Table de précédence​

Préc.OpérateursNomAssociativité
1 (haut)++ -- (postfixe)Post-incrément, post-décrémentGauche
2* / %Multiplication, division, moduloGauche
3+ -Addition, soustractionGauche
4<< >>Décalage gauche, droiteGauche
5< > <= >= == != =#=ComparaisonsGauche
6&ET bitwiseGauche
7^XOR bitwiseGauche
8|OU bitwiseGauche
9&&ET logiqueGauche
10||OU logiqueGauche
11++ -- ~ @ (préfixe)Pré-incrément, pré-décrément, NOT, address-ofDroite
12 (bas):: ::Groupement double-colonN/A

Opérateurs postfixes​

expr++ — Post-incrément : retourne la valeur actuelle, puis incrémente.

x = 5
y = x++ // y = 5, x = 6

expr-- — Post-décrément : retourne la valeur actuelle, puis décrémente.

x = 5
y = x-- // y = 5, x = 4

Opérateurs arithmétiques​

result = a * b // multiplication
quotient = a / b // division
remainder = a % b // modulo
sum = 3 + 4 // addition
diff = 10 - 3 // soustraction

Pour les types bs, + concatène les bitstreams :

bs msg = "hi" + "!" // "hi!"

Opérateurs de décalage​

shifted = 1 << 3 // 8
shifted = 8 >> 2 // 2

Opérateurs de comparaison​

Toutes les comparaisons retournent une valeur booléenne (0 ou 1).

OpérateurDescription
==Égal
!=Différent
<Inférieur
>Supérieur
<=Inférieur ou égal
>=Supérieur ou égal
=#=Égalité d'adresses

Opérateurs bitwise​

masked = value & 0xFF // ET
xored = value ^ 0x55 // XOR
combined = a | b // OU
inverted = ~value // NON (préfixe)

Opérateurs logiques​

Évaluation court-circuit. Retournent 0 ou 1.

if ::x > 0:: && ::x < 10:::
print "dans la plage"

Opérateurs préfixes​

++expr — Pré-incrément : incrémente, puis retourne. --expr — Pré-décrément : décrémente, puis retourne. @expr — Address-of : retourne l'adresse mémoire. ::expr:: — Groupement double-colon : empêche l'absorption des comparaisons.

y = ++x // y = 6, x = 6
bs# p = @x
in_range = ::a > 0:: && ::b < 10::

Affectations composées​

OpérateurDescription
+= -= *= /= %=Arithmétique + affectation
&= |= ^= <<= >>=Bitwise + affectation
+#=Incrément de bits bruts
#=Affectation d'adresse

Plongée Technique​

Cette section couvre le fondement du design des opérateurs, le mapping de génération de code, et la sémantique des débordements.

Fondement du design des opérateurs​

Pourquoi ::expr:: au lieu de parenthèses ?

Dans des langages de type C, les parenthèses groupent les sous-expressions. Mais dans la syntaxe séparée par des espaces de Raml, les parenthèses créent une ambiguïté :

b:get (move) != 0

Est-ce un appel de méthode board_get(&b, move) suivi d'une comparaison, ou board_get(&b, (move != 0)) ?

Le groupement double-colon ::expr:: élimine cette ambiguïté car :: n'apparaît dans aucune autre production syntaxique. Il sert d' « échappatoire » explicite pour les comparaisons dans des contextes d'expressions restreintes (arguments de méthodes/fonctions).

Mapping de génération de code C​

Expression RamlCode C généré
a + ba + b
a - ba - b
a * ba * b
a / ba / b
a % ba % b
a << ba << b
a >> ba >> b
a & ba & b
a | ba | b
a ^ ba ^ b
~a~a
a++a++
++a++a
a == ba == b
a != ba != b
a < ba < b
a <= ba <= b
a > ba > b
a >= ba >= b
@x&x
*p*p
p =#= qp == q
p #= @xp = &x
p += np += n
p +#= n(void*)((char*)p + n)
::expr::(expr) (parenthèses C)
a && ba && b
a || ba || b

Sémantique des débordements​

Les opérations arithmétiques suivent la sémantique C sous-jacente :

  • Débordement d'entiers non signés : rotation (modulo 2^N). Par exemple, x = 255; x += 1 donne x = 0.
  • Débordement d'entiers signés : comportement indéfini.

La fonction intégrée pow utilise uint64_t et peut déborder silencieusement.

Restrictions des arguments de méthodes​

Les arguments d'appels de méthodes utilisent simpleExprItem, qui exclut les opérateurs de comparaison et logiques. Voyez Aperçu de la Grammaire pour la justification complète.