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érateurs | Nom | Associativité |
|---|---|---|---|
| 1 (haut) | ++ -- (postfixe) | Post-incrément, post-décrément | Gauche |
| 2 | * / % | Multiplication, division, modulo | Gauche |
| 3 | + - | Addition, soustraction | Gauche |
| 4 | << >> | Décalage gauche, droite | Gauche |
| 5 | < > <= >= == != =#= | Comparaisons | Gauche |
| 6 | & | ET bitwise | Gauche |
| 7 | ^ | XOR bitwise | Gauche |
| 8 | | | OU bitwise | Gauche |
| 9 | && | ET logique | Gauche |
| 10 | || | OU logique | Gauche |
| 11 | ++ -- ~ @ (préfixe) | Pré-incrément, pré-décrément, NOT, address-of | Droite |
| 12 (bas) | :: :: | Groupement double-colon | N/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érateur | Description |
|---|---|
== | É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érateur | Description |
|---|---|
+= -= *= /= %= | 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 Raml | Code C généré |
|---|---|
a + b | a + b |
a - b | a - b |
a * b | a * b |
a / b | a / b |
a % b | a % b |
a << b | a << b |
a >> b | a >> b |
a & b | a & b |
a | b | a | b |
a ^ b | a ^ b |
~a | ~a |
a++ | a++ |
++a | ++a |
a == b | a == b |
a != b | a != b |
a < b | a < b |
a <= b | a <= b |
a > b | a > b |
a >= b | a >= b |
@x | &x |
*p | *p |
p =#= q | p == q |
p #= @x | p = &x |
p += n | p += n |
p +#= n | (void*)((char*)p + n) |
::expr:: | (expr) (parenthèses C) |
a && b | a && b |
a || b | a || 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 += 1donnex = 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.