26 juillet 2000 (Release 3)

Note : La description qui suit s’applique aux commandes DIM qui se trouvent à l’intérieur des blocs de définition de “vrai record” (BEGIN RECORD…END RECORD), aussi bien qu’à celles qui sont situées à l’extérieur de ces blocs. Les commandes DIM situées dans des blocs de définition de “pseudo record” (DIM RECORD…DIM END RECORD) sont utilisées quelque peu différemment, voyez la commande DIM RECORD pour plus d’informations.

La Release 3 a introduit une nouvelle syntaxe pour la commande DIM.

La syntaxe DIM AS indique que toutes les variables qui suivent sont du même type et de la même taille. Ceci est différent de DIM AS LONG qui attribue des spécifications à une seule variable par instruction.

DIM est une commande non-exécutable qui permet au compilateur de déterminer combien d’espace de stockage il doit allouer pour les variables, les tableaux et les champs de records qui sont déclarés, et d’identifier leur type de donnée. La commande DIM peut aussi être utilisée pour affecter la position relative en mémoire des variables, tableaux et champs déclarés.

Le paramètre declaration peut prendre l’une des formes suivantes :

Variables simples :

Records :

Tableaux :

Pointeurs :

Handles :

Déclarations d’Alignement Mémoire

•	longueurMax, maxIndice1, maxIndice2 et statExpr sont des expressions entières statiques (non négatives).
•	constante est un entier littéral (non négatif) ou une constante symbolique; mais, si une constante symbolique est utilisée, son caractère initial de soulignement est omis.
•	varChaine$ est une variable dont le nom se termine par le suffixe identificateur de type “$”.
•	nomVar est un nom de variable optionnellement terminé par un suffixe identificateur de type.
•	varAtypique est un nom de variable qui ne se termine pas par un suffixe identificateur de type.
•	typeUtilisateur est un nom de type défini antérieurement par une commande BEGIN RECORD ou #DEFINE.
•	typeRecord est un nom de type défini antérieurement par une commande BEGIN RECORD.
•	typePredefini est l’un des types suivants : CHAR, [UNSIGNED] BYTE, [UNSIGNED] WORD, [UNSIGNED] SHORT, [UNSIGNED] INT, UInt16 ,[UNSIGNED] LONG, UInt32, POINT, FIXED, RECT, HANDLE, RGNHANDLE, STR255, STR63, STR31, STR15, EXTENDED, DOUBLE, SINGLE.

Si une commande DIM apparaît à l’intérieur d’un bloc BEGIN GLOBALS…END GLOBALS, alors la portée des variables et tableaux déclarés est globale. Si elle apparaît à l’intérieur d’une fonction LOCAL ou d’une procédure ENTERPROC (mais, non à l’intérieur d’un bloc BEGIN GLOBALS…END GLOBALS), alors la portée des variables et tableaux déclarés est locale à cette fonction ou à cette procédure. Si la commande DIM apparaît à l’extérieur de toutes les fonctions et procédures (et à l’extérieur d’un bloc BEGIN GLOBALS…END GLOBALS), alors la portée des variables et tableaux déclarés est locale au “programme principal”.

Votre programme peut comporter autant de commandes DIM que vous le souhaitez.

La déclaration suivante :

est équivalente aux deux instructions suivantes :

Certaines structures doivent toujours être déclarées par une commande DIM, qui doit apparaître quelque part avant la ligne où la structure est effectivement utilisée. Ces structures comprennent :

•	Les tableaux (à moins qu’ils ne soient déclarés par une commande XREF ou XREF@)
•	Les variables de type record
•	Les variables d’un type défini par l’utilisateur
•	Les variables du type pointeur ou handle

Si l’option _dimmedVarsOnly du compilateur est active, alors cette restriction s’applique à toutes les variables, à l’exception de celles figurant dans la liste des paramètres des commandes LOCAL FN ou ENTERPROC.

Si l’option _dimmedVarsOnly du compilateur n’est pas active, alors les chaînes simples et les variables numériques n’ont pas besoin d’être déclarées avec DIM. Dans ce cas, une variable simple est Implicitement déclarée dans la première instruction où elle apparaît (avec la portée qui lui correspond), et le compilateur utilise cette déclaration implicite pour allouer l’espace de stockage adéquat.


L’espace de stockage pour les types prédéfinis par FutureBASIC est alloué comme suit :

