Énoncé (informatique)

En programmation informatique , une instruction est une unité syntaxique d’un langage de programmation impératif qui exprime une action à effectuer. ^[1] Un programme écrit dans un tel langage est formé par une séquence d’une ou plusieurs instructions. Une instruction peut avoir des composants internes (par exemple, des expressions ).

De nombreux langages de programmation (par exemple Ada , Algol 60 , C , Java , Pascal ) font une distinction entre les déclarations et les définitions/déclarations . Une définition ou une déclaration spécifie les données sur lesquelles un programme doit fonctionner, tandis qu’une instruction spécifie les actions à entreprendre avec ces données.

Les instructions qui ne peuvent pas contenir d’autres instructions sont simples ; celles qui peuvent contenir d’autres instructions sont composées . ^[2]

L’apparence d’une instruction (et en fait d’un programme) est déterminée par sa syntaxe ou sa grammaire. La signification d’une déclaration est déterminée par sa sémantique .

Déclarations simples

Les déclarations simples sont complètes en elles-mêmes ; ceux-ci incluent les affectations, les appels de sous-programmes et quelques instructions qui peuvent affecter de manière significative le flux de contrôle du programme (par exemple goto , return , stop/halt). Dans certains langages, les entrées et les sorties, les assertions et les sorties sont gérées par des instructions spéciales, tandis que d’autres langages utilisent des appels à des sous-programmes prédéfinis.

• mission
  • Fortran :variable = expression
  • Pascal, Algol 60, Ada :variable := expression;
  • C, C#, C++, PHP, Java :variable = expression;
• appel
  • Fortran :CALL subroutine name(parameters)
  • C, C++, Java, PHP, Pascal, Ad :subroutine name(parameters);
• affirmation
  • C, C++, PHP :assert(relational expression);
  • Java:assert relational expression;
• ALLER À
  • Fortran :GOTO numbered-label
  • Algol 60 :goto label;
  • C, C++, PHP, Pascal :goto label;
• retourner
  • Fortran :RETURN value
  • C, C++, Java, PHP :return value;
• arrêter/arrêter/sortir
  • Fortran :STOP number
  • C, C++ :exit(expression)
  • PHP :exit number;

Déclarations composées

Les instructions composées peuvent contenir des (séquences d’) instructions, emboîtables à n’importe quelle profondeur raisonnable, et impliquent généralement des tests pour décider s’il faut ou non obéir ou répéter ces instructions contenues.

Notation pour les exemples suivants :

• <instruction> est une instruction unique (peut être simple ou composée).
• <séquence> est une séquence de zéro ou plusieurs <instructions>

Certains langages de programmation fournissent un moyen général de regrouper des instructions, de sorte que toute <instruction> unique puisse être remplacée par un groupe :

• Algol 60 :begin <sequence> end
• Pascal:begin <sequence> end
• C, PHP, Java :{ <sequence> }

D’autres langages de programmation ont un terminateur spécial différent sur chaque type d’instruction composée, de sorte qu’une ou plusieurs instructions sont automatiquement traitées comme un groupe :

• Ad :if test then <sequence> end if;

De nombreuses instructions composées sont des commandes de boucle ou des commandes de choix. En théorie, une seule de chacun de ces types de commandes est requise. En pratique, il existe divers cas particuliers qui se produisent assez souvent; ceux-ci peuvent rendre un programme plus facile à comprendre, faciliter la programmation et peuvent souvent être mis en œuvre beaucoup plus efficacement. Il existe de nombreuses subtilités non mentionnées ici; voir les articles liés pour plus de détails.

• boucle contrôlée par comptage :
  • Algol 60 :for index := 1 step 1 until limit do <statement> ;
  • Pascal:for index := 1 to limit do <statement> ;
  • C, Java : for ( index = 1; index <= limit; index += 1) <statement> ;
  • Ad :for index in 1..limit loop <sequence> end loop
  • Fortran 90 :

DO index = 1, limite <séquence> FIN FAIRE

• boucle conditionnée avec test en début de boucle :
  • Algol 60 :for index := expression while test do <statement> ;
  • Pascal:while test do <statement> ;
  • C, Java :while (test) <statement> ;
  • Ad :while test loop <sequence> end loop
  • Fortran 90 :

