Travail pratique #2--Énoncé

Ce qui suit constitue l'énoncé du travail pratique #2 (TP2).

Note: vous trouverez du support supplémentaire à travers les liens disponibles dans la section Important, tout en haut de ce document.

Contraintes générales à respecter

Étant donné le programme principal suivant (disponible sur le site du cours, sous le nom de "TP2.cpp" dans l'archive "TP2.zip"): 


#include <iostream.h>
#include "Clavier.h"

int main ()
{
   bool Termine;
   char c;

   Termine = false;

   cout << endl << "Appuyez sur ESC pour terminer..." << endl;
   while (!Termine)
   {
      if (Clavier_Tester_Statut ()) // un caractere a lire
      {
         c = Clavier_Lire_Sans_Echo ();
         if (c == CHAR_ECHAP)
         {
            Termine = true;
         }
         else
         {
            Ecran_Echo (c);
         }
      }
   }
   cout << endl << "Au revoir!" << endl;
} // main ()

ainsi que le fichier d'en-tête suivant (aussi disponible sur le site du cours, sous le nom de "Clavier.h" dans l'archive "TP2.zip"): 


#ifndef CLAVIER_H
#define CLAVIER_H

const char CHAR_ECHAP = 27; // ESC
typedef enum
{
   true = -1, false
}
bool;

// Les fonctions d'entree/ sortie a utiliser
const int FCT_ECRAN_SORTIE_CARACTERE   = 0x02
,         FCT_CLAVIER_ENTREE_SANS_ECHO = 0x08
,         FCT_CLAVIER_TEST_STATUT      = 0x0b
;

// Fonction: Clavier_Lire_Sans_Echo ()
// Lit un caractere du clavier sans envoyer d'echo a l'ecran
// a l'aide de la fonction FCT_CLAVIER_ENTREE_SANS_ECHO de
// l'interrupt 21h. Retourne le caractere lu.
char Clavier_Lire_Sans_Echo ();

// Fonction: Clavier_Tester_Statut ()
// Verifie a l'aide de la fonction FCT_CLAVIER_TEST_STATUT de
// l'interrupt 21h s'il y a un caractere dans le tampon du
// clavier. Retourne true s'il y en a effectivement un, et
// false sinon.
bool Clavier_Tester_Statut ();

// Procedure: Ecran_Echo
// Prend en parametre un caractere, et en fait echo a l'ecran
// a l'aide de la fonction FCT_ECRAN_SORTIE_CARACTERE de
// l'interrupt 21h.
void Ecran_Echo (char c);
#endif // !defined CLAVIER_H

Vous devrez, à l'aide de Borland C 3.1 (BC3.1):

  • créer un projet dans lequel vous inclurez "TP2.cpp". Ce fichier ne pourra en aucun temps être modifié (il en va de même pour le fichier "Clavier.h");
  • créer le fichier source "Clavier.cpp" qui implantera au minimum les sous-programmes "Ecran_Echo()", "Clavier_Lire_Sans_Echo()" et "Clavier_Tester_Statut()";
  • intégrer le fichier source "Clavier.cpp" à votre projet;
  • vous assurer que le tout compile bien et s'exécute correctement.

    • Vous trouverez aussi dans l'archive "TP2.zip" deux (2) exécutables, soit "TP2v1.exe" et "TP2v2.exe".

    Le programme "TP2v1.exe" est le résultat attendu de votre TP2 (s'il fonctionne, c'est là précisément l'exécution à laquelle nous sommes en droit de nous attendre).

    Le programme "TP2v2.exe" est un résultat plus élaboré (il traite correctement le "backspace" et le "return"). Des points boni--en petite quantité, mais quand même...-- vous seront attribués si vous parvenez à ce résultat en n'altérant ni "TP2.cpp", ni "Clavier.h", dans la mesure où votre solution est jugée élégante.

    Détail de l'énoncé

    Le travail consiste à implanter trois (3) sous-programmes permettrant des entrées au clavier et des sorties à la console à l'aide de fonctions des services d'interruption du DOS.

    Ces sous-programmes respecteront les prototypes donnés par "Clavier.h" (en fait, "Clavier.cpp" devrait inclure "Clavier.h").

    Les fonctions des services d'interruption du DOS...

    Chaque sous-programme devra faire appel à une fonction du service d'interruption 21h. Vous devrez include le fichier d'en-tête "dos.h" et faire usage de la fonction "intdos()" de même qu'au type "union REGS".

    Note: au besoin, n'hésitez pas à faire usage de l'aide en ligne de BC3.1.

    Dans tous les cas, vous devrez:

  • déclarer une (ou deux) variable(s) du type "union REGS";
  • déposer le numéro de la fonction dans le membre de votre variable qui représentera le registre "ah" en entrée;
  • déposer toute autre valeur pertinente dans les membres de cette même variable qui représentent les registres appropriés (selon la fonction utilisée--voir plus bas);
  • appeler la fonction "intdos()";
  • utiliser les valeurs appropriées dans les membres de la variable représentant les registres en sortie pour décoder le résultat de l'interruption.

    • Sortie de caractère à l'écran (fonction 02h)

    Cette fonction envoie un caractère en sortie à la console (à l'écran). Le caractère écrit sera celui dont le code ASCII se trouve le registre "DL" au moment de l'interruption.

    Note:

    ne traitez pas la tabulation (le TAB, ou '\t') de manière spéciale. Cela demanderait trop de temps pour trop peu d'acquis.

    Par défaut, le "backspace" ('\b') recule le curseur sans effacer le caractère qui précède. De même, par défaut, la touche "return" revient au début de la ligne courante sans changer de ligne.

    Entrée de caractère sans écho (fonction 08h)

    Cette fonction lit un caractère au clavier sans en faire l'écho à l'écran. On trouvera le code ASCII du caractère lu dans le registre "AL" après l'interruption.

    Test du statut du clavier (fonction 0bh)

    Cette fonction vérifie la présence d'un caractère au clavier. S'il y en a effectivement un de disponible, le registre "AL" contiendra "0xff" après l'interruption. S'il n'y en a aucun de disponible, le registre "AL" contiendra "0x00" après l'interruption.

    Bonne chance!