Les premiers pas

Le BCPL est le coeur du système de compilation BCPL. C'est un langage ressemblant beaucoup au vrai CPL mais étant en fait un langage de programmation très simple étant facile à compiler en code efficace. Les principales différences entre BCPL et CPL sont les suivantes :

• Une syntaxe simplifiée.
• Tous les éléments de données ont des Rvalues étant des modèles de bits de la même longueur et le type d'une Rvalue dépend uniquement du contexte de son utilisation et non de la déclaration de l'élément de données. Cela simplifie le compilateur et améliore l'efficacité du code objet, mais par conséquent, il n'y a pas de vérification de type.
• BCPL dispose d'une fonction de constante nommée manifeste.
• Les fonctions et les routines ne peuvent avoir que des variables libres étant des constantes nommées manifestes ou dont les Lvalues sont des constantes manifestes (c'est-à-dire des fonctions ou des routines explicites, des étiquettes ou des variables globales).
• L'utilisateur peut manipuler explicitement les L et les Rvalues.
• Il existe un schéma pour la compilation séparée des segments d'un programme.

Syntaxe BCPL

La notation syntaxique utilisée dans ce manuel est essentiellement BNF avec les extensions suivantes :

• Les symboles E, D et C sont utilisés comme abréviations pour <expression> <définition> et <commande>.
• Les crochets métalinguistiques '<' et '>' peuvent être imbriqués et ainsi utilisés pour regrouper plusieurs séquences constitutives (pouvant contenir des alternatives). Un indice entier peut être attaché au crochet métalinguistique '>' et utilisé pour spécifier la répétition ; s'il s'agit de l'entier n, alors la séquence entre crochets doit être répétée au moins n fois ; si l'entier est suivi d'un signe moins, alors la séquence peut être répétée au plus n fois ou elle peut être absente.

Syntaxe matérielle

La syntaxe matérielle est la syntaxe d'une implémentation réelle du langage et dépend donc nécessairement de l'implémentation puisqu'elle dépend de l'ensemble de caractères disponible. Pour simplifier la description de toute implémentation de BCPL, une syntaxe canonique a été définie. La représentation canonique d'un programme BCPL consiste en une séquence de symboles de l'ensemble suivant :

Symboles canoniques de la BCPL

• NUMBER NAME STRINGCONST TRUE FALSE
• VALOF LV RV DIV REM PLUS MINUS
• EQ NE LS GR LE GE NOT LSHIFT RSHIFT
• LOGAND LOGOR EQV NEQV COND COMMA
• AND ASS GOTO RESULTIS COLON TEST
• FOR IF UNLESS WHILE UNTIL REPEAT REPEATWHILE
• REPEATUNTIL BREAK RETURN FINISH SWITCHON CASE
• DEFAULT LET MANIFEST GLOBAL
• BE SECTBRA SECTKET RBRA RKET SBRA SKET
• SEMICOLON INTO TO DO OR VEC STAR

Les symboles NUMBER, NAME, STRINGCONST, SECTBRA et SECTKET désignent des éléments composites ayant chacun une séquence de caractères associée.

Conventions matérielles et règles du préprocesseur

• Si l'ensemble de caractères d'implémentation contient à la fois des majuscules et des minuscules, les conventions suivantes s'appliquent :
• Un nom est soit une seule petite lettre, soit une séquence de lettres et de chiffres commençant par une majuscule. Le caractère qui suit immédiatement un nom ne peut être ni une lettre ni un chiffre.
• Une séquence de deux ou plusieurs petites lettres ne faisant pas partie d'un NAME, SECTBRA, SECTKET ou STRINGCONST est un mot système réservé et peut être utilisé pour représenter un symbole canonique. Par exemple : let et logor pourraient être utilisés pour représenter LET et LOGOR, mais Let et Logor sont des noms.
• Le commentaire de l'utilisateur peut être inclus dans un programme entre une double barre oblique «//» et la fin de la ligne. Exemple :
1. let R[] be // Cette routine remplit le vecteur symbole
2. § for i = 1 to 200 do Readch [INPUT, lv Symb*[i]] §


• Les crochets de section peuvent être marqués avec une séquence de lettres et de chiffres et deux crochets de section sont considérés comme correspondants si leurs balises sont identiques. Plusieurs sections peuvent être fermées par un seul crochet de section fermant car, en rencontrant un crochet de section fermant, si le crochet de section ouvrant actuel ne correspond pas, la section actuelle est automatiquement fermée par l'insertion d'un crochet de fermeture supplémentaire. Le processus est répété jusqu'à ce que le crochet de section ouvert correspondant soit trouvé.
• Le symbole canonique SEMICOLON est inséré entre les paires d'éléments s'ils apparaissent sur des lignes différentes et si le premier fait partie de l'ensemble des éléments pouvant terminer une commande ou une définition, à savoir :
• BREAK RETURN FINISH REPEAT SKET RKET
• SECTKET NAME STRINGCONST NUMBER TRUE FALSE

et le deuxième fait partie de l'ensemble des éléments pouvant démarrer : une commande, à savoir :

• TEST FOR IF UNLESS UNTIL WHILE GOTO RESULTIS
• CASE DEFAULT BREAK RETURN FINISH SECTBRA
• RBRA VALOF LV RV NAME
• Le symbole canonique DO est inséré entre deux éléments s'ils apparaissent sur la même ligne et si le premier fait partie de l'ensemble des éléments pouvant terminer une expression, à savoir :
• SKET RKET SECTKET NAME NUMBER
• STRINGCONST TRUE FALSE

et le deuxième fait partie de l'ensemble des éléments devant démarrer une commande, à savoir :

• TEST FOR IF UNLESS UNTIL WHILE GOTO RESULTIS
• CASE DEFAULT BREAK RETURN FINISH
• Une directive de la forme :

get <specifier>

peut être utilisé n'importe où dans un programme BCPL ; il ordonne au compilateur de remplacer la directive par le fichier ou le flux de texte d'entrée référencé par le spécificateur. La forme syntaxique exacte du spécificateur dépend de l'implémentation, mais il s'agira généralement d'une constante de chaîne de caractères ou d'un entier.

Exemple&bbsp;: ce qui suit est un segment de programme complet pour une compilation séparée ; il est écrit dans une représentation matérielle fictive et présente certaines des règles du préprocesseur. Notez qu'il n'était pas nécessaire d'écrire un seul point-virgule puisqu'ils seront tous insérés automatiquement :

1. get 'HEAD2' // Cela «récupère» le fichier appelé HEAD2 déclarant vraisemblablement Checkdistinct, Report et Dvec
2.  
3. let Checkdistinct[E, S] be
4.          $(1 until E=S do // Le symbole $( représente une SECTBRA
5.  
6.                  $( let p = E + 4
7.                    and N = Dvec*[E]
8.                    while p ls S do // Notez que ls est un mot système, p est un nom.
9.                         $( if Dvec*[p]=N do Report [142, N]
10.                             p := p + e $)
11.                    E := E + e $)1 // Notez que ceci ferme deux sections.

Syntaxe canonique

La syntaxe donnée dans cette section définit toutes les constructions légales en BCPL sans spécifier ni les pouvoirs de liaison relatifs ni les règles d'association des opérateurs de commande et d'expression. Celles-ci sont données plus loin dans la page dans les descriptions de chaque construction.

Pour améliorer la lisibilité de la syntaxe, une représentation matérielle des symboles canoniques a été utilisée. Par exemple :

Éléments de données

Rvalues, Lvalues et éléments de données

Une RVALUE est un modèle binaire de bits d'une longueur fixe (dépendant de l'implémentation), elle est généralement de la taille d'un mot informatique. Les Rvalues ??peuvent être utilisées pour représenter une variété de types d'objets différents tels que des entiers, des valeurs de vérité, des vecteurs ou des fonctions. Le type d'objet réel représenté est appelé le TYPE de la Rvalue.

Une expression BCPL peut être évaluée pour produire une valeur R, mais son type reste indéfini jusqu'à ce que la valeur R soit utilisée dans un contexte définitif et elle est alors supposée représenter un objet du type requis. Par exemple, dans l'application de fonction suivante :

l'expression (B*[i] → f, g) est évaluée pour produire une valeur R étant ensuite interprétée comme la valeur R d'une fonction puisque l'expression est apparue dans la position d'opérateur d'une application de fonction ; si f et g sont en fait des fonctions n'est pas explicitement vérifié. De même, l'expression B*[i] (étant une application vectorielle) apparaît là où un booléen est attendu et donc sa valeur R est interprétée comme une valeur de vérité.

Il n'y a pas de vérification explicite pour s'assurer qu'il n'y a pas d'incompatibilité de type.

Une LVALUE est un modèle de bits représentant un emplacement d'entreposage contenant une valeur R. Une Lvalue a la même taille qu'une Rvalue et est un type dans BCPL. Il existe un contexte dans lequel une valeur R est interprétée comme une valeur R et c'est comme l'opérande de l'opérateur monadique rv. Par exemple, dans l'expression :

l'expression f[i] est évaluée pour donner un Rvalue étant ensuite interprétée comme un Lvalue puisqu'elle est l'opérande de rv. L'application de rv sur cette Lvalue donne la Rvalue étant contenue dans l'emplacement représenté (ou référencé) par le Lvalue. Une Lvalue peut être obtenue en appliquant l'opérateur lv à un identifiant, une application vectorielle ou une expression rv.

Un élément de données est composé d'une Lvalue, de la Rvalue référencée et éventuellement d'un identifiant associé. Le terme est utilisé de manière vague pour désigner la Lvalue, la Rvalue ou l'identifiant selon le contexte.

En BCPL, un élément de données peut avoir au plus un identificateur.

La ligne brisée indique l'association sémantique entre un identificateur x et l'emplacement d'entreposage étant représenté par la case ; la flèche continue montre la correspondance entre la Lvalue 001101 et la Rvalue 000101, et la flèche brisée montre la correspondance entre l'identifiant x et la Lvalue 001101.

Il est significatif de dire que la Lvalue de l'élément de données x est le modèle binaire 001101, que la Rvalue de l'élément de données x est le modèle binaire 000101 et que la Lvalue 001101 fait référence à l'élément de données x.

Types

Une Rvalue peut représenter un objet de l'un des types suivants :

• entier, logique, booléen, fonction, routine, étiquette, chaîne de caractères, vecteur et Lvalue.

Bien que les représentations de modèles de bits de chaque type dépendent de l'implémentation, certaines relations entre les types ne le sont pas :

• La Rvalue d'un vecteur v, par exemple, est identique à la Lvalue de son élément zéro :
1. v = lv v*[0]

et donc&nbps;:

1. rv v = v*[0]


• La Lvalue du n-ième élément d'un vecteur v peut être obtenue en ajoutant l'entier n à v ; ainsi :
1. lv v*[n] = v+n


• Si x, y et t sont les premier, deuxième et n ième paramètres d'une fonction ou d'une routine et si v = lv x, alors :
  1. v*[0] = x
  2. v*[1] = y
  3. v*[n] = t

Cette propriété peut être utilisée pour définir des fonctions et des routines avec un nombre variable de paramètres réels. Dans la définition d'une telle fonction ou routine, il est nécessaire de donner une liste de paramètres formelle qui soit au moins aussi longue que la plus longue liste de paramètres réels de tout appel à celle-ci.

Exemple

La définition suivante :

définit la routine R pouvant appelée avec 6 paramètres réels ou moins. Lors de l'exécution de la routine, la variable v peut être utilisée comme un vecteur dont les n premiers éléments sont les n premiers paramètres réels de l'appel ; ainsi lors de l'appel suivant :

les initiales sont des Rvalues de :

• v*[0], v*[l], v*[2] et v*[3] sont 126, 36, 18 et 99.

La Rvalue d'une étiquette est un modèle binaire représentant la position du programme de la commande étiquetée. Notez qu'elle ne contient pas d'informations sur le niveau d'activation de la fonction ou de la routine dans laquelle l'étiquette est apparue.

La Rvalue d'une fonction ou d'une routine est une représentation du point d'entrée de la fonction ou de la routine.

Expressions primaires

Noms

Constantes de chaîne de caractères

Forme syntaxique :

La représentation matérielle des caractères dans l'alphabet de chaîne dépend de l'implémentation. Une représentation matérielle est la suivante :

L'alphabet de caractères de chaîne de caractères contient tous les caractères sauf * et ' étant représentés directement. Ces deux exceptions sont représentées par :

• ** et *' respectivement.

De plus :

Sémantique : Une constante de chaîne de caractères de longueur 1 a une Rvalue étant la représentation du motif binaire du caractère; elle est justifiée à droite et remplie de zéros.

Une constante de chaîne de caractères de longueur autre que 1 est représentée comme un vecteur BCPL ; la longueur et les caractères de la chaîne de caractères sont regroupés dans des mots successifs du vecteur.

Exemple : Si les caractères sont regroupés à 4 par mot, alors la chaîne de caractères :

Rvalue pointant vers la boîte avec 6, 'A', 'b', 'c', '1', '0', '*n', 0.

Constantes numériques

Forme syntaxique :

Sémantique : La séquence de chiffres est interprétée comme un entier décimal dans le premier cas, et comme un nombre octal justifié à droite dans le second.

True et false

Forme syntaxique :

Sémantique : La Rvalue de true est un modèle binaire entièrement composé de uns ; la Rvalue de false est zéro. Notez que :

Expressions entre crochets

Forme syntaxique :

Sémantique : Les parenthèses peuvent entourer n'importe quelle expression ; leur seul but est de spécifier le regroupement.

Blocs de résultats

Forme syntaxique :

Sémantique : Un bloc de résultats est une forme d'expression BCPL ; il est évalué en exécutant le bloc jusqu'à ce qu'une instruction resultis soit rencontrée, ce qui provoque l'arrêt de l'exécution du bloc et renvoie la valeur de l'expression dans la commande resultis.

Applications vectorielles

Forme syntaxique :

L'astérisque est nécessaire pour distinguer une application vectorielle d'une application fonctionnelle. E1 est une expression primaire.

Sémantique : Un vecteur est représenté par un pointeur vers un groupe consécutif de mots étant les éléments du vecteur. Le pointeur pointe vers le zéroième élément. Pour évaluer une application vectorielle, E1 et E2 sont évalués pour produire deux Rvalue, la première est interprétée comme un pointeur de vecteur et la seconde comme l'indice ; l'élément est ensuite consulté pour produire le résultat.

La Lvalue d'un élément peut être obtenue en évaluant l'expression :

Les représentations des vecteurs, des Lvalues et des entiers sont telles que les relations suivantes sont vraies :

Applications de la fonction

Forme syntaxique :

E1 est une expression primaire.

Sémantique : L'application de la fonction est évaluée en évaluant les expressions E1, E2 ... En et en affectant les Rvalues de E2 ... En aux n-1 premiers paramètres formels de la fonction dont la Rvalue est la valeur de E1 ; cette fonction est alors saisie. Le résultat de l'application est la Rvalue de l'expression dans la définition de la fonction.

Expressions Lv

Forme syntaxique :

E est une expression primaire.

Sémantique : La Lvalue de certaines expressions peut être obtenue en appliquant l'opérateur lv ; il n'est utile d'appliquer lv qu'à une application vectorielle, une expression rv ou un identifiant qui n'est pas une constante manifeste.

Le résultat de l'application dépend de l'opérateur principal de l'opérande comme suit :

• Une application vectorielle. Le résultat est la Lvalue de l'élément référencé.
• Une expression rv. Le résultat est la valeur de l'opérande de rv. La relation suivante est toujours vraie :
1. lv rv E = E


• Un nom. Le résultat est la Lvalue de l'élément de données portant le nom donné (ne devant pas être une constante manifeste). Si le nom a été déclaré explicitement comme fonction, routine, global ou étiquette, sa Lvalue est une constante manifeste (mais sa Rvalue ne l'est pas).