FAIRE PENDANT (test) <séquence> FIN FAIRE

• boucle conditionnelle avec test en fin de boucle :
  • Pascal:repeat <sequence> until test; { note reversed test}
  • C, Java :do { <sequence> } while (test) ;
  • Ad :loop <sequence> exit when test; end loop;
• boucle conditionnelle avec test au milieu de la boucle :
  • C :do { <sequence> if (test) break; <sequence> } while (true) ;
  • Ad :loop <sequence> exit when test; <sequence> end loop;
• situation simple avec une instruction if :
  • Algol 60 :if test then <unconditional statement> ;
  • Pascal:if test then <statement> ;
  • C, Java :if (test) <statement> ;
  • Ad :if test then <sequence> end if;
  • Fortran 77+ :

SI (tester) ALORS <séquence> FIN SI

• choix bidirectionnel de l’instruction if :
  • Algol 60 :if test then <unconditional statement> else <statement> ;
  • Pascal:if test then <statement> else <statement> ;
  • C, Java :it (test) <statement> else <statement> ;
  • Ad :if test then <sequence> else <sequence> end if;
  • Fortran 77+ :

SI (tester) ALORS <séquence> AUTRE <séquence> FIN SI

• instruction case/switch choix multiple :
  • Pascal:case c of ‘a’: alert(); ‘q’: quit(); end;
  • Ad :case c is when ‘a’ => alert(); when ‘q’ => quit(); end case;
  • C, Java :switch (c) { case ‘a’: alert(); break; case ‘q’: quit(); break; }
• Gestion des exceptions :
  • Ad : begin protected code except when exception specification => exception handler
  • Java:try { protected code } catch (exception specification) { exception handler } finally { cleanup }
  • Python: try: protected code except exception specification: exception handler else: no exceptions finally: cleanup

Syntaxe

Outre les affectations et les appels de sous-programmes, la plupart des langages commencent chaque instruction par un mot spécial (par exemple goto, if, while, etc.) comme indiqué dans les exemples ci-dessus. Diverses méthodes ont été utilisées pour décrire la forme des déclarations dans différentes langues; les méthodes plus formelles tendent à être plus précises :

• Algol 60 a utilisé la forme Backus – Naur (BNF) qui a établi un nouveau niveau pour la spécification de la grammaire du langage. ^[3]
• Jusqu’à Fortran 77, la langue a été décrite en prose anglaise avec des exemples, ^[4] À partir de Fortran 90, la langue a été décrite en utilisant une variante de BNF. ^[5]
• Cobol a utilisé un métalangage à deux dimensions. ^[6]
• Pascal a utilisé à la fois des diagrammes de syntaxe et des BNF équivalents. ^[7]

BNF utilise la récursivité pour exprimer la répétition, de sorte que diverses extensions ont été proposées pour permettre une indication directe de la répétition.

Énoncés et mots-clés

Certaines grammaires de langage de programmation réservent des mots-clés ou les marquent spécialement , et ne permettent pas de les utiliser comme identificateurs . Cela conduit souvent à des grammaires plus faciles à analyser , nécessitant moins d’anticipation .

Aucun mot-clé distinctif

Fortran et PL/1 n’ont pas de mots-clés réservés, permettant des déclarations comme :

• en PL/1 :
  • IF IF = THEN THEN …(la seconde IFet la première THENsont des variables).
• en Fortran :
  • IF (A) X = 10… instruction conditionnelle (avec d’autres variantes)
  • IF (A) = 2 affectation à une variable indicée nomméeIF

Comme les espaces étaient facultatifs jusqu’à Fortran 95, une faute de frappe pouvait complètement changer le sens d’une instruction :

• DO 10 I = 1,5 début d’une boucle avec I allant de 1 à 5
• DO 10 I = 1.5 affectation de la valeur 1,5 à la variableDO10I

Mots signalés

Dans Algol 60 et Algol 68, les jetons spéciaux ont été distingués explicitement : pour publication, en gras par exemple begin; pour la programmation, avec un marquage spécial, par exemple, un drapeau ( ‘begin), des guillemets ( ‘begin’) ou souligné ( beginsur l’ Elliott 503 ). C’est ce qu’on appelle “stropping”.