Type	Stockage
Entiers sur octet ( `, ``); BYTE; CHAR	1 octet
Entiers courts (+, %`); SHORT; INT; WORD	2 octets
Entiers longs (&, &`); LONG	4 octets
POINT; FIXED	4 octets
Simple précision (!); SINGLE	4 octets
Double précision (#); DOUBLE	(voir note)
RECT	8 octets
STR255	256 octets
POINTER	4 octets
HANDLE	4 octets

 

(Note : l’espace de stockage des variables en double précision dépend du type de processeur (CPU 68K ou PPC) cible de votre compilation : 10 octets en 68K et 8 octets en PPC. Utilisez la fonction SIZEOF pour déterminer de manière certaine les tailles de ces variables.

L’espace de stockage alloué à une variable chaîne dépend de la valeur du paramètre longueurMax (qui ne peut excéder 255). Si longueurMax est omis, alors le paramètre longueurMax spécifié le plus récemment dans une commande DIM est utilisé. S’il n’y a pas de paramètre longueurMax spécifié antérieurement dans une commande DIM, alors la valeur spécifiée par la plus récente commande DEF LEN est utilisée. S’il n’y a pas de commande DEF LEN précédant la commande DIM, alors le paramètre longueurMax prendra sa valeur par défaut à 255. Les variables chaînes déclarées avec la clause AS STR255 ont toujours une valeur pour longueurMax de 255.

Une fois que le paramètre longueurMax a été déterminé pour une variable chaîne donnée, le nombre réel d’octets alloués pour cette variable est :

• longueurMax + 1 octet, si longueurMax est impair;

• longueurMax + 2 octets, si longueurMax est pair;

Votre programme ne doit pas assigner plus de longueurMax caractères à une variable chaîne.

L’espace de stockage d’une variable record est égal à la somme des tailles de ses champs, ou à la valeur constant2 (en octets).

L’espace de stockage pour un tableau est calculé comme suit : Si tailleElem est la taille en octets d’un élément du tableau, alors l’espace alloué pour le tableau entier est donné par la formule suivante :

Tous les éléments d’un tableau sont stockés en mémoire de manière contiguë. Si le tableau est multidimensionnel, alors la dimension la plus à droite change plus rapidement à mesure que vous vous déplacez dans le tableau en mémoire.

Par exemple, si vous déclarez un tableau comme suit :

Alors les éléments de p%() sont stockés en mémoire dans cet ordre :

Utilisation du symbole “@” pour contrôler le stockage en RAM

Afin augmenter la vitesse d’exécution d’un programme, FB^3 peut stocker certaines variables dans des registres du CPU plutôt que dans une mémoire adressable en RAM (plus lente). Si vous utilisez la commande REGISTER ON, ou que l’option du compilateur “Mettre les variables en registres ” est activée dans les préférences, FB^3 range dans les registres du CPU, autant de variables qu’il peut, lorsque ces variables sont du type entier court, entier long ou octet. Le compilateur commence avec la première variable qu’il rencontre, et continue à assigner les variables à la suite dans des registres jusqu’à ce qu’il n’y ait plus aucun registre disponible.

Quelquefois cette méthode n’est pas appropriée. Si votre programme a besoin d’obtenir l’adresse d’une variable, cette variable doit être stockée dans un espace adressable en RAM. Lorsque vous mettez un symbole “@” devant un nom de variable dans une commande DIM, vous forcez toutes les variables qui suivent la commande DIM (à la droite de “@”) à être stockées en RAM plutôt que dans des registres du CPU. Voyez les commandes REGISTER ON/OFF pour plus d’informations.

Utilisation des Déclarateurs d’Alignement Mémoire pour ajuster l’endroit de stockage.

Un déclarateur d’alignement mémoire (%, &, &&, &&&) affecte l’endroit de stockage d’une variable simple ou de type record qui est déclarée après, en forçant la variable à commencer à une position d’octet dont l’adresse est divisible par 2, 4, 8 ou 16. Cela peut améliorer l’efficacité de certaines opérations de bas niveau qui impliquent cette variable, et peut, de ce fait, améliorer la rapidité d’exécution de votre programme. Le déclarateur mémoire .constant2 force l’insertion d’un nombre arbitraire d’octets vides entre deux variables.

DIM %, var	Force var à commencer sur une frontière de mot (adresse divisible par 2)
DIM &, var	Force var à commencer sur une frontière de mot long (adresse divisible par 4).
DIM &&, var	Force var à commencer sur une frontière de mot long double (adresse divisible par 8).
DIM &&&, var	Force var à commencer sur une frontière de mot étendu (adresse divisible par 16)
DIM .constante2, var	Force var à commencer à constante2 octets après la fin de la précédente variable déclarée.

Note : l’utilisation des déclarateurs d’alignement ci-dessus force également les variables restantes déclarées dans la commande DIM (à la droite du déclarateur) à être stockées dans un espace mémoire adressable plutôt que dans des registres du CPU. Voyez les commandes REGISTER ON/OFF pour plus d’informations.


Utilisation de la syntaxe point-virgule(;)pour ajuster l’endroit de stockage
(pour des variables qui ne sont pas des tableaux)

Les variables simples et de type record sont normalement stockées dans un espace contigu en mémoire, selon l’ordre dans lequel elles sont déclarées. Par exemple, examinez l’instruction DIM suivante :

En admettant qu’aucune de ces variables n’a été implicitement déclarée avant la commande DIM, et qu’elles sont toutes localisées dans un espace mémoire adressable en RAM, alors elles apparaîtront de manière contiguë en mémoire, comme illustré dans ce diagramme :
Il est parfois utile d’ajuster l’arrangement de ce stockage. Cela peut être fait en utilisant la syntaxe point-virgule. Lorsqu’une déclaration de la forme var;constant1 figure dans une commande DIM, le compilateur est chargé d’appliquer un décalage de constant1 octets entre le début de la variable var et le début de la variable suivante. Cela peut être utile en certaines occasions :

• Si constant1 est plus grand que la taille de stockage de var, alors des octets supplémentaires (sans référence) seront réservés après la variable var. Par exemple :

Cette instruction demande au compilateur d’allouer l’espace de stockage comme suit (en admettant que le type par défaut des variables atypiques est entier court sur 2 octets) :
Ici, même si maVar est effectivement un entier sur 2 octets, vous pouvez stocker jusqu’à 8 octets à son adresse en mémoire sans interférer avec les autres variables du programme. Ceci est utile avec certaines commandes anciennes de FutureBASIC, qui réclament le nom d’une variable sur un entier court, mais qui s’attendent à trouver une plus grande structure de données à l’adresse de cette variable.


• Si constant1 est plus petit que la taille de la variable var, alors vous pouvez forcer des variables à “se chevaucher” en mémoire.. Ceci produit un effet similaire au mot-clé “union” du C, ou à la commande “EQUIVALENCE” du ForTran. Par exemple :

Ici, on demande au compilateur de ne mettre aucun décalage entre le début de monLong& et le début de motFort%. Le résultat ressemble à ceci:
Dans cet exemple, à chaque fois que le programme assigne une nouvelle valeur à monLong&, les valeurs de motFort% et de motFaible% sont également altérées. De même, si le programme attribue une nouvelle valeur à motFort% ou à motFaible%, alors la valeur de monLong& est modifiée.

L’exemple qui suit pousse ce concept un peu plus loin :

Ici, les variables sont stockées de la manière suivante :
Dans cette exemple, les 8 octets de stockage sont connus par une quantité de noms différents. Si nous imaginons que les 8 octets représentent la structure standard d’un rectangle QuickDraw, alors : rect représente la structure complète; pt1 et pt2 représentent les points supérieur gauche et inférieur droit du rectangle; longPt1& et longPt2& sont des entiers longs synonymes de pt1 et pt2 respectivement; enfin, x1%, y1%, x2% et y2% représentent les coordonnées individuelles des deux points.

Si vous utilisez la syntaxe point-virgule en conjonction avec un déclarateur d’alignement mémoire, alors les effets sont combinés. Par exemple, si vous déclarez ceci :

alors la variable x% commence à la première frontière de mot long qui est située à 7 octets au moins après le début de la variable z$.

Note : L’utilisation du point-virgule dans une déclaration (à l’exception des tableaux) force la variable qui précède le point-virgule, et toutes les variables qui le suivent dans la même instruction DIM, à être stockées en mémoire adressable, plutôt que dans des registres du CPU. Voyez les commandes REGISTER ON/OFF pour plus d’informations.

Utilisation de la syntaxe “;0” avec les tableaux
La syntaxe point-virgule peut être utilisée d’une manière limitée avec les tableaux de variables simples (ce qui exclut les tableaux de records). Par exemple, en déclarant ce qui suit :

vous demandez au compilateur d’aligner le début du tableau de variables simples qui sera déclaré juste après avec le début du tableau abc&(). Cet autre tableau n’a pas besoin d’être du même type simple, ni d’avoir les mêmes dimensions que le tableau abc&(). Notez que, la syntaxe point-virgule n’est pas valable pour les tableaux de records. De plus, lorsque vous utilisez le point-virgule avec des tableaux, vous devez faire suivre le point-virgule par un zéro, vous ne pouvez pas utiliser de constante arbitraire dans ce cas.

FB^3 range les tableaux et les variables qui ne sont pas des tableaux dans des endroits séparés en mémoire. Vous ne pouvez pas utiliser le point-virgule après une variable qui n’est pas un tableau pour ajuster l’endroit de stockage d’un tableau, et réciproquement non plus.