Expressions Rv

Forme syntaxique :

E est une expression primaire.

Sémantique : La valeur d'une expression rv est obtenue en évaluant son opérande pour produire un Rvalue étant ensuite interprétée comme la Lvalue d'un élément de données. Le résultat est la Rvalue de cet élément de données.

Expressions composées

Expressions arithmétiques

Forme syntaxique :

Les opérateurs * / et rem sont plus contraignants que + et - et s'associent à droite. Les opérateurs + et - s'associent à gauche.

Sémantique : Tous ces opérateurs interprètent les Rvalue de leurs opérandes comme des entiers signés et tous donnent des résultats entiers.

L'opérateur * désigne la multiplication d'entiers.

L'opérateur de division / donne le résultat correct de la division de E1 par E2 si E1 est divisible par E2 ; il dépend sinon de l'implémentation mais l'erreur d'arrondi n'est jamais supérieure à 1.

L'opérateur rem donne le reste de E1 divisé par E2 ; sa spécification exacte dépend de l'implémentation.

Les opérateurs + et - s'expliquent d'eux-mêmes.

Expressions relationnelles

Forme syntaxique :

L'absence de caractère réel >= est un problème de police de caractères.

Les opérateurs relationnels sont moins contraignants que les opérateurs arithmétiques.

Sémantique : Le résultat de l'évaluation d'une relation étendue est vrai si et seulement si toutes les relations individuelles sont vraies. L'ordre d'évaluation est indéfini. Les Rvalue des expressions E1 ... En sont interprétées comme des entiers signés et les opérateurs relationnels ont leur signification mathématique habituelle.

