Syntaxe

Syntaxe du langage DCL

Pour tout ce qui écrit ci-après  je me suis fortement inspiré d'un livre (retrouvé par hasard) qui était fourni à une époque (années 90) où les éditeurs de logiciels ne nous voyaient pas encore comme des vaches à lait et se fendaient de didacticiels livrés dans la langue de l'achat du logiciel, ce temps est révolu mais je vous fais partager toute cette théorie.

Cette page décrit la syntaxe DCL permettant de définir les composants, les attributs des composants et les valeurs des attributs.
Les nouveaux composants sont créés à partir de définitions.
Lorsqu'une définition de composant apparaît en dehors d'une définition de boîte
de dialogue, il s'agit d'un prototype ou d'un sous-ensemble.
Les prototypes et sous-ensembles peuvent être utilisés dans les définitions
de boîtes de dialogue à partir de références.
Chaque référence à une définition hérite des attributs du composant d'origine. Dans les références aux prototypes, vous pouvez modifier les valeurs des
attributs précédents ou ajouter de nouveaux attributs.
En revanche, dans les références aux sous-ensembles, les attributs sont figés. '
Si vous prévoyez d'utiliser plusieurs fois un même composant avec des
attributs communs, il est plus pratique de définir un prototype contenant uniquement les attributs communs.
Par la suite, vous pouvez modifier les attributs ou en ajouter de nouveaux dans chaque référence au prototype sans avoir à les afficher tous.
Les attributs étant hérités, vous serez plutôt amené à créer des références (notamment aux composants prédéfinis) que des composants en soi.

Accès direct dans cette page à : Définition de composant Référence aux composants Attributs et valeurs d'attributs Commentaires Gestion des erreurs sous DCL Contrôle sémantique des fichiers DCL

Définition de composant

Une définition de composant se présente ainsi :

nom: elt1 [: elt2: elt3 ... ]
 {
attribut = valeur;
}