Les jetons qui font partie de la syntaxe du langage n’entrent donc pas en conflit avec les noms définis par le programmeur.

Mots clés réservés

Certains noms sont réservés dans le cadre du langage de programmation et ne peuvent pas être utilisés comme noms définis par le programmeur. La majorité des langages de programmation les plus populaires utilisent des mots-clés réservés. Les premiers exemples incluent FLOW-MATIC (1953) et COBOL (1959). Depuis 1970, d’autres exemples incluent Ada, C, C++, Java et Pascal. Le nombre de mots réservés dépend du langage : C en a environ 30 alors que COBOL en a environ 400.

Sémantique

La sémantique s’intéresse à la signification d’un programme. Les documents standards pour de nombreux langages de programmation utilisent BNF ou un équivalent pour exprimer la syntaxe/grammaire d’une manière assez formelle et précise, mais la sémantique/signification du programme est généralement décrite à l’aide d’exemples et de prose anglaise. Cela peut entraîner une ambiguïté. ^[8] Dans certaines descriptions de langage, la signification des instructions composées est définie par l’utilisation de constructions « plus simples », par exemple, une boucle while peut être définie par une combinaison de tests, de sauts et d’étiquettes, en utilisant ifet goto.

L’ article sur la sémantique décrit plusieurs formalismes mathématiques/logiques qui ont été utilisés pour spécifier la sémantique de manière précise ; ceux-ci sont généralement plus compliqués que BNF, et aucune approche unique n’est généralement acceptée comme la voie à suivre. Certaines approches définissent efficacement un interpréteur pour le langage, certaines utilisent une logique formelle pour raisonner sur un programme, certaines attachent des affixes aux entités syntaxiques pour assurer la cohérence, etc.

Expressions

Une distinction est souvent faite entre les instructions, qui sont exécutées, et les expressions , qui sont évaluées. La valeur obtenue à partir d’une expression est souvent utilisée dans le cadre d’une instruction, par exemple une affectation variable := expression;

Certains langages de programmation (par exemple C, C++) autorisent certaines instructions à fournir un résultat (techniquement, toutes les instructions fournissent un résultat, mais ce résultat est souvent de type ‘void’ et ne peut être utilisé pour rien). La déclaration la plus utile qui fournit un résultat est une affectation, le résultat étant la valeur qui vient d’être affectée.

Cela peut être utile pour plusieurs initialisations :

i = j = 0;qui est traité comme i = (j = 0);

Cela peut également entraîner un simple problème de doigt qui change complètement la signification de certains codes :

if (i == j) {. . . };teste pour voir si iest égal à j if (i = j) { . . . };attribue la valeur de jà ipuis teste pour voir si cette valeur est différente de zéro.

Certains langages autorisent l’affectation multiple (Algol 60) mais n’autorisent pas l’apparition d’affectations dans les expressions (Algol 60, Pascal).

Extensibilité

La plupart des langages ont un ensemble fixe d’instructions définies par le langage, mais il y a eu des expériences avec des langages extensibles qui permettent au programmeur de définir de nouvelles instructions.

Voir également

• Comparaison des langages de programmation – Déclarations
• Flux de contrôle
• Expression (contraste)

Références

1. ^ “déclaration” . webopédia . Récupéré le 03/03/2015 .
2. ^ Section de rapport Algol 60 révisée. 4.1. “Algol 60” . Consulté le 23 janvier 2021 .
3. ^ Section 1.1 du rapport Algol 60 révisé. “Algol 60” . Consulté le 23 janvier 2021 .
4. ^ Norme ANSI FORTRAN 66 “FORTRAN 66” (PDF) . Consulté le 19 février 2021 .
5. ^ Norme ANSI FORTRAN 95 “Fortran95” (PDF) . Consulté le 19 février 2021 .
6. ^ Manuel Cobol. « COBOL » (PDF) . Consulté le 23 janvier 2021 .
7. ^ Manuel de l’utilisateur Pascal et annexe de rapport D. “Pascal” (PDF) . Consulté le 19 février 2021 .
8. ^ Points problématiques dans Algol 60 “Trouble Spots” (PDF) . Consulté le 24 février 2021 .

Liens externes

• ENCYCLOPÉDIE PC : Définition de : énoncé de programme