Expressions de décalage

Forme syntaxique :

E2 est une expression primaire ou arithmétique et E1 est une expression primaire, relationnelle, arithmétique ou de décalage. Ainsi, les opérateurs de décalage sont moins contraignants que les relations à gauche et plus contraignants à droite.

Sémantique : La Rvalue de E1 est interprétée comme un motif binaire logique et celle de E2 comme un entier. Le résultat de «E1 lshift E2» est le motif binaire E1 décalé vers la gauche de E2 positions. «E1 rshift E2» est comme pour lshift mais se décale vers la droite. Les positions vacantes sont remplies de zéros et le résultat est indéfini si E2 est négatif ou supérieur à la taille de l'élément de données.

Expressions logiques

Forme syntaxique :

Note  NEQV était une triple barre croisée.

L'opérateur ~ est le plus contraignant ; alors, par ordre décroissant de pouvoir contraignant, on trouve :

• ∧ ∨ ≡ NEQV

Tous les opérateurs logiques sont moins contraignants que les opérateurs de décalage.

Sémantique : Les opérandes de tous les opérateurs logiques sont interprétés comme des motifs binaires de uns et de zéros.

L'application de l'opérateur ~ donne la négation logique de son opérande. Le résultat de l'application de tout autre opérateur logique est un motif binaire dont le n-ième bit ne dépend que des n-ièmes bits des opérandes et peut être déterminé par le tableau suivant.