elt désignant un composant précédemment défini.
Le nouveau composant (nom) hérite des attributs de tous les composants indiqués (elt1, elt2, etc.).
Les éventuelles définitions d'attributs entre accolades ({}) permettent d'ajouter des attributs ou de modifier ceux hérités (si le nom de l'attribut est identique).
Si la définition a plusieurs parents, l'ordre de priorité des attributs est défini de gauche à droite, c'est-à-dire que si plusieurs éléments référencés possèdent le même attribut, la modification est appliquée au premier élément trouvé.
Si la nouvelle définition ne comporte aucun enfant, elle devient un
prototype.
Vous pouvez modifier ses attributs ou en ajouter lorsque vous y faites référence. S'il s'agit d'un sous-ensemble avec enfants, les attributs ne peuvent pas être changés.
Le nom d'un composant (prototype ou non) peut contenir des lettres,
des chiffres et le trait de soulignement ( _ ) (underscore). Le premier caractère doit être une lettre.
Les majuscules sont distinguées des minuscules dans les noms des composants de boîtes. Par exemple, monbouton, MONBOUTON et MonBouton désignent trois composants différents.
Il faut de la rigueur et toujours conserver exactement la même écriture pour identifier vos composants.

L'exemple ci-dessous correspond à la définition interne d'un bouton :

button : tile {
fixed height = true;
is_tab_stop = true;
}

Le fichier base.dcl définit un bouton de type default_button de la façon suivante :

default_button : button {
is_default = true;
}

Le bouton default_button hérite des deux valeurs définies pour les attributs
fixed_height et is_tab_stop.
Un troisième attribut, is_default, de valeur true, leur est ajouté.

Haut de page

Référence aux composants

Les références aux composants se présentent de l'une des deux façons suivantes :

1
2
3
4
5
6
7

nom;
// n'oubliez pas le point-virgule de fin de ligne 
// ou bien
: nom 
{
attribut = valeur;
}

nom étant le nom d'un composant prédéfini.
Attention à la casse, majuscules qui sont distinguées des minuscules dans les noms de composants.
Dans le premier exemple, tous les attributs définis dans nom sont intégrés à la référence.
Dans le second, les définitions d'attributs entre accolades ajoutent de nouvelles définitions ou remplacent celles héritées.
Comme il s'agit d'une référence et non d'une définition de composant, les modifications et ajouts d'attributs ne sont valables que pour cette occurrence du composant.
La seconde forme n'est utilisable qu'avec les prototypes et non avec les sous-ensembles.
Dans une définition de boîte de dialogue, le composant spacer est
utilisé pour la présentation, il ne possède pas d'attributs.
Les références peuvent donc utiliser le premier format :

spacer;

Le composant ok_cancel défini dans le fichier base. dcl est un sous-ensemble
et ne peut donc être référencé que suivant le format du premier exemple :

ok_cancel;

Inversement, vous pouvez redéfinir les attributs d'un composant particulier, par exemple, si vous souhaitez créer un bouton avec les mêmes fonctions qu'un autre bouton mais avec une étiquette différente, utilisez le format suivant :

: retirement button { label = "Au revoir"; }

Voir les explications concernant "Personnalisation du texte des boutons de sortie de boîte" ailleurs sur ce site.

Haut de page

Attributs et valeurs d'attributs

Entre les accolades de définition ou de référence de composant, vous mentionnez des attributs et leur affectez des valeurs suivant la syntaxe ci-après:

attribut = valeur ;

attribut correspondant à un mot-clé et valeur à la valeur affectée à cet attribut.
Le signe égal (=) sépare l'attribut de la valeur et le point-virgule (;) indique la fin de l'instruction.
Comme pour les noms des composants de boîte, les majuscules sont distinguées des minuscules dans les noms des attributs et dans les valeurs. Ainsi, Largeur et largeur désignent deux attributs différents et les valeurs True et true ne donnent pas le même résultat.

Haut de page

Commentaires

Les commentaires permettent d'ajouter des informations telles que le nom du programme ou des fichiers qui lui sont associés, le nom du programmeur, et des explications ou des informations d'usage. Comme je vous l'indiquais pour l'AutoLISP il ne faut pas négliger les commentaires qui permettent de s'y retrouver lors des mises- à jour ou autres évolutions du code.

Dans un fichier DCL, tout ce qui est commentaire est précédé de deux barres obliques (/ /) double slash.
Toutes les données entre ces symboles et la fin de la ligne sont ignorées par le logiciel
Le langage DCL autorise, de plus, des commentaires multi-lignes sous la forme :
/* commentaire /*
Les délimiteurs de début (/ *) et de fin ( * /) peuvent se trouver sur des lignes distinctes.

Dans les commentaires  multi-lignes /* et */, insérer d'autres commentaires n'est pas possible, le genre de commentaire qui suit est interdit :

1
2
3
4
5
6

/* début du commentaire
blabla commentaires "principal"
 /* insertion de commentaire dans le bloc de commentaires */
blabla suite du commentaire "principal"
et je termine sur cette ligne
*/

La ligne 3 va déclencher une erreur

Haut de page

Gestion des erreurs sous DCL

L'utilitaire PDB effectue une analyse des fichiers DCL lors de leur chargement initial.
En cas d'erreur de syntaxe, d'utilisation incorrecte des attributs ou autre (par exemple si un attribut clé a été omis pour un composant actif), le fichier DCL n'est pas chargé et la liste des erreurs est écrite dans un fichier texte acad.dce. La consultation de ce fichier peut vous aider à résoudre le problème.
Si le fichier DCL est lu sans qu'aucune erreur ne soit détectée, AutoCAD supprime le fichier acad.dce.
En général, AutoCAD place le fichier acad.dce dans le répertoire de travail courant.
Si votre application utilise plusieurs fichiers DCL, le fichier acad.dce est
écrasé à chaque chargement (ou supprimé si aucune erreur n'a été trouvée). Lorsque vous testez un programme, acad.dce ne contient que les erreurs rencontrées éventuellement dans le dernier fichier DCL lu.
Il est par conséquent conseillé de charger chaque fichier manuellement à l'aide de la fonction load_dialog pour la mise au point du programme.
Dans l'exemple suivant, la fonction load _dialog permet de charger le fichier DCL "coucou.dcl" :
Commande : (load_dialog "coucou")
3
La fonction load_dialog renvoie le numéro d'identification DCL.
Vous devez noter ce numéro, car il doit être transmis comme argument aux fonctions new_dialog et unload_dialog.

Si, suite à des erreurs, des données sont écrites dans le fichier acad.dce,
une case d'alerte apparaît pour vous en avertir.
Sinon, load_dialog renvoie un nombre entier positif identifiant le fichier DCL. Cette valeur est utilisée par la fonction new_dialog pour initialiser les boîtes
de dialogue individuelles dans le fichier.

Certaines des erreurs signalées dans la case d'alerte pendant l'exécution de new_ dialog ne sont pas consignées dans le fichier acad.dce.
La fonction new_dialog renvoie la valeur T en cas de succès et la valeur nil en cas d'échec.
Si elle a renvoyé T, vous devez utiliser start_dialog pour afficher la boîte de dialogue.

Le programme AutoCAD risque d'être interrompu si vous appelez la fonction start_dialog après que new_dialog ait renvoyé la valeur nil.
Sur certaines plateformes, l'exécution de la fonction new_dialog peut activer la boîte de dialogue sans l'ouvrir, ce qui risque également de bloquer le  fonctionnement d'AutoCAD.
Dans ce cas, vous devez faire appel à une fonction pour regrouper new_dialog et start_dialog lorsque vous les appelez en mode interactif :

( if (new_dialog "coucou" 3 )( setq retcode ( start_dialog)))

Lorsque vous avez corrigé les erreurs dans chacun des fichiers DCL, vous pouvez charger le programme et tester les boîtes de dialogue ensemble.

Haut de page

Contrôle sémantique des fichiers DCL

AutoCAD propose quatre niveaux (de 0 à 3) de contrôle sémantique des fichiers DCL (reportez-vous au tableau suivant).
Ce contrôle permet de détecter les instructions problématiques ou inutiles dans les fichiers DCL.
Le contrôle est réalisé au moment du chargement du fichier DCL.
Pour définir le niveau de contrôle d'un fichier DCL, ajoutez une ligne au format suivant dans le fichier DCL mais pas à l'intérieur d'une définition de composant par exemple en début de fichier.

dcl_settings : default_dcl_settings { audit_level = 3; }

Si votre fichier DCL fait référence à d'autres fichiers DCL (au moyen de l'instruction d'inclusion @include), vous ne devez utiliser l'instruction
dcl_settings que dans un seul des fichiers.
Le niveau de contrôle ainsi défini est appliqué à tous les fichiers référencés.

Niveaux de contrôle sémantique

Pour exploiter au maximum la fonction de contrôle, les utilisateurs du langage DCL ont intérêt à conserver le niveau 3 pendant toute la durée du  développement.

Haut de page

Retour à "Théorie DCL"

05 janvier2018