Langue Grammaire

parser grammar SolidityParser

Solidity est un langage de haut niveau statiquement typé, orienté vers les contrats et destiné à la mise en œuvre de contrats intelligents sur la plateforme Ethereum.

rule source-unit

Au niveau le plus élevé, Solidity permet les pragmas, les directives d’importation et les définitions de contrats, d’interfaces, de bibliothèques, de structs, d’enums et de constantes.

pragmapragma-token;import-directivecontract-definitioninterface-definitionlibrary-definitionfunction-definitionconstant-variable-declarationstruct-definitionenum-definitionuser-defined-value-type-definitionerror-definitioneof

rule import-directive

Les directives d’importation importent les identifiants de différents fichiers.

importpathasidentifiersymbol-aliasesfrompath*asidentifierfrompath;

rule path

Chemin d’un fichier à importer.

non-empty-string-literal

rule symbol-aliases

Liste d’alias pour les symboles à importer.

{identifierasidentifier,}

rule contract-definition

Définition de haut niveau d’un contrat.

abstractcontractidentifierisinheritance-specifier,{contract-body-element}

rule interface-definition

Définition de haut niveau d’une interface.

interfaceidentifierisinheritance-specifier,{contract-body-element}

rule library-definition

Définition de haut niveau d’une bibliothèque.

libraryidentifier{contract-body-element}

rule inheritance-specifier

Spécification de l’héritage pour les contrats et les interfaces. Peut optionnellement fournir les arguments du constructeur de base.

identifier-pathcall-argument-list

rule contract-body-element

Déclarations pouvant être utilisées dans les contrats, les interfaces et les bibliothèques.

Les interfaces et les bibliothèques ne peuvent pas contenir de constructeurs, les interfaces ne peuvent pas contenir de variables d’état, et les bibliothèques ne peuvent pas contenir de fonctions de repli, de réception ou de variables d’état non constantes.

constructor-definitionfunction-definitionmodifier-definitionfallback-function-definitionreceive-function-definitionstruct-definitionenum-definitionuser-defined-value-type-definitionstate-variable-declarationevent-definitionerror-definitionusing-directive

rule call-argument-list

Arguments lors de l’appel d’une fonction ou d’un objet appelable similaire. Les arguments sont donnés soit sous forme de liste séparée par des virgules, soit sous forme de carte d’arguments nommés.

(expression,{identifier:expression,})

rule identifier-path

Nom qualifié.

identifier.

rule modifier-invocation

Appel à un modificateur. Si le modificateur ne prend pas d’arguments, la liste des arguments peut être entièrement ignorée. (y compris les parenthèses ouvrantes et fermantes).

identifier-pathcall-argument-list

rule visibility

Visibilité des fonctions et des types de fonctions.

internalexternalprivatepublic

rule parameter-list

Une liste de paramètres, tels que les arguments de la fonction ou les valeurs de retour.

type-namedata-locationidentifier,

rule constructor-definition

Définition d’un constructeur. Doit toujours fournir une implémentation. Notez que la spécification de la visibilité interne ou publique est dépréciée.

constructor(parameter-list)modifier-invocationpayableinternalpublicblock

rule state-mutability

Indiquer la mutabilité pour les types de fonctions. La mutabilité par défaut “non-payable” est supposée si aucune mutabilité n’est spécifiée.

pureviewpayable

rule override-specifier

Un spécificateur de surcharge utilisé pour les fonctions, les modificateurs ou les variables d’état. Dans les cas où il y a des déclarations ambiguës dans plusieurs contrats de base qui sont remplacés, une liste complète des contrats de base doit être donnée.

override(identifier-path,)

rule function-definition

La définition des fonctions de contrat, de bibliothèque et d’interface. Selon le contexte dans lequel la fonction est définie, d’autres restrictions peuvent s’appliquer. Par exemple, les fonctions des interfaces doivent être non implémentées, c’est-à-dire qu’elles ne peuvent pas contenir de bloc de corps.

functionidentifierfallbackreceive(parameter-list)visibilitystate-mutabilitymodifier-invocationvirtualoverride-specifierreturns(parameter-list);block