Expressions conditionnelles

Forme syntaxique :

E1, E2 et E3 peuvent être n'importe quelles expressions logiques ou des expressions ayant un pouvoir de liaison supérieur. E2 et E3 peuvent, en outre, être des expressions conditionnelles.

Sémantique : La valeur de l'expression conditionnelle E1 → E2, E3 est la valeur R de E2 ou E3 selon que la valeur de E1 représente respectivement vrai ou faux. Dans les deux cas, une seule alternative est évaluée. Si la valeur de E1 ne représente ni vrai ni faux, le résultat de l'expression conditionnelle est indéfini.

Commandes

Commandes d'affectation

Forme syntaxique :

Sémantique : La sémantique de la commande d'affectation est définie en termes de commande d'affectation simple ; la commande donnée ci-dessus est sémantiquement équivalente à la séquence suivante :

Notez que les tâches individuelles sont exécutées de gauche à droite et non simultanément.

Commandes d'affectation simples

Forme syntaxique :

Sémantique : E1 peut être soit un identifiant, soit une application vectorielle, soit une expression rv, et son effet est le suivant :

• Si E1 est un identifiant : l'identifiant doit faire référence à un élément de données ayant une Lvalue (c'est-à-dire qu'il ne doit pas être déclaré comme une constante nommée manifeste). L'affectation remplace la Rvalue de cet élément de données par la Rvalue de E2.
• Si E1 est une application vectorielle : L'élément référencé par E1 est mis à jour avec la Rvalue de E2.
• Si E1 est une expression rv : L'opérande de rv est évalué pour produire une valeur étant ensuite interprétée comme une Lvalue ; La Rvalue de E2 remplace alors la Rvalue de l'élément de données référencé par la Lvalue.

