Modification de Villes/Montluçon/sciences/Turbo Pascal/utilitaires

Ce fichier décrit cinq programmes autonomes utilitaires qui viennent avec Turbo Pascal: TPUMOVER, MAKE, TOUCH, GREP et BINOBJ.

==Utilisation de TPUMOVER==

Lorsque vous écrivez des unités, vous voulez les rendre facilement accessibles à tous les programmes que vous développez. (Mystères de chapitre, "Unités et Mystères connexes», explique ce qu'est une unité est et raconte comment créer vos propres unités.) Nous allons maintenant vous montrer comment utiliser TPUMOVER pour éliminer les unités rarement utilisées de TURBO.TPL, et comment insérer des unités souvent utilisées dans TURBO.TPL.


  Un examen des dossiers Unité

Il existe deux types de fichiers de l'unité: les fichiers .TPU et fichiers .TPL. Lorsque vous compilez une unité, Turbo Pascal met le code objet résultant dans un fichier .TPU (Turbo Pascal Unit), qui contient toujours une unité exactement.

A .TPL (Turbo Pascal Library) fichier, d'autre part, peut contenir plusieurs unités. Par exemple, toutes les unités qui viennent sur votre disque Turbo Pascal sont dans le fichier TURBO.TPL. Le TURBO.TPL de fichier est actuellement le seul fichier de bibliothèque Turbo Pascal va charger des unités de.

Vous avez peut-être remarqué, cependant, que vous pouvez utiliser les unités standard Turbo Pascal sans donner un nom de fichier. En effet, ces unités sont stockées dans le fichier de l'unité standard Turbo Pascal - TURBO.TPL sur votre disque de distribution. Parce que les unités sont dans ce fichier, tout programme peut les utiliser sans «connaître» leur emplacement.

Supposons que vous ayez une unité appelée TOOLS.TPU, et vous l'utiliser dans de nombreux programmes différents. Bien que l'ajout d'outils pour TURBO.TPL prend mémoire (TURBO.TPL est automatiquement chargé en mémoire par le compilateur), l'ajouter à la bibliothèque résidente rend "en utilisant" Outils plus vite parce que l'unité est en mémoire plutôt que sur le disque.

Il y a cinq unités standard déjà contenues dans TURBO.TPL: System, Overlay, Printer, Crt, et Dos.

===Utilisation de TPUMOVER===

Vous pouvez utiliser plusieurs paramètres de ligne de commande qui vous permettent de manipuler les unités rapidement. La syntaxe de ces paramètres est

  opérations de nom de fichier TPUMOVER

où le nom de fichier est un fichier de .TPU ou un fichier .TPL, et opérations est une liste facultative d'un ou plusieurs des éléments suivants :

  + Unitname Ajouter une unité à la bibliothèque.
  - unitname Supprimer une unité de la bibliothèque.
  * Unitname Extrait d'une unité de la bibliothèque.

Si aucune opération sont spécifiées, TPUMOVER répertorie les unités dans le fichier de la bibliothèque ainsi que la taille et la dépendance des informations.

==L'utilitaire MAKE==

===Contenu des Makefiles===

Un makefile contient les définitions et les relations nécessaires pour aider à faire garder votre programme (s) à jour. Vous pouvez créer autant de makefiles que vous le souhaitez et les nommer ce que vous voulez. Si vous ne spécifiez pas de makefile lorsque vous exécutez MAKE (en utilisant l'option -f), puis MAKE recherche d'un fichier avec le nom par défaut MAKEFILE.

Vous créez un makefile avec un éditeur de texte ASCII, comme éditeur interactif intégré de Turbo Pascal. Toutes les règles, les définitions et directives se terminent par un retour chariot; si une ligne est trop longue, vous pouvez continuer à la ligne suivante en plaçant une barre oblique inverse (\) comme le dernier caractère de la ligne.

Whitespace - espaces et tabulations - est utilisé pour séparer les identificateurs adjacents (comme les dépendances) et aux commandes en retrait dans une règle.

Création d'un makefile est presque comme l'écriture d'un programme - avec des définitions, des commandes et des directives.

===commentaires===

Les commentaires commencent par un signe dièse (#); le reste de la ligne qui suit le # est ignorée par MAKE. Les commentaires peuvent être placés partout et n'ont pas à commencer dans une colonne particulière.

===Règles explicites===

Les règles explicites prennent la forme

  cible [cible ...]: [source source ...]
      [commande]
      [commande]
      ...

où la cible est le fichier à être mis à jour, la source est un fichier dont la cible dépend, et la commande est une commande valide MS-DOS (y compris l'invocation de fichiers .BAT et l'exécution des .COM et fichiers .EXE).

Des règles explicites définissent un ou plusieurs noms de cibles, zéro ou plusieurs fichiers source, et une liste facultative de commandes à exécuter. Les noms de cible et de fichiers source répertoriés dans des règles explicites peuvent contenir des disques et des répertoires spécifications MS-DOS normales, mais ils ne peuvent pas contenir des caractères génériques.

====Syntaxe====

ici est important. cible doit être au début d'une ligne (colonne 1), et chaque commande doit être en retrait (précédé d'au moins un caractère d'espace ou une tabulation). Comme mentionné précédemment, la barre oblique inverse (\) peut être utilisé comme un caractère de continuation si la liste des fichiers source ou une commande donnée est trop long pour une seule ligne. Enfin, aussi bien les fichiers source et les commandes sont facultatives; il est possible d'avoir une règle explicite consistant seulement

  cible [cible ...] suivi par deux points.

L'idée derrière une règle explicite est que la ou les commandes énumérées vont créer ou mettre à jour la cible, en utilisant habituellement les fichiers source. Lorsque MAKE rencontre une règle explicite, il vérifie d'abord pour voir si l'un des fichiers source sont des fichiers cibles ailleurs dans le makefile. Si oui, ces règles sont évaluées en premier.

Une fois que tous les fichiers source ont été créés ou mis à jour sur la base d'autres règles explicites (ou implicites), effectuer des contrôles pour voir si la cible existe. Sinon, chaque commande est invoquée dans l'ordre donné. Si existe cible, son heure et la date de la dernière modification sont comparées à l'heure et la date de chaque source. Si une source a été modifié plus récemment que la cible, la liste des commandes est exécutée.

Un nom de fichier donné peut se produire sur le côté gauche d'une règle explicite qu'une seule fois dans une exécution donnée de MAKE.

Chaque ligne de commande dans une règle explicite commence par des espaces. FAIS considère toutes les lignes suivantes une règle explicite pour faire partie de la liste de commandes pour cette règle, jusqu'à la ligne suivante qui commence dans la colonne 1 (sans aucun espace précédent) ou jusqu'à la fin du fichier. Les lignes vides sont ignorées.

Une règle explicite, sans lignes de commande suivante, il est traité un peu différemment d'une règle explicite avec les lignes de commande.

* Si une règle explicite existe pour une cible avec des commandes, les seuls fichiers que la cible dépend sont ceux énumérés dans la règle explicite.

* Si une règle explicite n'a pas les commandes, les objectifs dépendent des fichiers données dans la règle explicite, et ils dépendent également de tout fichier correspond à une règle implicite pour la cible.

Voici quelques exemples de règles explicites d'un makefile:

  myutil.obj: myutil.asm
     tasm myutil.asm, myutil.obj;

  myapp.exe: myapp.pas myglobal.tpu myutils.tpu
     tpc myapp / Tc: \ TP5 \ bin

*La première règle explicite indique que MYUTIL.OBJ dépend MYUTIL.ASM, et que MYUTIL.OBJ est créé en exécutant la donnée commande TASM.

* La deuxième règle stipule que MYAPP.EXE dépend MYAPP.PAS, MYGLOBAL.TPU et MYUTILS.TPU, et est créé par le TPC donné commander.  (Le / T plus chemin nom dans ces exemples sera expliquée dans la suite)

Si vous réorganisez les règles afin que celui pour MYAPP.EXE vient en premier, suivi par les autres, make recompiler (ou réassembler) uniquement les fichiers qu'il doit afin de mettre à jour tout correctement. En effet, un MAKE sans cible sur la ligne de commande essaiera d'exécuter la première règle explicite qu'il trouve dans le makefile.

===Règles implicites===

Assurez-vous également vous permet de définir des règles implicites, qui sont des généralisations des règles explicites. Voici un exemple pour illustrer la relation entre les deux types. Considérez cette règle explicite du programme exemple précédent:

  myutil.obj: myutil.asm
     tasm myutil.asm, myutil.obj;

Cette règle est une commune, parce qu'il suit un principe général: Un fichier .OBJ dépend du fichier .ASM avec le même nom de fichier et est créé en exécutant TASM (Turbo Assember). En fait, vous pourriez avoir un makefile où vous avez plusieurs (ou même plusieurs dizaines) explicite les règles suivant ce même format.

En redéfinissant la règle explicite une règle implicite, vous pouvez éliminer toutes les règles explicites de la même forme. Comme une règle implicite, il ressemblerait à ceci:

  .asm.obj:
     tasm $ * EAM, de $ * obj..;

Cette règle signifie, "tout fichier se terminant par .OBJ dépend du fichier du même nom qui se termine dans .ASM, et le fichier .OBJ est créé en utilisant la commande

  tasm $ *. asm, $ *. obj

où $ * représente le nom du fichier sans extension. "(Le symbole $ * est une macro spéciale et est discuté dans la section suivante.)

La syntaxe d'une règle implicite suivante:

  .source_extension.target_extension:
     {commander}
     {commander}
     ...

Notez que les commandes sont facultatives et doivent être en retrait. Le source_extension (qui doit commencer en colonne 1) est l'extension du fichier source, qui est, il applique à tout fichier ayant le format

  fname.source_extension

De même, le target_extension se réfère au fichier

  fname.target_extension

où fname est le même pour les deux fichiers. En d'autres termes, cette règle implicite remplace toutes les règles explicites ayant le format

  fname.target_extension: fname.source_extension
     [commander]
     [commander]
     ...

pour tout fname.

Les règles implicites sont utilisées si aucune règle explicite pour une cible donnée peut être trouvée ou si une règle explicite avec aucune commande existe pour la cible.

L'extension du nom de fichier en question est utilisé pour déterminer quelle règle implicite à utiliser. La règle implicite est appliquée si un fichier est trouvé avec le même nom que la cible, mais avec l'extension de la source mentionnée. Par exemple, supposons que vous avez eu un makefile (nommé Makefile) dont le contenu était

  .asm.obj:
     tasm $ * EAM, de $ * obj..;

Si vous aviez une routine de langage assembleur nommé RATIO.ASM que vous vouliez compiler pour RATIO.OBJ, vous pouvez utiliser la commande

  faire ratio.obj

FAIRE prendrait RATIO.OBJ être la cible et créer en exécutant la commande:

  tasm ratio.asm, ratio.obj;

Les règles implicites sont également utilisés si une règle explicite est donnée à aucune commande. Supposons, comme mentionné précédemment, vous aviez la règle implicite suivante au début de votre makefile:

  .pas.tpu:
     tpc $ <

Vous pouvez ensuite réécrire certaines règles explicites comme suit:

  myglobal.tpu: myglobal.pas
   myutils.tpu: myutils.pas myglobal.tpu myutil.obj

Puisque vous ne disposez pas d'informations explicites sur la façon de créer ces fichiers .TPU, MAKE applique la règle implicite définie précédemment.

Plusieurs règles implicites peuvent être écrites avec la même extension de cible, mais une seule telle règle peut demander à la fois. Si plus d'une règle implicite existe pour une extension de cible donnée, chaque règle est vérifiée dans l'ordre les règles apparaissent dans le makefile, jusqu'à ce que toutes les règles applicables sont vérifiées.

MAKE utilise la première règle implicite qu'il découvre un fichier avec l'extension de la source. Même si les commandes de cette règle échouent, des règles plus implicites sont vérifiées.

Toutes les lignes suivantes une règle implicite sont considérés comme faisant partie de la liste de commande pour la règle, jusqu'à la ligne suivante qui commence sans espace ou à la fin du fichier. Les lignes vides sont ignorées. La syntaxe d'une ligne de commande est fournie plus loin dans cette annexe.

MAKE ne connaît pas le nom complet du fichier avec une règle implicite, comme il le fait avec des règles explicites. Pour cette raison, les macros spéciales sont fournies avec MAKE qui vous permettent d'inclure le nom du fichier en cours de construction par la règle.


  Listes de commandes

Les commandes dans une liste de commandes doivent être en retrait - qui est, précédée d'au moins un caractère ou un onglet d'espace - et prendre la forme

  [Prefix ...] command_body

Chaque ligne de commande dans une liste de commande se compose d'un (facultatif) liste des préfixes, suivi d'un corps de commandement unique.

Les préfixes autorisés dans une commande modifient le traitement de ces commandes par MAKE. Le préfixe est soit le au (@) signe ou un trait d'union (-) immédiatement suivi par un certain nombre.

  @ Maintient MAKE d'afficher la commande avant de l'exécuter.  le
       affichage est caché, même si l'option -s n'a pas été donnée sur la MAKE
       ligne de commande.  Ce préfixe applique uniquement à la commande sur laquelle elle
       apparaît.

  -num affecte la façon dont les codes traite de sortie FAIS.  Si un certain nombre (num) est
          fourni, puis faire sera interrompre le traitement que si l'état de sortie
          dépasse le nombre donné.  Dans cet exemple, MAKE annulerait seulement
          si l'état de sortie est supérieure à 4:

  -4 Myprog sample.x

  Si aucun préfixe -num est donnée, MAKE vérifie l'état de sortie pour le
          commander.  Si le statut est différent de zéro, MAKE va arrêter et supprimer le
          fichier cible en cours.

  - Avec un trait d'union, mais pas de numéro, MAKE ne sera pas vérifier l'état de sortie
       tout.  Indépendamment de ce que l'état de sortie était, MAKE continuera.

Le corps de la commande est traitée exactement comme si elle était entrée comme une ligne à COMMAND.COM, à l'exception que la redirection et les tuyaux ne sont pas pris en charge. MAKE exécute les commandes intégrées suivantes en invoquant une copie de COMMAND.COM pour les exécuter:

  BREAK CD CHDIR CLS COPY
   MD MKDIR PATH PROMPT REN
   RENAME SET TIME TYPE VER
   VÉRIFIER VOL

MAKE recherche pour tout autre nom de commande en utilisant l'algorithme de recherche MS-DOS:

  o Le répertoire courant est recherché en premier, suivi par chaque répertoire
     dans le chemin.

  o Dans chaque répertoire, d'abord un fichier avec l'extension .COM est cochée,
     puis un fichier .exe, et enfin un .BAT.

  o Si un fichier .BAT se trouve, une copie de COMMAND.COM est invoqué pour exécuter
     le fichier de commandes.


Cette commande fera MYPROG.PAS à être recherchées, en utilisant l'algorithme de recherche complète:

  tpc myprog.pas / $ B +, R +, I +


  Macros

Souvent, certaines commandes, les noms de fichiers, ou des options sont utilisés encore et encore dans votre makefile. Dans un exemple plus tôt dans la présente annexe, toutes les commandes de PTC utilisé le commutateur / Tc: \ TP5 \ bin, ce qui signifie que les fichiers TPC.CFG et TURBO.TPL sont dans le sous-répertoire C: \ TP5 \ BIN. Supposons que vous vouliez passer à un autre sous-répertoire pour ces fichiers; Qu'est-ce que tu ferais? Vous pouvez passer et modifier toutes les options / T, en insérant le nom de chemin approprié. Ou, vous pouvez définir une macro.

Une macro est un nom qui représente une certaine chaîne de caractères (lettres et chiffres). Une définition macro donne un nom de macro et le texte d'expansion; par la suite, lorsque MAKE rencontre le nom de la macro, il remplace le nom avec le texte d'expansion.

Supposons que vous avez défini la macro suivante au début de votre makefile:

  TURBO = c: \ TP5 \ bin

Vous avez défini la macro TURBO, ce qui équivaut à la chaîne c: \ TP5 \ bin. Vous pouvez maintenant réécrire le makefile comme suit:

  TURBO = c: \ TP5 \ bin
   myapp.exe: myapp.pas myglobal.tpu myutils.tpu
     tpc myapp / T $ (TURBO)

  myutils.tpu: myutils.pas myglobal.tpu myutil.obj
     myutils de tpc / T $ (TURBO)


Partout dans le répertoire Turbo est spécifié, vous utilisez la macro invocation $ (TURBO). Lorsque vous exécutez FAIS, $ (TURBO) est remplacé par le texte d'expansion, c: \ TP5.BIN. Le résultat est le même ensemble de commandes que vous aviez avant mais avec une plus grande flexibilité.

En fait, si vous laissez la première ligne tout à fait, vous pouvez spécifier le sous-répertoire que vous voulez à chaque fois que vous exécutez FAIS, en utilisant la -D (Définir) Option:

  faire -DTURBO = c: \ TP5 \ projet

définitions Macro prennent la forme

  macro_name = texte d'expansion

où macro_name est le nom d'une macro composée d'une chaîne de lettres et de chiffres sans espace en elle, même si vous pouvez avoir des espaces entre macro_name et le signe égal (=). [Texte d'extension] est une chaîne arbitraire contenant des lettres, des chiffres, des espaces et la ponctuation; il se termine par un retour chariot. Notez que les macros sont sensibles à la casse. Ainsi, les noms de macro Turbo, Turbo et TURBO sont tous différents.

Si macro_name a été préalablement définie, soit par une définition de macro dans le makefile ou par l'option -D sur la ligne de commande MAKE, la nouvelle définition remplace l'ancienne.

Les macros sont invoquées dans votre makefile avec le format

  $ (Macro_name)

Macros dans des macros: Macros ne peuvent pas être invoquées sur le (macro_name) côté gauche d'une définition de macro. Ils peuvent être utilisés sur le côté droit (texte d'extension), mais ils ne sont pas développées jusqu'à ce que la macro étant définie est invoquée. En d'autres termes, quand une macro invocation est étendu, toutes les macros intégrées dans son texte d'expansion sont également élargis.

FAIS est livré avec plusieurs macros prédéfinies spéciales intégré: $ d, $ *, $ <, $ :, $, et $ &.. La première est une macro de test défini, utilisé dans les directives conditionnelles si et elif!; les autres sont de noms de fichiers macros, utilisés dans des règles explicites et implicites. Les différents noms de fichiers macros fonctionnent de façon similaire, en élargissant à une certaine variation du nom de chemin complet du fichier en cours de construction. En outre, les chaînes d'environnement SET actuels sont automatiquement chargés comme des macros, et la macro __MAKE__ est définie à 1 (un).


  Macro d'essai définie ($ d)

Cette macro se développe à 1 si le nom de la macro donné est défini, ou à 0 si elle est pas. Le contenu du texte d'expansion de la macro n'a pas d'importance. Cette macro spéciale est autorisée uniquement dans! Directives si et! Elif. Par exemple, si vous vouliez modifier votre makefile afin qu'il utiliserait un répertoire particulier Turbo Pascal, si vous ne spécifiez pas un, vous pourriez mettre ceci au début de votre makefile:

  ! Si! $ D (TURBO) # si TURBO est pas défini
   TURBO = c: \ TP5 \ bin # définissent à C: \ TP5 \ BIN
  !fin si

Si vous appelez FAIRE avec la ligne de commande

  faire -DTURBO = c: \ TP5 \ projet

puis TURBO est défini comme c: \ TP5 \ projet. Toutefois, si vous venez invoquez MAKE par lui-même,

  faire

puis TURBO est défini comme c: \ TP5 \ bin, votre sous-répertoire "par défaut".


  Base de nom de fichier Macro ($ *)

Cette macro est autorisée dans les commandes pour une explicite ou une règle implicite. La macro se développe pour le nom du fichier en cours de construction, à l'exclusion de toute prolongation, comme ceci:

  Nom du fichier est A: \ P \ TESTFILE.PAS
   $ * Étend à A: \ P \ TESTFILE

Par exemple, vous pouvez modifier la règle MYAPP.EXE explicite déjà donné à ressembler à ceci:

  myapp.exe: myapp.pas myglobal.tpu myutils.tpu
     tpc $ * / T $ (TURBO)


  Nom complet du fichier Macro ($ <)

Le nom complet du fichier macro ($ <) est également utilisé dans les commandes d'une règle explicite ou implicite. Dans une règle explicite, $ <élargit le nom complet du fichier cible (y compris l'extension), comme ceci:

  Nom du fichier est A: \ P \ TESTFILE.PAS
   $ <Étend à A: \ P \ TESTFILE.PAS

Dans une règle implicite, $ <prend le nom du fichier ainsi que l'extension de la source. Par exemple, la règle implicite précédente

  .asm.obj:
     tasm $ * EAM, de $ * obj..;

peut être réécrite comme

  .asm.obj:
      tasm $ <, $ * obj.


  Nom du fichier Chemin Macro ($ :)

Cette macro se développe pour le chemin d'accès (sans le nom de fichier), comme ceci:

  Nom du fichier est A: \ P \ TESTFILE.PAS
   $: Étend à A: \ P \


  Nom de fichier et Macro Extension ($).

Cette macro se développe pour le nom du fichier, avec l'extension, comme ceci:

  Nom du fichier est A: \ P \ TESTFILE.PAS
   $.  étend à TESTFILE.PAS


  File Name Only Macro ($ &)

Cette macro se développe pour le nom de fichier uniquement, sans chemin d'accès ou l'extension, comme ceci:

  Nom du fichier est A: \ P \ TESTFILE.PAS
   $ Et étend à TESTFILE


  directives

La version de MAKE livré avec Turbo Pascal permet quelque chose que les autres versions de MAKE ne le font pas: directives conditionnelles semblable à ceux autorisés pour Turbo Pascal. Vous pouvez utiliser ces directives pour inclure d'autres makefiles, de rendre les règles et les commandes conditionnelles, pour imprimer les messages d'erreur, et à des macros "UNDEFINE".

Directives dans un makefile commencent par un point d'exclamation (!). Voici la liste complète des directives de MAKE:

   !comprendre
  !si
  !autre
  ! elif
  !fin si
  !Erreur
  ! undef

Une directive fichier-inclusion (! Include) spécifie un fichier à inclure dans le makefile pour l'interprétation au point de la directive. Il prend la forme suivante:

  ! Include "filename"

ou

  ! Include <filename>

Ces directives peuvent être imbriquées arbitrairement profonde. Si une directive include tente d'inclure un fichier qui a déjà été inclus dans un certain niveau externe de nidification (de sorte qu'une boucle de nidification est sur le point de commencer), y compris la directive interne est rejetée comme une erreur.

Les directives conditionnelles (! si! elif,! d'autre, et! endif) donner un programmeur une certaine souplesse dans la construction makefiles. Règles et macros peuvent être "conditionalized" de telle sorte que la définition de ligne de commande macro (en utilisant l'option -D) peut activer ou désactiver les sections du makefile.

Le format de ces directives parallèles, mais est plus étendue que, les directives conditionnelles permises par Turbo Pascal:

  ! Si l'expression
     [ lignes ]
  !fin si

  ! Si l'expression
     [ lignes ]
  !autre
     [ lignes ]
  !fin si

  ! Si l'expression
     [ lignes ]
  ! Elif expression
     [ lignes ]
  !fin si

Les directives conditionnelles forment un groupe, avec au moins un! Si directive commençant le groupe et une directive endif! Fermer le groupe.

L'expression a permis dans un! Si ou un! Elif directive utilise une syntaxe similaire à celle trouvée dans le langage de programmation C. L'expression est évaluée comme un entier signé expression simple 32 bits.

Les nombres peuvent être entrés en décimal, octal ou hexadécimal constantes. Par exemple, ceux-ci sont des constantes juridiques dans une expression:

  4536 # décimal constant
   0677 constant # octal (notez le zéro)
   0x23aF # constante hexadécimale

et l'un des opérateurs unaires suivants:

  - négation
   ~ Bit complément
  !  pas logique

Une expression peut utiliser l'un des opérateurs binaires suivants:

  + addition
   - soustraction
   * multiplication
   / division
  % restant
   >> Décalage à droite
   << Décalage à gauche
   & Bitwise et
   |  ou binaire
   ^ OR exclusif ou
   && Logique et
   ||  logique ou
   > Supérieur
   <Inférieur à
   > = Supérieur ou égal à
   <= Inférieur ou égal à
   == égalité
  ! = Inégalité

Une expression peut contenir l'opérateur ternaire suivant:

  ?  : L'opérande avant?  est traité comme un test.

  Si la valeur de cet opérande est non nul, alors la seconde
         opérande (la partie entre le? et le côlon) est le
         résultat.  Si la valeur du premier opérande est égal à zéro, la
         La valeur du résultat est la valeur du troisième opérande
         (La partie après le :).

Les parenthèses peuvent être utilisées pour des opérandes de groupe dans une expression. En l'absence de parenthèses, les opérateurs binaires sont regroupés en fonction de la même priorité donnée dans la langue de C.

Le regroupement est de gauche à droite pour les opérateurs de même priorité, à l'exception de l'opérateur ternaire (? :), Ce qui est de droite à gauche.

Les macros peuvent être invoquées dans une expression, et la macro $ d spéciale () est reconnu. Après toutes les macros ont été élargies, l'expression doit avoir la syntaxe correcte. Tous les mots dans l'expression élargie sont traités comme des erreurs.

La directive d'erreur (Erreur) les causes MAKE pour arrêter et imprimer un fatal diagnostic contenant le texte après erreur!. Il prend le format

  Erreur [any_text]

Cette directive est conçue pour être inclus dans les directives conditionnelles pour permettre à une condition d'interruption définie par l'utilisateur.

La directive undefine (! Undef) provoque une définition de la macro appelée à être oublié. Si la macro est actuellement undefined, cette directive n'a pas d'effet.

  Utilisation FAIRE

==

Vous savez maintenant beaucoup de choses sur la façon d'écrire makefiles; est maintenant le temps d'apprendre comment les utiliser avec MAKE. La façon la plus simple d'utiliser MAKE est de taper la commande

  FAIRE

à l'invite MS-DOS. FAIRE puis recherche MAKEFILE; si elle ne peut le trouver, il cherche MAKEFILE.MAK; si elle ne peut pas trouver cela, il arrête avec un message d'erreur.

Vous pouvez spécifier un fichier avec l'option -f:

  FAIRE -fstars.mak

La syntaxe générale pour MAKE est

  faire l'option cible l'option ... cible ...

où option est une option MAKE (voir plus loin) et la cible est le nom d'un fichier cible à traiter par des règles explicites.

Si la ligne de commande ne comprend pas les noms de cible, MAKE utilise le premier fichier cible mentionné dans une règle explicite. Si une ou plusieurs cibles sont mentionnés sur la ligne de commande, ils seront construits selon les besoins.

Voici quelques exemples de lignes de commande MAKE:

  faire -fstars.mak -n
   fait du
   faire -DTURBO -Iinclude = c: \ TP5 \ projet


  Le fichier BUILTINS.MAK

Comme vous familiariser avec MAKE, vous trouverez qu'il ya des macros et des règles (généralement des implicites) que vous utilisez encore et encore. Vous avez trois façons de les manipuler. D'abord, vous pouvez les mettre dans chaque makefile vous créez. Deuxièmement, vous pouvez les mettre tous dans un seul fichier et utiliser le! Inclut directive dans chaque Makefile vous créez. Troisièmement, vous pouvez les mettre tous dans un fichier nommé BUILTINS.MAK.

Chaque fois que vous exécutez MAKE, il recherche un fichier nommé BUILTINS.MAK; si elle trouve le fichier, MAKE le lit avant MAKEFILE manutention (ou le Makefile que vous voulez qu'il traite).

Le fichier BUILTINS.MAK est destiné à toutes les règles (généralement des règles implicites) ou des macros qui seront couramment utilisés dans les fichiers partout sur votre ordinateur.

Il n'y a aucune exigence que tout fichier BUILTINS.MAK existe. Si MAKE trouve un fichier BUILTINS.MAK, il interprète ce fichier en premier. Si MAKE ne peut pas trouver un fichier BUILTINS.MAK, il passe directement à interpréter MAKEFILE (ou quoi que makefile vous spécifiez).


  Comment faire des recherches pour les fichiers

FAIS recherchera BUILTINS.MAK dans le répertoire courant ou dans le répertoire exec si votre ordinateur fonctionne sous DOS 3.x. Vous devez placer ce fichier dans le même répertoire que le fichier MAKE.EXE.

FAIRE toujours recherches pour le makefile dans le répertoire en cours. Ce fichier contient les règles pour le fichier de programme exécutable particulier en cours de construction. Les deux fichiers ont des règles de syntaxe identiques.

FAIRE également des recherches pour tout! Inclure des fichiers dans le répertoire courant. Si vous utilisez le -I (Inclure) option, il sera également rechercher dans le répertoire spécifié.


  Faire des options de ligne de commande

  -Didentifier Définit l'identificateur nommé à la chaîne consistant en
                  le caractère unique 1.

  -Diden = Chaîne Définit l'iden identificateur nommé à la chaîne après
                  le signe égal.  La chaîne ne peut pas contenir d'espaces ou
                  onglets.

  MAKE -Idirectory va rechercher les fichiers à inclure dans l'indication
                  répertoire (ainsi que dans le répertoire courant).

  -Uidentifier Annule la définition des définitions précédentes du nom
                  identifiant.

  -s Normalement, FAIS imprime chaque commande car il est sur le point d'être
                  réalisé.  Avec l'option -s, pas de commandes sont imprimées
                  avant l'exécution.

  Causes -n MAKE pour imprimer les commandes, mais pas réellement
                  les exécuter.  Ceci est utile pour le débogage d'un makefile.

  -fnom de fichier Utilise le nom de fichier que le fichier MAKE.  Si le nom de fichier ne
                  existe et aucune extension est donnée, tente filename.MAK.

  -?  ou -h message d'aide.


  FAIRE Messages d'erreur

  Erreurs fatales

Je ne sais pas comment faire XXXXXXXX

  Ce message est émis lorsque MAKE rencontre un nom de fichier inexistant dans
   la séquence de construction, et aucune règle existe qui permettrait le nom de fichier
   être construit.

Erreur de directive: XXXX

  Ce message est émis lorsque MAKE traite une directive #error dans le
   fichier source.  Le texte de la directive est affiché dans le message.

Mauvaise argument de ligne de commande: XXX

  Cette erreur se produit si MAKE est exécuté avec incorrect en ligne de commande
   arguments.

Pas assez de mémoire

  Cette erreur se produit lorsque le stockage de travail total a été épuisé.  Toi
   devrait essayer ceci sur une machine avec plus de mémoire.  Si vous avez déjà 640K
   dans votre machine, vous pouvez avoir à simplifier le fichier source.

Impossible de commande d'exécution

  Ce message est émis après avoir tenté d'exécuter une commande.  cela pourrait
   être le résultat du fichier de commande ne sont pas trouvés, ou parce qu'il était
   mal orthographié.  Une possibilité moins probable est que la commande existe mais est
   en quelque sorte corrompu.

Impossible d'ouvrir le fichier makefile

  Ce message est émis lorsque le répertoire courant ne contient pas de
   fichier makefile nommé.


  les erreurs

Bad format de nom de fichier dans include

  Inclure les noms de fichiers doivent être entourés par des guillemets ou des crochets.  le
   nom de fichier était manquant la citation d'ouverture ou équerre.

syntaxe de l'instruction undef Bad

  Une déclaration undef! Doit contenir un identifiant unique et rien d'autre que
   le corps de la déclaration.

constante de caractères trop longue

  constantes de caractères peuvent être seulement un ou deux caractères.

Les arguments de commande trop long

  Les arguments d'une commande exécutée par MAKE étaient plus de 127
   caractères - une limite imposée par DOS.

erreur de syntaxe de commande

  Ce message se produit si

  o la première ligne de la règle du makefile contenait tout premier plan
        des espaces.

  o une règle implicite ne consistait pas en .ext.ext :.

  o une règle explicite ne contenait pas un nom avant le caractère:.

  oa macro définition ne contient pas de nom avant le caractère =.

Division par zéro

  Une fracture ou reste dans une! If a un diviseur de zéro.

Expression erreur de syntaxe dans! If

  L'expression dans une instruction if est mal formé - il contient un
   parenthèses correspondent pas, un opérateur supplémentaire ou manquant, ou d'un manque ou
   constante supplémentaire.

Nom de fichier trop long

  Le nom de fichier donné dans un! Inclut directive était trop long pour MAKE à
   processus.  noms de chemin du fichier dans MS-DOS ne doivent pas être plus de 78 caractères
   longue.

caractère illicite de la constante expression X

  FAIS rencontré un certain caractère non autorisé dans une expression constante.  Si
   le caractère est une lettre, cela indique un (probablement) mal orthographié
   identifiant.

chiffres octal illégal

  Une constante octale a été trouvé contenant un chiffre 8 ou 9.

l'expansion macro trop long

  Une macro ne peut pas étendre à plus de 4096 caractères.  Cette erreur souvent
   se produit si une macro se développe de manière récursive.  Une macro ne peut pas légalement
   étendre à lui-même.

Déclaration de elif Misplaced

  Une! Directive elif a été rencontrée sans correspondance! Si directive.

else Misplaced

  Une! Else directive a été rencontrée sans correspondance! Si directive.

instruction endif Misplaced

  Une directive endif! A été rencontrée sans correspondance! Si directive.

Aucun nom de fichier se terminant

  Le nom de fichier dans une instruction include manquait la bonne fermeture
   devis ou équerre.

Redéfinition de la cible XXXXXXXX

  Le fichier nommé se produit sur le côté gauche de plus d'un explicite
   Règle.

Impossible d'ouvrir le fichier include XXXXXXXXX.XXX

  Le fichier nommé n'a pu être trouvée.  Cela pourrait aussi être causé si un
   inclure fichier lui-même inclus.  Vérifiez si le fichier nommé existe.

Fin de fichier inattendue dans conditionnelle a commencé sur la ligne #

Le fichier source terminée avant MAKE rencontré une! Endif. Le endif! Était
  soit manquant ou mal orthographié.

Inconnu déclaration préprocesseur

UNE ! le caractère a été rencontré au début d'une ligne, et
  Nom de l'instruction suivante n'a pas été l'erreur, undef, si, elif, comprend, d'autre,
  ou endif.

==L'utilitaire TOUCH==

Il y a des moments où vous voulez forcer un fichier cible particulier être recompilés ou reconstruites, même si aucune modification n'a été apportée à ses sources. Une façon de le faire est d'utiliser l'utilitaire TOUCH inclus avec Turbo Pascal. TOUCH change la date et l'heure d'un ou plusieurs fichiers à la date et l'heure actuelle, ce qui rend "plus récent" que les fichiers qui en dépendent.

Pour forcer un fichier cible à reconstruire, "toucher" l'un des fichiers qui cible dépend. Pour toucher un fichier (ou fichiers), entrez

 toucher filename [nom de fichier ...]

à l'invite DOS. TOUCH mettra alors à jour la date de création du fichier (s).

Une fois que vous faites cela, vous pouvez appeler MAKE pour reconstruire le fichier cible touché (s).

==L'utilitaire GREP==

GREP est un utilitaire de recherche puissant qui peut rechercher du texte dans plusieurs fichiers à la fois.

La syntaxe de ligne de commande pour GREP suit:

 GREP [options] searchstring [filespec ...]

où les options se compose d'un ou plusieurs caractères simples précédés d'un trait d'union, searchstring définit le motif à rechercher, et filespec est la spécification de fichier. filespec dit GREP quels fichiers (ou groupes de fichiers) à la recherche; il peut être un nom de fichier explicite ou un nom de fichier générique intégrant les wildcards DOS (? et *). Vous pouvez également entrer un chemin dans le cadre de filespec; si vous utilisez filespec sans chemin, GREP recherche uniquement le répertoire en cours. Si vous ne spécifiez pas filespec, entrée GREP doit être spécifié en redirigeant stdin ou de la tuyauterie.


 Les commutateurs GREP

=======

Dans la ligne de commande, les options sont un ou plusieurs caractères simples précédés par un tiret (-). Chaque caractère individuel est un interrupteur que vous pouvez activer ou désactiver: tapez le symbole plus (+) après un caractère pour activer l'option, ou tapez un trait d'union (-) après le caractère à désactiver l'option.

La valeur par défaut est activé (+ est implicite): par exemple, -R signifie la même chose que -R +. Vous pouvez lister plusieurs options individuellement comme ceci: -I -D -L). Ou vous pouvez les combiner comme ceci: -ILD ou -IL -D, et ainsi de suite). Il est tout de même à GREP.