rule modifier-definition

La définition d’un modificateur. Notez que dans le corps d’un modificateur, l’underscore ne peut pas être utilisé comme identifiant, mais est utilisé comme déclaration de remplacement pour le corps d’une fonction à laquelle le modificateur est appliqué.

modifieridentifier(parameter-list)virtualoverride-specifier;block

rule fallback-function-definition

Définition de la fonction spéciale de repli.

fallback(parameter-list)externalstate-mutabilitymodifier-invocationvirtualoverride-specifierreturns(parameter-list);block

rule receive-function-definition

Définition de la fonction de réception spéciale.

receive()externalpayablemodifier-invocationvirtualoverride-specifier;block

rule struct-definition

Définition d’une structure. Peut se trouver au niveau supérieur dans une unité source ou dans un contrat, une bibliothèque ou une interface.

structidentifier{struct-member}

rule struct-member

La déclaration d’un membre de structure nommé.

type-nameidentifier;

rule enum-definition

Définition d’un enum. Peut se produire au niveau supérieur dans une unité source ou dans un contrat, une bibliothèque ou une interface.

enumidentifier{identifier,}

rule user-defined-value-type-definition

Définition d’un type de valeur défini par l’utilisateur. Peut se produire au niveau supérieur dans une unité source ou dans un contrat, une bibliothèque ou une interface.

typeidentifieriselementary-type-name;

rule state-variable-declaration

La déclaration d’une variable d’état.

type-namepublicprivateinternalconstantoverride-specifierimmutableidentifier=expression;

rule constant-variable-declaration

La déclaration d’une variable constante.

type-nameconstantidentifier=expression;

rule event-parameter

Paramètre d’un événement.

type-nameindexedidentifier

rule event-definition

Définition d’un événement. Peut se produire dans les contrats, les bibliothèques ou les interfaces.

eventidentifier(event-parameter,)anonymous;

rule error-parameter

Paramètre d’une erreur.

type-nameidentifier

rule error-definition

Définition d’une erreur.

erroridentifier(error-parameter,);

rule using-directive

Utilisation de directives pour lier des fonctions de bibliothèques à des types. Peut se produire dans les contrats et les bibliothèques.

usingidentifier-pathfor*type-name;

rule type-name

Un nom de type peut être un type élémentaire, un type de fonction, un type de mappage, un type défini par l’utilisateur (par exemple, un contrat ou un struct) ou un type de tableau.

elementary-type-namefunction-type-namemapping-typeidentifier-pathtype-name[expression]

rule elementary-type-name

addressaddresspayableboolstringbytessigned-integer-typeunsigned-integer-typefixed-bytesfixedufixed

rule function-type-name

function(parameter-list)visibilitystate-mutabilityreturns(parameter-list)

rule variable-declaration

La déclaration d’une seule variable.

type-namedata-locationidentifier

rule data-location

memorystoragecalldata

rule expression

Expression complexe. Peut être un accès à un index, un accès à une plage d’index, un accès à un membre, un appel de fonction (avec des options d’appel de fonction facultatives), une conversion de type, une expression unaire ou binaire, une comparaison ou une affectation, une expression ternaire, une nouvelle expression (c’est-à-dire la création d’un contrat ou l’allocation d’un tableau de mémoire dynamique), un tuple, un tableau en ligne ou une expression primaire (c’est-à-dire un identifiant, un littéral ou un nom de type).

expression[expression]expression[expression:expression]expression.identifieraddressexpression{identifier:expression,}expressioncall-argument-listpayablecall-argument-listtype(type-name)++--!~delete-expressionexpression++--expression**expressionexpression*/%expressionexpression+-expressionexpression<<>>>>>expressionexpression&expressionexpression^expressionexpression|expressionexpression<><=>=expressionexpression==!=expressionexpression&&expressionexpression||expressionexpression?expression:expressionexpression=|=^=&=<<=>>=>>>=+=-=*=/=%=expressionnewtype-nametuple-expressioninline-array-expressionidentifierliteralelementary-type-name