Commandes de routine

Forme syntaxique :

où E1 est une expression primaire.

Sémantique : La commande ci-dessus est exécutée en affectant les Rvalues ??de E2, E3, ... , En aux n-1 premiers paramètres formels de la routine dont la Rvalue est la valeur de E1 ; cette routine est alors saisie. L'exécution de cette commande est terminée lorsque l'exécution du corps de la routine est terminée.

Commandes d'étiquettes

Forme syntaxique :

où N est un nom.

Sémantique : Ceci déclare un élément de données avec le nom N ; sa portée est le plus petit corps de routine ou bloc de résultat englobant textuellement et sa Rvalue initiale est un motif binaire représentant la position du programme de la commande C. Sa Lvalue est une constante manifeste et fait référence à une position dans le vecteur global si et seulement si la commande étiquetée se produit dans la portée d'un global avec le même nom que l'étiquette. La Rvalue d'une étiquette est initialisée avant l'exécution du programme.

Commande goto

Forme syntaxique :

Sémantique : E est évalué pour produire une Rvalue, puis l'exécution est reprise à l'instruction dont l'étiquette avait la même Rvalue initiale.

Commande if

Forme syntaxique :

Sémantique : E est évalué pour produire une Rvalue étant ensuite interprétée comme une valeur de vérité. Dans BCPL, false est représenté par zéro et true par le complément de false :