Voici une liste des commutateurs et leurs significations:

 -C Count seulement: Seulement un nombre de lignes correspondant est imprimé.  Pour chaque
       fichier qui contient au moins une ligne de correspondance, GREP imprime le fichier
       nom et un décompte du nombre de lignes correspondant. Les lignes correspondantes
       ne sont pas imprimés.

 Annuaires -D: Pour chaque filespec spécifié sur la ligne de commande, GREP
       recherches pour tous les fichiers qui correspondent à la spécification de fichier, à la fois dans
       le répertoire spécifié et dans tous les sous-répertoires du
       répertoire spécifié. Si vous donnez un filespec sans chemin, GREP
       suppose que les fichiers sont dans le répertoire courant.

 -I Ignorer la casse: GREP ignore les différences supérieures / minuscules (cas
       pliant). GREP traite toutes les lettres az comme étant identique à la
       lettres correspondantes AZ dans toutes les situations.

 Liste -L fichiers match: Seul le nom de chaque fichier contenant une correspondance est
        imprimé. Après GREP trouve une correspondance, il imprime le nom du fichier et
       le traitement se déplace immédiatement sur le fichier suivant.

 Numbers -N: Chaque ligne de correspondance qui imprime GREP est précédée par sa
       numéro de ligne.

   format de sortie -O UNIX: Change le format de sortie de correspondance des lignes pour supporter plus facilement le style UNIX de la tuyauterie de ligne de commande.  Toutes les lignes de sortie sont précédés par le nom du fichier qui contenait la ligne correspondante. 

  -R Recherche d'expression régulière: Le texte défini par searchstring est
        traité comme une expression régulière plutôt que comme une chaîne littérale.

  -U Options de mise à jour: GREP combineront les options données sur la commande
        ligne avec ses options par défaut et les écrire dans le fichier GREP.COM
        que les nouveaux paramètres par défaut.  (En d'autres termes, GREP est auto-configuration.)
        Cette option vous permet d'adapter les paramètres de l'option par défaut
        votre propre goût.

  -V Non-correspondance: Seules les lignes non correspondantes sont imprimées.  Seules les lignes qui font
        pas contenir la chaîne de recherche sont considérés comme non-appariement
        lignes.

  -W Recherche par mot: Texte trouvé qui correspond à l'expression régulière sera
        être considéré comme un match que si le caractère immédiatement précédent
        et à la suite ne peut pas faire partie d'un mot.  Le caractère de texte par défaut
        ensemble comprend AZ, 9-0, et le soulignement (_).  Une autre forme de
        cette option vous permet de spécifier le jeu de caractères juridiques de mots.
        Sa forme est -W [set], où ensemble est un ensemble régulier valide d'expression
        définition.  Si les caractères alphabétiques sont utilisés pour définir l'ensemble,
        l'ensemble sera automatiquement défini pour contenir à la fois la partie supérieure et
        minuscules valeurs pour chaque lettre dans l'ensemble, quelle que soit la façon dont il
        est tapé, même si la recherche est sensible à la casse.  Si l'option -W est
        utilisé en combinaison avec l'option -U, la nouvelle série de juridique
        caractères est enregistré comme le jeu par défaut.

  -Z Verbose: GREP imprime le nom du fichier de chaque fichier recherché.  Chaque
        ligne correspondante est précédée par son numéro de ligne.  Un compte de correspondance
        lignes dans chaque fichier est donné, même si le nombre est égal à zéro.

Plusieurs de ces options sont en conflit direct avec l'autre. Dans ces cas, l'ordre suivant applique (la première est celle qui a priorité):

  -Z -L -C -N

Chaque apparition d'une option remplace la définition précédente: Son état reflète la façon dont vous définissez dernière. À un moment donné, chaque option ne peut être activée ou désactivée.

Vous pouvez installer votre réglage par défaut préféré pour chaque option dans GREP.COM avec l'option -U. Par exemple, si vous voulez GREP toujours faire une recherche détaillée (-Z), vous pouvez l'installer avec la commande suivante:

  GREP -U -Z


  Comment faire une recherche utilisant GREP

La valeur de searchstring définit le motif GREP va rechercher. Une chaîne de recherche peut être un (via le commutateur -R) ou une chaîne littérale. Dans les expressions régulières, les opérateurs régissent la recherche; chaînes littérales ont pas d'opérateurs.

Vous pouvez joindre la chaîne de recherche entre guillemets pour éviter les espaces et les onglets d'être traités comme des délimiteurs. Matches ne franchissent pas les limites de ligne (un match doit être contenu dans une seule ligne).

Lorsque le commutateur -R est utilisé, la chaîne de recherche est traitée comme une expression régulière (par opposition à une expression littérale), et les symboles suivants prennent des significations particulières:

  ^ Un caret au début de l'expression correspond au début
       d'une ligne.

  $ Un signe dollar à la fin de l'expression correspond à la fin
       d'une ligne.

  .  Une période correspond à tout caractère.

  * Une expression suivie d'un caractère générique astérisque correspond
       zéro ou plusieurs occurrences de cette expression: fo * matchs
       f, fo, foo, etc.

  + Une expression suivie d'un signe plus correspond à une ou plusieurs
       occurrences de cette expression: fo + correspond à fo, foo, etc.,
       mais pas f.

  [] Une chaîne entre crochets correspond à tout caractère dans
       cette chaîne, mais pas d'autres.  Si le premier caractère de la
       chaîne est un caret (^), l'expression correspond à tout
       caractère sauf les caractères de la chaîne.  Pour
       par exemple, [xyz] correspond à x, y et z, tandis que [^ xyz] correspond à un
       et b, mais pas x ou y.  Une gamme de caractères peut être
       spécifié par deux caractères séparés par un tiret (-).
       Ceux-ci peuvent être combinés pour former des expressions telles que [? A-ld-z]
       correspondre ?  et toute lettre, sauf c.

  \ La barre oblique inverse "caractère d'échappement" dit GREP à seach pour
       le caractère littéral qui le suit.  Par exemple, \.
       correspond à une période au lieu de caractère.

  Remarque: Quatre caractères (, +, * et?.) Ne pas avoir de spécial
   ce qui signifie quand il est utilisé dans un ensemble.  Le caractère ^ est traité seulement
   spécialement si elle suit immédiatement le début de l'ensemble
   (Qui est, immédiatement après le [).

Tout caractère ordinaire ne sont pas mentionnés dans cette liste correspond à ce caractère. Une concaténation d'expressions régulières est une expression régulière.


  Exemples d'utilisation GREP

Les exemples suivants supposent toutes les options par défaut désactivée.

Recherche cordes grep dirdemo.pas fonction -n

Trouve DIRDEMO.PAS du fichier:

  46 LessFunc = function (X, Y: DirPtr): Boolean;
            55 fonction NumStr (N, D: Integer): string;
            68 fonction LessName (X, Y: DirPtr): Boolean;
            73 fonction LessSize (X, Y: DirPtr): Boolean;
            78 fonction LessTime (X, Y: DirPtr): Boolean;

Remarques Constate toutes les fonctions dans le fichier DIRDEMO.PAS. Puis

  raconte GREP de faire précéder chaque ligne en correspondance avec sa ligne
            nombre.

Chaîne de recherche grep {$ \ dirdemo.pas

Trouve DIRDEMO.PAS du fichier:

  {$ I, S}
            {$ M 8192,8192,655360}
            {$ F +}
            {$ F-}

Remarques Trouve toutes les directives du compilateur dans DIRDEMO.PAS. Le \

  (Backslash) précédant le $ est nécessaire.  Sans ça,
            le $ indiquerait la fin de la ligne.  toutes les lignées
            avec {(accolade) comme le dernier caractère serait
            correspondre à ce modèle et être imprimé.

Chaîne de recherche grep -i "^ * fonction. *). * Vrai" * .pas

Trouve MCPARSER.PAS du fichier:

  fonction CellValue (Col, Rangée: Word): Real;
            fonction Parse (S: string; var Att: Word): Real;

Remarques Trouve toutes les lignes qui commencent par zéro ou plusieurs espaces

  suivi de la fonction de mot, suivi d'une chaîne
            de zéro ou plusieurs caractères, suivie d'une
            entre parenthèses, suivie d'une autre chaîne de zéro ou
            plusieurs caractères, suivi par le mot réel, et
            ignore le cas.  L'effet net est à la recherche de tous les
            fonctions renvoyant un réel.  Voyez si vous pouvez penser
            d'autres façons de le faire.

  Les guillemets doubles sont nécessaires en raison de l'espace
            dans la chaîne de motif.  Les citations disent DOS
            processeur de ligne de commande pour traiter l'intervenant
            personnages comme un seul argument.  Sans les citations,
            DOS pense que la chaîne de recherche est en fait deux
            arguments et GREP vont penser que tout ce qui suit
            ^ (Le caractère caret) fait référence aux noms de fichiers, et
            se plaignent

  Aucun correspondant: * FONCTION *) *...


==L'utilitaire BINOBJ==

Un programme utilitaire appelé BINOBJ.EXE a été ajouté pour convertir un fichier binaire (.BIN) en un fichier .OBJ de sorte qu'il peut être lié à un programme Turbo Pascal comme une «procédure». Ceci est utile si vous avez un fichier de données binaires qui doivent résider dans le segment de code ou est trop grand pour en faire un tableau de constantes typées. Par exemple, vous pouvez utiliser BINOBJ avec l'unité graphique pour lier le pilote graphique ou des fichiers de polices directement dans votre fichier .EXE. Ensuite, pour utiliser votre programme graphique, vous devez avoir seulement le fichier .EXE (voir l'exemple BGILINK.PAS).

BINOBJ comporte trois paramètres:

  BINOBJ <source [.BIN]> <destination [.OBJ]> <nom public>

où source est le fichier binaire pour convertir, la destination est le nom de l'OBJ à produire, et le nom public est le nom de la procédure telle qu'elle sera déclarée dans votre programme Turbo Pascal.

L'exemple suivant, la procédure Showscreen, prend un pointeur comme paramètre et déplace 4000 octets de données à la mémoire de l'écran. Le fichier appelé MENU.DTA contient l'image de l'écran du menu principal (80 * 25 * 2 = 4000 octets).

Voici une version simple (pas de contrôle d'erreur) de MYPROG.PAS:

  programme monprog;

  procédure Showscreen (var ScreenData: Pointer);
   {Affiche un plein écran des données - pas de contrôle d'erreur!  }
   var
     ScreenSegment: Word;

  commencer
     if (Lo (LastMode) = 7) alors {Mono?  }
       ScreenSegment: = $ B000
     autre
       ScreenSegment: = $ B800;
     Déplacer (@ ^ ScreenData ^, {} De pointeur
      Ptr (ScreenSegment, 0) ^, {Pour mémoire vidéo}
      4000);  {80 * 25 * 2}
   fin;

  var
     MenuP: Pointer;
     MenuF: fichier;
   commencer
     Attribuer (MenuF, 'MENU.DTA');  {Ouvrir fichier de données d'écran}
     Reset (MenuF, 1);
     GetMem (MenuP, 4000);  {Allouer tampon sur tas}
     BlockRead (MenuF, MenuP ^, 4000);  {Lire les données d'écran}
     Fermer (MenuF);
     Showscreen (MenuP);  { Écran d'affichage }
   fin.

Le fichier de données de l'écran (MENU.DTA) est ouvert et ensuite lu dans une mémoire tampon sur le tas. Les deux monprog.exe et MENU.DTA doivent être présents au moment de l'exécution de ce programme fonctionne. Vous pouvez utiliser BINOBJ pour convertir MENU.DTA un fichier .OBJ (MENUDTA.OBJ) et lui dire d'associer les données avec une procédure appelée MenuData. Ensuite, vous pouvez déclarer la procédure externe faux MenuData, qui contient en fait les données d'écran. Une fois que vous liez dans le fichier .OBJ avec la directive de compilation $ L, MenuData sera 4000 octets de long et contiennent vos données d'écran. Tout d'abord, exécutez BINOBJ sur MENU.DTA:

  binobj MENU.DTA MENUDTA MenuData

Le premier paramètre, MENU.DTA, montre un fichier familier de données d'écran; le second, MENUDTA, est le nom du fichier .OBJ à créer (puisque vous ne spécifiez pas une extension, OBJ sera ajouté). Le dernier paramètre, MenuData, est le nom de la procédure externe comme il sera déclaré dans votre progam. Maintenant que vous avez converti MENU.DTA à un fichier .OBJ, voici ce que la nouvelle MYPROG.PAS ressemble:

  programme monprog;

  procédure Showscreen (ScreenData: Pointer);
   {Affiche un plein écran des données - aucune vérification d'erreur!  }
   var
     ScreenSegment: Word;
   commencer
     if (Lo (LastMode) = 7) alors {Mono?  }
       ScreenSegment: = $ B000
     autre
       ScreenSegment: = $ B800;
     Déplacer (@ ^ ScreenData ^, {} De pointeur
      Ptr (ScreenSegment, 0) ^, {Pour mémoire vidéo}
      4000);  {80 * 25 * 2}
   fin;

  procédure MenuData;  externe;
   {$ L MENUDTA.OBJ}
   commencer
     Showscreen (@MenuData);  { Écran d'affichage }
   fin.

Notez que Showscreen n'a pas changé du tout, et que l'adresse de votre procédure est passée en utilisant l'opérateur @.