rule tuple-expression

(expression,)

rule inline-array-expression

Une expression de tableau en ligne désigne un tableau de taille statique du type commun des expressions contenues.

[expression,]

rule identifier

Outre les identificateurs ordinaires sans mot-clé, certains mots-clés comme « from » et « error » peuvent également être utilisés comme identificateurs.

identifierfromerrorrevert

rule literal

string-literalnumber-literalboolean-literalhex-string-literalunicode-string-literal

rule boolean-literal

truefalse

rule string-literal

Une chaîne de caractères complète est constituée d’une ou plusieurs chaînes de caractères consécutives entre guillemets.

non-empty-string-literalempty-string-literal

rule hex-string-literal

Un littéral de chaîne hexagonale complète qui consiste en une ou plusieurs chaînes hexagonales consécutives.

hex-string

rule unicode-string-literal

Un littéral de chaîne unicode complet qui consiste en une ou plusieurs chaînes unicode consécutives.

unicode-string-literal

rule number-literal

Les littéraux numériques peuvent être des nombres décimaux ou hexadécimaux avec une unité optionnelle.

decimal-numberhex-numbernumber-unit

rule block

Un bloc d’instructions avec des accolades. Ouvre sa propre portée.

{statementunchecked-block}

rule unchecked-block

uncheckedblock

rule statement

blockvariable-declaration-statementexpression-statementif-statementfor-statementwhile-statementdo-while-statementcontinue-statementbreak-statementtry-statementreturn-statementemit-statementrevert-statementassembly-statement

rule if-statement

Déclaration If avec partie else facultative.

if(expression)statementelsestatement

rule for-statement

Instruction For avec une partie facultative init, condition et post-boucle.

for(variable-declaration-statementexpression-statement;expression-statement;expression)statement

rule while-statement

while(expression)statement

rule do-while-statement

dostatementwhile(expression);

rule continue-statement

Une instruction continue. Uniquement autorisé dans les boucles for, while ou do-while.

continue;

rule break-statement

Une instruction break. Uniquement autorisé dans les boucles for, while ou do-while.

break;

rule try-statement

Une instruction try. L’expression contenue doit être un appel de fonction externe ou une création de contrat.

tryexpressionreturns(parameter-list)blockcatch-clause

rule catch-clause

La clause catch d’une déclaration try.

catchidentifier(parameter-list)block

rule return-statement

returnexpression;

rule emit-statement

Une instruction emit. L’expression contenue doit faire référence à un événement.

emitexpressioncall-argument-list;

rule revert-statement

Une déclaration de retour en arrière. L’expression contenue doit faire référence à une erreur.

revertexpressioncall-argument-list;

rule assembly-statement

Un bloc d’assemblage en ligne. Le contenu d’un bloc d’assemblage en ligne utilise un analyseur/lexeur séparé, c’est-à-dire que l’ensemble des mots-clés et d’identificateurs autorisés est différent à l’intérieur d’un bloc d’assemblage en ligne.

assembly'"evmasm"'{yul-statement}

rule variable-declaration-tuple

Un tuple de noms de variables à utiliser dans les déclarations de variables. Peut contenir des champs vides.

(,variable-declaration,variable-declaration)

rule variable-declaration-statement

Une déclaration de variable. Une seule variable peut être déclarée sans valeur initiale, alors qu’un tuple de variables ne peut être déclaré avec une valeur initiale.

variable-declaration=expressionvariable-declaration-tuple=expression;

rule expression-statement

expression;

rule mapping-type

mapping(mapping-key-type=>type-name)

rule mapping-key-type

Seuls les types élémentaires ou les types définis par l’utilisateur sont viables comme clés de mappage.

elementary-type-nameidentifier-path

rule yul-statement

Une instruction Yul dans un bloc d’assemblage en ligne. Les instructions continue et break ne sont valables que dans les boucles for. Les instructions leave ne sont valables que dans les corps de fonctions.

yul-blockyul-variable-declarationyul-assignmentyul-function-callyul-if-statementyul-for-statementyul-switch-statementleavebreakcontinueyul-function-definition