Si la valeur de E représente false alors la commande C n'est pas exécutée ; si elle représente true alors elle est exécutée et si elle ne représente ni true ni false alors l'effet dépend de l'implémentation.

Commande unless

Forme syntaxique :

Sémantique : Cette affirmation est exactement équivalente à la suivante :

Commande while

Forme syntaxique :

Sémantique : Ceci est équivalent à la séquence suivante :

où L et M sont des identifiants n'apparaissant pas ailleurs dans le programme.

Commande until

Forme syntaxique :

Sémantique : Cette affirmation est équivalente à :

Commande test

Forme syntaxique :

Sémantique : Cette instruction est équivalente à la séquence suivante :

où L et M sont des identificateurs n'apparaissant pas ailleurs dans le programme.

Commande repeat

Forme syntaxique :

Où C est une commande autre qu'une commande if, unless, until, while, test ou for.

Sémantique : C repeat est équivalent à :

où L est un identifiant qui n'apparaît pas ailleurs dans le programme.

Commande for

Forme syntaxique :

où N est un nom.

Sémantique : L'énoncé ci-dessus est équivalent à :

Commande break

Forme syntaxique :

Sémantique : Lorsque cette instruction est exécutée, elle entraîne la reprise de l'exécution au point juste après la plus petite commande de boucle englobante textuellement. Les commandes de boucle sont celles qui contiennent les mots clefs suivants : until, while, repeat, repeatwhile, repeatuntil et for.

Commande finish

Forme syntaxique :

Sémantique : Cela provoque l'arrêt de l'exécution du programme.

Commande return

Forme syntaxique :

Sémantique : Cela provoque un retour d'un corps de routine au point juste après la commande de routine ayant effectué l'appel de routine.

Commande Resultis

Forme syntaxique :

Sémantique : Cela provoque l'arrêt de l'exécution du plus petit bloc de résultats englobant et renvoie la valeur R de E.

Commande switchon

Forme syntaxique :

où le bloc contient des étiquettes de la forme :

Sémantique : L'expression est d'abord évaluée, puis si un cas existe ayant une constante avec la même valeur, l'exécution reprend à cette étiquette ; sinon, s'il existe un étiquette par défaut, l'exécution continue à partir de là ; sinon, l'exécution reprend juste après la fin de la commande switchon. Le commutateur est implémenté comme un commutateur direct, une recherche séquentielle ou un commutateur de hachage en fonction du nombre et de l'intervalle des constantes de cas.

Blocs

Forme syntaxique :

Sémantique : Un bloc est exécuté en exécutant les déclarations (le cas échéant) en séquence, puis en exécutant les commandes du bloc. La portée de la définition d'une déclaration est la région du programme constituée de la déclaration elle-même, des déclarations suivantes et de la séquence de commandes.

Définitions

Règles de portée

La portée d'un nom N est la région textuelle du programme dans laquelle N fait référence au même élément de données. Chaque occurrence d'un nom doit être dans la portée d'une déclaration du même nom.

Il existe trois types de déclaration :

• Une liste de paramètres formels d'une fonction ou d'une routine : sa portée est le corps de la fonction ou de la routine.
• L'ensemble des étiquettes définies par deux points d'une routine ou d'un bloc de résultats : sa portée est le corps de la routine ou du bloc de résultats.
• Chaque déclaration dans la séquence de déclaration d'un bloc : sa portée est la région du programme constituée de la déclaration elle-même, des déclarations suivantes et de la séquence de commandes du bloc.

Deux éléments de données sont dits déclarés au même niveau de définition s'ils ont été déclarés dans la même liste de paramètres formels, comme étiquettes de la même routine ou du même bloc de résultats, ou dans la même définition.

Il existe trois restrictions sémantiques concernant les règles de portée ; ce sont :

• Deux éléments de données portant le même nom ne peuvent pas être déclarés au même niveau de définition.
• Si un nom N est utilisé mais n'est pas déclaré dans le corps d'une fonction ou d'une routine, il doit s'agir soit d'une constante nommée manifeste, soit d'un élément de données avec une constante manifeste Lvalue, c'est-à-dire qu'il doit avoir été déclaré comme une fonction ou une routine globale, explicite, ou comme une étiquette.
• Une étiquette définie par deux points ne peut pas apparaître dans la portée d'un élément de données portant le même nom si cet élément de données a été déclaré dans la portée de l'étiquette et n'était pas global.

Allocation d'espace et étendue des éléments de données

L'étendue d'un élément de données est la durée pendant laquelle il existe et a une Lvalue.

Tout au long de l'étendue d'un élément de données, sa Lvalue reste constante et sa Rvalue n'est modifiée que par affectation.

Dans BCPL, les éléments de données peuvent être divisés en deux classes :

• Éléments de données statiques : éléments de données dont l'étendue dure aussi longtemps que le temps d'exécution du programme ; ces éléments de données ont des Lvalues constantes manifestes. Chaque élément de données statique doit avoir été déclaré soit dans une définition de fonction ou de routine, dans une déclaration globale ou sous la forme d'une étiquette définie par deux points.
• Éléments de données dynamiques : éléments de données dont l'étendue est limitée ; l'étendue d'un élément de données dynamique commence lorsque sa déclaration est exécutée et continue jusqu'à ce que l'exécution quitte la portée de la déclaration. Chaque élément de données dynamique doit être déclaré soit par une définition simple, une définition vectorielle ou comme un paramètre formel. La Lvalue d'un tel élément de données n'est pas une constante manifeste.