rule yul-block

{yul-statement}

rule yul-variable-declaration

La déclaration d’une ou plusieurs variables Yul avec une valeur initiale facultative. Si plusieurs variables sont déclarées, seul un appel de fonction constitue une valeur initiale valide.

letyul-identifier:=yul-expressionletyul-identifier,:=yul-function-call

rule yul-assignment

Toute expression peut être assignée à une seule variable Yul, alors que les affectations multiples nécessitent un appel de fonction sur le côté droit.

yul-path:=yul-expressionyul-path,yul-path:=yul-function-call

rule yul-if-statement

ifyul-expressionyul-block

rule yul-for-statement

foryul-blockyul-expressionyul-blockyul-block

rule yul-switch-statement

Une déclaration Yul switch peut consister uniquement en un cas par défaut (déprécié) ou en un ou plusieurs cas non-définis par défaut, éventuellement suivis d’un cas-défini par défaut.

switchyul-expressioncaseyul-literalyul-blockdefaultyul-blockdefaultyul-block

rule yul-function-definition

functionyul-identifier(yul-identifier,)->yul-identifier,yul-block

rule yul-path

Alors que seuls les identifiants sans points peuvent être déclarés dans un bloc d’assemblage en ligne, les chemins contenant des points peuvent faire référence à des déclarations en dehors du bloc d’assemblage en ligne.

yul-identifier.

rule yul-function-call

Un appel à une fonction avec des valeurs de retour ne peut se produire qu’à droite d’une affectation ou d’une déclaration de variable.

yul-identifieryul-evm-builtin(yul-expression,)

rule yul-boolean

truefalse

rule yul-literal

yul-decimal-numberyul-string-literalyul-hex-numberyul-booleanhex-string

rule yul-expression

yul-pathyul-function-callyul-literal

lexer grammar SolidityLexer
rule fixed-bytes

Types d’octets de longueur fixe.

'bytes1''bytes2''bytes3''bytes4''bytes5''bytes6''bytes7''bytes8''bytes9''bytes10''bytes11''bytes12''bytes13''bytes14''bytes15''bytes16''bytes17''bytes18''bytes19''bytes20''bytes21''bytes22''bytes23''bytes24''bytes25''bytes26''bytes27''bytes28''bytes29''bytes30''bytes31''bytes32'

rule number-unit

Dénomination unitaire pour les nombres.

'wei''gwei''ether''seconds''minutes''hours''days''weeks''years'

rule signed-integer-type

Types d’entiers signés dimensionnés. int est un alias de int256.

'int''int8''int16''int24''int32''int40''int48''int56''int64''int72''int80''int88''int96''int104''int112''int120''int128''int136''int144''int152''int160''int168''int176''int184''int192''int200''int208''int216''int224''int232''int240''int248''int256'

rule unsigned-integer-type

Types d’entiers non signés dimensionnés. uint est un alias de uint256.

'uint''uint8''uint16''uint24''uint32''uint40''uint48''uint56''uint64''uint72''uint80''uint88''uint96''uint104''uint112''uint120''uint128''uint136''uint144''uint152''uint160''uint168''uint176''uint184''uint192''uint200''uint208''uint216''uint224''uint232''uint240''uint248''uint256'

rule non-empty-string-literal

Une chaîne de caractères non vide, entre guillemets, limitée aux caractères imprimables.

'"'double-quoted-printableescape-sequence'"''\''single-quoted-printableescape-sequence'\''

rule empty-string-literal

Une chaîne littérale vide

'"''"''\'''\''

rule single-quoted-printable

Tout caractère imprimable, sauf le guillemet simple ou la barre oblique inversée.

[\u0020-\u0026\u0028-\u005B\u005D-\u007E]

rule double-quoted-printable

Tout caractère imprimable, sauf le guillemet double ou la barre oblique inversée.

[\u0020-\u0021\u0023-\u005B\u005D-\u007E]

rule escape-sequence