Un élément de données est initialisé au plus une fois au début de son étendue ; les éléments de données statiques sont initialisés avant l'exécution du programme et un élément de données dynamiques au moment où sa déclaration est exécutée. Les éléments de données statiques et dynamiques peuvent avoir leurs Rvalue modifiées par affectation.

Pendant l'exécution d'une fonction ou d'une routine récursive, une seule déclaration de texture peut donner lieu à plusieurs activations de sa définition. Les seules déclarations pouvant donner lieu à plusieurs activations sont celles déclarant des éléments de données dynamiques, à savoir :

• définitions simples, définitions vectorielles et paramètres formels.

Déclarations globales

Forme syntaxique :

Sémantique : Le vecteur global est le seul moyen de communication entre les segments compilés séparément d'un programme. Pour appeler une fonction ou une routine déclarée dans un segment à partir d'une position dans un autre, il est nécessaire de la déclarer comme globale dans chacun des deux segments.

La déclaration ci-dessus déclare un ensemble de noms comme étant global et alloue les positions dans le vecteur global comme défini par les constantes manifestes. Une variable globale est un élément de données statique et possède une Lvalue étant une constante manifeste.

Déclarations manifestes

Forme syntaxique :

Sémantique : cette déclaration déclare que chaque nom est une constante manifeste avec une valeur égale à la valeur de son expression constante associée. La signification d'un programme resterait inchangée si toutes les occurrences de constantes nommées manifestes étaient remplacées textuellement par leurs valeurs correspondantes.

Cette fonctionnalité a été fournie pour améliorer la lisibilité des programmes et pour donner au programmeur une plus grande flexibilité dans le choix des représentations internes des données.

Définitions simples

Forme syntaxique :

Sémantique : Les éléments de données portant les noms N1 ... Nn sont d'abord déclarés, mais pas initialisés, puis la commande d'affectation suivante est exécutée :

Une définition simple déclare des éléments de données dynamiques.

Définitions vectorielles

Forme syntaxique :

où N est un nom.

Sémantique : la valeur de l'expression constante doit être une constante manifeste et elle définit la valeur d'indice maximale autorisée du vecteur N. La valeur d'indice minimale est toujours zéro. La Rvalue initiale de N est la valeur L du zéroième élément du vecteur ; N et les éléments du vecteur sont tous deux des éléments de données dynamiques.

Définitions de fonctions

Forme syntaxique :

où N est un nom.

Sémantique : Ceci définit une fonction avec le nom N ; l'élément de données défini est statique et sa Rvalue est initialisée avant l'exécution du programme. La valeur L de N est une constante manifeste et fait référence à une position dans le vecteur global si et seulement si la définition de fonction est dans la portée d'une définition globale du même nom.

Les noms dans la liste de noms sont appelés paramètres formels et leur portée est le corps de la fonction E. L'étendue d'un paramètre formel dure depuis le moment de son initialisation dans un appel jusqu'au moment où l'évaluation du corps est terminée.

Toutes les fonctions et routines peuvent être définies et utilisées de manière récursive.

Définitions de routine

Forme syntaxique :

où N est un nom.

Sémantique : Ceci définit une routine avec le nom N. La sémantique d'une définition de routine est exactement la même que celle d'une définition de fonction, sauf que le corps d'une routine est un bloc et que son application ne donne donc aucun résultat. Une routine ne doit donc être appelée que dans le contexte d'une commande.

Définitions simultanées

Forme syntaxique :

Sémantique : Toutes les définitions sont effectivement exécutées simultanément et tous les éléments de données définis ont la même portée qui, selon les règles de portée, inclut la définition simultanée elle-même ; un ensemble de fonctions et de routines mutuellement récursives peut ainsi être déclaré.