Séquence d’échappement. Outre les séquences d’échappement à un seul caractère, il est possible d’échapper aux sauts de ligne ainsi que les séquences d’échappement unicode à quatre chiffres hexagonaux (uXXXX) et les séquences d’échappement hexagonales à deux chiffres (xXX) sont autorisées.

'\\'['"\\nrt\n\r]'u'[0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f]'x'[0-9A-Fa-f][0-9A-Fa-f]

rule unicode-string-literal

Un littéral de chaîne de caractères entre guillemets permettant des caractères unicodes arbitraires.

'unicode"'~["\r\n\\]escape-sequence'"''unicode\''~['\r\n\\]escape-sequence'\''

rule hex-string

Les chaînes hexadécimales doivent être composées d’un nombre pair de chiffres hexadécimaux qui peuvent être groupés à l’aide de caractères de soulignement.

'hex''"'[0-9A-Fa-f][0-9A-Fa-f]'_''"''\''[0-9A-Fa-f][0-9A-Fa-f]'_''\''

rule hex-number

Les nombres hexadécimaux se composent d’un préfixe et d’un nombre arbitraire de chiffres hexadécimaux qui peuvent être délimités par des traits de soulignement.

'0''x'[0-9A-Fa-f]'_'

rule decimal-number

Un littéral de nombre décimal est constitué de chiffres décimaux qui peuvent être délimités par des traits de soulignement et un exposant positif ou négatif facultatif. Si les chiffres contiennent un point décimal, le littéral est de type à virgule fixe.

[0-9]'_'[0-9]'_''.'[0-9]'_'[eE]'-'[0-9]'_'

rule identifier

Un identifiant dans solidity doit commencer par une lettre, un symbole dollar ou un trait de soulignement et peut en outre contenir des chiffres après le premier symbole.

[a-zA-Z$_][a-zA-Z0-9$_]

rule yul-evm-builtin

Fonctions intégrées dans le dialecte EVM Yul.

'stop''add''sub''mul''div''sdiv''mod''smod''exp''not''lt''gt''slt''sgt''eq''iszero''and''or''xor''byte''shl''shr''sar''addmod''mulmod''signextend''keccak256''pop''mload''mstore''mstore8''sload''sstore''msize''gas''address''balance''selfbalance''caller''callvalue''calldataload''calldatasize''calldatacopy''extcodesize''extcodecopy''returndatasize''returndatacopy''extcodehash''create''create2''call''callcode''delegatecall''staticcall''return''revert''selfdestruct''invalid''log0''log1''log2''log3''log4''chainid''origin''gasprice''blockhash''coinbase''timestamp''number''difficulty''gaslimit''basefee'

rule yul-identifier

Les identifiants définis par l’utilisateur sont constitués de lettres, de signes de dollar, d’underscores et de chiffres, mais ne peuvent pas commencer par un chiffre. Dans l’assemblage en ligne, il ne peut y avoir de points dans les identificateurs définis par l’utilisateur. Voir plutôt yulPath pour les expressions consistant en des identificateurs avec des points.

[a-zA-Z$_][a-zA-Z0-9$_]

rule yul-hex-number

Les littéraux hexadécimaux dans Yul consistent en un préfixe et un ou plusieurs chiffres hexadécimaux.

'0''x'[0-9a-fA-F]

rule yul-decimal-number

Les littéraux décimaux dans Yul peuvent être zéro ou toute séquence de chiffres décimaux sans zéros de tête.

'0'[1-9][0-9]

rule yul-string-literal

Les chaînes de caractères dans Yul consistent en une ou plusieurs chaînes de caractères entre guillemets ou entre guillemets simples qui peuvent contenir des séquences d’échappement et des caractères imprimables, à l’exception des sauts de ligne non encodés ou des des guillemets doubles ou simples non masqués, respectivement.

'"'double-quoted-printableescape-sequence'"''\''single-quoted-printableescape-sequence'\''

rule pragma-token

Jeton de pragmatisme. Peut contenir n’importe quel type de symbole sauf un point-virgule. Notez qu’actuellement l’analyseur de Solidity ne permet qu’un sous-ensemble de ceci.