home *** CD-ROM | disk | FTP | other *** search
/ DP Tool Club 25 / CD_ASCQ_25_1095.iso / dos / prg / emsutil / ems.txt < prev    next >
Text File  |  1995-08-29  |  30KB  |  809 lines
  1.  
  2.  
  3.   █▀▀▀▀ █▀▄ ▄▀█  ▄▀▀▀▀     █   █  ▀▀█▀▀  █  █      █  ▀▀█▀▀  █  █▀▀▀▀  ▄▀▀▀▀
  4.   █▄▄▄  █  ▀  █  ▀▄▄▄      █   █    █    █  █      █    █    █  █▄▄▄   ▀▄▄▄
  5.   █     █     █      █     █   █    █    █  █      █    █    █  █          █
  6.   ▀▀▀▀▀ ▀     ▀  ▀▀▀▀       ▀▀▀     ▀    ▀  ▀▀▀▀▀  ▀    ▀    ▀  ▀▀▀▀▀  ▀▀▀▀
  7.   ──────────────────────────────────────────────────────────────────────────
  8.     ──────────────────────────────────────────────────────────────────────
  9.  
  10.  
  11.  
  12.  
  13.  
  14.               ▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄
  15.               █▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█
  16.               █▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓█
  17.               █▓▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▓█
  18.               █▓▒░                                          ░▒▓█
  19.               █▓▒░            EMS UTILITIES V1.00           ░▒▓█
  20.               █▓▒░                                          ░▒▓█
  21.               █▓▒░   Aupetit Sébastien - Septembre 1995(c)  ░▒▓█
  22.               █▓▒░                                          ░▒▓█
  23.               █▓▒░  Version Shareware : enregistrez-vous !  ░▒▓█
  24.               █▓▒░  ──────────────────────────────────────  ░▒▓█
  25.               █▓▒░                                          ░▒▓█
  26.               █▓▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▓█
  27.               █▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓█
  28.               █▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█
  29.               ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  30.  
  31.  
  32.  
  33.  
  34.  
  35.  
  36.  
  37.  
  38.  
  39. Chapitre 1 : Qu'est-ce que EMS UTILITIES ?
  40.  
  41. Chapitre 2 : A savoir.
  42.  
  43. Chapitre 3 : Quelques notions sur l'EMS pour comprendre la nécessité de EMS
  44.              UTILITIES.
  45.  
  46. Chapitre 4 : Description des unités.
  47.  
  48. Chapitre 5 : Précautions et conseils lors de la programmation.
  49.  
  50. Chapitre 6 : Enregistrez-vous !
  51.  
  52.  
  53.  
  54.                    ┌──────────────────────────────────────┐
  55.                    │ CHAPITRE 1 : Qu'est-ce EMS UTILITIES │
  56.                    └──────────────────────────────────────┘
  57.  
  58.  
  59.  
  60. EMS UTILITIES est un coffret regroupant des fonctions pour gérer l'EMS
  61. (Expanded Memory Specification ) dans vos programmes de façon similaire aux
  62. instructions Turbo Pascal.
  63. Aux instructions Turbo Pascal : GetMem, FreeMem correspondent les instructions
  64. EMS UTILITIES Ems_GetMem, Ems_FreeMem.
  65. Toutefois leurs utilisations doivent être combinées à Ems_Acces pour accèder à
  66. une zone mémoire. ( voir plus loin )
  67.  
  68. L'un des avantages de EMS UTILITIES est que ses procédures et fonctions
  69. peuvent être exploitées même sans pilote EMS et carte EMS. EMS UTILITIES a la
  70. possibilité de pouvoir simuler de la mémoire EMS sur disque sans que le
  71. programme n'en voit la différence. Ainsi un programme exploitant la mémoire
  72. EMS pourra être utilisé même sur un système n'ayant pas de mémoire EMS.
  73.  
  74.  
  75.  
  76.                           ┌────────────────────────┐
  77.                           │ CHAPITRE 2 : A savoir. │
  78.                           └────────────────────────┘
  79.  
  80.  
  81.  
  82. Ce coffret n'est pas gratuit. Pour toutes utilisations au delà d'un délai de
  83. 30 jours suivant la première utilisation, vous avez l'obligation morale de
  84. vous enregistrez. Pour cela veuillez vous référer au chapitre : Enregistrez
  85. - vous !
  86.  
  87. Il est aussi à noter que je décline toutes responsabilités quant aux domages
  88. que pouraient provoquer EMS UTILITIES.
  89.  
  90. Je vous serais gré de m'envoyer un courrier si un bogue se révèlait dans
  91. l'utilisation de ce coffret. Pour cela, écrivez sur un papier la cause et la
  92. ligne de l'unité EMS UTILITIES où le bogue est apparu. Essayez d'expliquer le
  93. plus clairement possible ce qui a provoque l'erreur.
  94.  
  95.  
  96.  
  97.   ┌─────────────────────────────────────────────────────────────────────────┐
  98.   │ Chapitre 3 : Quelques notions sur l'EMS pour comprendre la nécessité de │
  99.   │                              EMS UTILITIES                              │
  100.   └─────────────────────────────────────────────────────────────────────────┘
  101.  
  102.  
  103.  
  104. Avant d'aborder la description des unités de EMS UTILITIES, il vous  faut
  105. connaître certaines bases sur la programmation de l'EMS.
  106.  
  107. En mode réel, un ordinateur ne peut adresser la mémoire que sur 1Mo de large.
  108. Cela parait suffisant, il faut savoir que l'espace effectivement libre pour un
  109. programme n'est que de 640 ko. Ces 640ko sont encore réduit par DOS et les
  110. drivers pour obtenir en moyenne 512 ko. De plus, la taille du code d'un
  111. programme en mémoire est généralement de 200 à 400 ko, l'espace libre reste
  112. souvant limitant pour un programme. Une solution serait de pouvoir accéder à
  113. plus de mémoire or l'architecture du microprocesseur ne le permet pas.
  114.  
  115. L'EMS offre à cette limite une solution qui consiste à adresser une autre
  116. mémoire à travers une "fenêtre accéssible". Le programme accède à la portion
  117. de mémoire EMS ( Fenêtre EMS ) à travers une zone mémoire adressable nommer
  118. Page Frame ( Fenêtre accéssible ).
  119.  
  120.  
  121.                    Le shéma suivant vous aidera à comprendre :
  122.  
  123.  
  124.           Mémoire adressable                   Mémoire EMS adressable à
  125.                                                 travers le Page Frame
  126.  
  127.   ^
  128.   │    ┌──────────────────────┐ 1 Mo          ┌──────────────────────┐
  129.   │    │                      │               │                      │
  130.   A    ├──────────────────────┤───────┐       │                      │
  131.   d    │ "Fenêtre accéssible" │       └───────├──────────────────────┤
  132.   r    ├──────────────────────┤───────┐       │   "Fenêtre EMS"      │
  133.   e    │                      │       └───────├──────────────────────┤
  134.   s    │                      │               │                      │
  135.   s    │                      │               │                      │
  136.   e    │                      │               │    Mémoire EMS       │
  137.   s    ├──────────────────────┤ 640 ko        │                      │
  138.        │                      │               │                      │
  139.   c    │                      │               │                      │
  140.   r    │                      │               │                      │
  141.   o    │                      │               │                      │
  142.   i    │                      │               │                      │
  143.   s    │                      │               │                      │
  144.   s    │                      │               │                      │
  145.   a    │                      │               │                      │
  146.   t    │                      │               │                      │
  147.   e    │                      │               │                      │
  148.   s    │                      │               │                      │
  149.   │    │                      │               │                      │
  150.   │    └──────────────────────┘ 0 ko          └──────────────────────┘
  151.  
  152.  
  153. Généralement l'adresse du Page Frame est logée au dessus des premiers 640 ko
  154. pour laisser un maximum d'espace libre aux programmes.
  155.  
  156. Tout accès dans la zone de la fenêtre s'effectue en fait dans la mémoire EMS.
  157.  
  158.  
  159. Ce mode d'exploitation pose plusieurs problèmes :
  160.  
  161.        - Le programme doit se charger de modifier la fenêtre pour accèder à la
  162. zone voulue en mémoire EMS car on ne peut accèder à toute la mémoire EMS en
  163. même temps.
  164.        - Ni DOS ni Turbo Pascal se charge de l'allocation et de la répartition
  165. de le mémoire libre et de sa gestion dans l' EMS.
  166.  
  167. EMS UTILITIES offre une solution à ces différents problèmes.
  168.  
  169. De plus, EMS UTILITIES prévoit le cas où la mémoire EMS n'est pas présente. Ce
  170. coffret permet en effet le cas échéant de simuler de la mémoire EMS ainsi
  171. votre programme n'a pas à prévoir deux gestions de mémoire, tout est
  172. fait de façon transparante.
  173.  
  174.  
  175.  
  176.                    ┌───────────────────────────────────────┐
  177.                    │ CHAPITRE 4 : Description des unités.  │
  178.                    └───────────────────────────────────────┘
  179.  
  180.  
  181.  
  182.                                **** SOMMAIRE ****
  183.  
  184.  
  185. L'unité Ems_Var.
  186.  
  187. Les unités EmsDisk et EmsEms.
  188.  
  189. L'unité Ems.
  190.  
  191. L'unité EmsLib.
  192.  
  193. L'unité EmsStr.
  194.  
  195. NB : Un handle EMS est un handle fourni par l'EMM ( Expanded Memory Manager).
  196. Il est a diférencier des handles EMS UTILITIES qui sont en fait un index dans
  197. un tableau de Handle EMS.
  198.  
  199.  
  200.                              ┌──────────────────┐
  201.                              │ L'unité Ems_Var  │
  202.                              └──────────────────┘
  203.  
  204.  
  205.  
  206. Cette unités regroupe un ensemble de variables et de constantes utilisées par
  207. plusieurs unités de EMS UTILITIES.
  208.  
  209.  
  210. I) La gestion des erreurs
  211. ─────────────────────────
  212.  
  213. Cette unité contient la variable EmsErrorProc destinée a recevoir un pointeur
  214. sur une routine d'erreur EMS.
  215.  
  216. La variable EmsErrorProc est déclarée de la façon suivante :
  217.  
  218.  
  219.    Const EmsErrorProc : TEmsErrorProc = Ems_DefaultErrorproc;
  220.                              │                   │
  221.              ┌───────────────┘                   └──────────────┐
  222.              │                                                  │
  223.   Type TEmsErrorProc = Procedure;      Ems_DefaultErrorProc est la routine de
  224.                                         traitement d'erreur EMS par défaut.
  225.  
  226.  
  227. Vous pouvez définir votre propre routine de traitement des erreurs en
  228. définissant une procédure à accès Far.
  229. Cette routine pourra choisir d'ignorer certaines erreurs et d'autres non. La
  230. routine par défaut déclenche une sortie immédiate du programme.
  231.  
  232. Toute routine de gestion des erreurs EMS doit consulter la variable
  233. EmsErrorCode ( de type WORD ).
  234.  
  235. A cette fin, l'unité Ems_Var définie une série de constantes dont voici la
  236. description :
  237.  
  238.    EmsError_Ok                                   = $00;
  239.    { Aucune erreur }
  240.    EmsError_NotInitialized                       = $01;
  241.    { Les fonctions de l'EMS n'ont pas été initialisées }
  242.    EmsError_NotEnoughMemory                      = $02;
  243.    { Mémoire disponible insuffisante }
  244.    EmsError_CreateFile                           = $03;
  245.    { Création du fichier d'échange impossible }
  246.    EmsError_CloseFile                            = $04;
  247.    { Erreur lors de la fermeture du fichier d'échange EMS }
  248.    EmsError_EraseFile                            = $05;
  249.    { Erreur lors de l'éffacement du fichier d'échange EMS }
  250.    EmsError_Release                              = $06;
  251.    { Erreur lors de la libération d'une page }
  252.    EmsError_AllocTooLargeBlock                   = $07;
  253.    { Tentative d'allocation d'un bloc de plus de }
  254.    { MaxPageBlockSize + SizeOf(TEmsFreeRec) octets, voir plus loin }
  255.    EmsError_InternError                          = $80;
  256.    { Erreur interne, Peut-être EMM détruit }
  257.    EmsError_ElectronicError                      = $81;
  258.    { Défaut de fonctionnement de l'électronique EMS }
  259.    EmsError_OccupiedEMM                          = $82;
  260.    { EMM occupé }
  261.    EmsError_BadHandle                            = $83;
  262.    { Handle incorrect, cette erreur peut se produire si un pointeur non EMS
  263.    est transmit aux fonctions de EMS UTILITIES }
  264.  
  265.    EmsError_BadFunction                          = $84;
  266.    { Fonction appelée non reconnue }
  267.    EmsError_NoMoreHandleFree                     = $85;
  268.    { Il n'y a plus de handles disponibles, cette erreur peut se produire dans
  269.    le cas où beaucoup trop de Handle ont été alloués }
  270.    EmsError_SaveRestoreMap                       = $86;
  271.    { Erreur lors de la sauvegarde ou du renvoi de la concordance entre }
  272.    { pages logiques et physiques }
  273.    EmsError_NotEnoughPhysicalPage                = $87;
  274.    { Le nb de pages physiques demandé est supérieur au nombre de pages }
  275.    { disponibles }
  276.    EmsError_NotEnoughLogicPage                   = $88;
  277.    { Le nb de pages logiques demandées est supérieur au nb actuellement }
  278.    { disponible }
  279.    EmsError_TryToAllocZeroPage                   = $89;
  280.    { Tentative d'allouer 0 Page }
  281.    EmsError_InvalidLogicPage                     = $8A;
  282.    { Numéro de page logique non valable }
  283.    EmsError_InvalidPhysicalPage                  = $8B;
  284.    { Numéro de page physique non valable }
  285.  
  286.  
  287. NB : Si la routine des gestions des erreurs décide d'ignorer une erreur, elle
  288. doit mettre la variable EmsErrorCode à EmsError_Ok.
  289.  
  290.  
  291. NB : La routine d'erreur quitte le programme avec un code de sortie de $FFFF.
  292.  
  293.  
  294. II) La gestion des procédures à appeler.
  295. ────────────────────────────────────────
  296.  
  297. Cette unité contient une variable nommée EmsProc servant à indiquer quelle
  298. gestion EMS UTILITIES est en cours. ( EMS ou émulation )
  299. Les valeurs valides pour cette variable sont :
  300.        Ems_EmsProc     = 0; { Utilisation de l'EMM et de l'EMS }
  301.        Ems_DiskProc    = 1; { Utilisation d'un fichier d'échange }
  302. Par défaut cette variable est préfixée à Ems_EmsProc.
  303. Avant l'appel de la procédure d'initialisation des fonctions d'EMS UTILITIES,
  304. il est possible de modifier cette variable pour modifier le comportement de
  305. ces fonctions. Cette variable ne doit JAMAIS être modifiée par la suite si
  306. l'initialisation a réusie.
  307.  
  308.  
  309. III) La taille maximale du bloc allouable
  310. ─────────────────────────────────────────
  311.  
  312. La taille maximale du bloc allouable par les fonctions d'EMS UTILITIES est
  313. contenue dans la variable MaxPageBlockSize. Cette variable est modifiée par
  314. les procédures d'initialisation. Cette variable ne doit JAMAIS être modifiée.
  315.  
  316. IV) Le segment du Page Frame
  317. ────────────────────────────
  318.  
  319. Le segment du Page Frame EMS est inscrit dans la variable Ems_FrameSeg. Cette
  320. variable ne doit JAMAIS être modifiée.
  321.  
  322.  
  323. V) Le nombre d'handle déjà alloué.
  324. ──────────────────────────────────
  325.  
  326. Le nombre de handle EMS dejà alloué est contenu dans la variable EmsHeapEnd.
  327. Comme la taille d'un handle de EMS UTILITIES est préfixée à 64ko, pour obtenir
  328. la taille de mémoire EMS utilisée par le programme il suffit de multiplier
  329. cette variable par 64ko. Cette variable ne doit JAMAIS être modifiée.
  330.  
  331.  
  332. VI) L'état des fonctions de EMS UTILITIES.
  333. ──────────────────────────────────────────
  334.  
  335. La variable EmsStatus de type BOOLEAN permet d'indiquer aux fonctions de EMS
  336. UTILITIES si l'initialisation s'est déroulée ( correctement ).
  337.  
  338.  
  339. VII) Le handle actuellement chargé en mémoire.
  340. ──────────────────────────────────────────────
  341.  
  342. La variable ActualEmsHandle indique quel est le handle EMS actuellement chargé
  343. en mémoire.
  344.  
  345.  
  346. VIII) La taille maximale de mémoire EMS utilisable par un programme.
  347. ────────────────────────────────────────────────────────────────────
  348.  
  349. Un programme peut par l'utilisation de EMS UTILITIES allouer au maximum de 16
  350. Mo de mémoire EMS. Ce chiffre est réduit par la gestion à l'intérieur de
  351. chaque handle mais ceci reste malgré tout négligeable.
  352.  
  353.  
  354. IX) La taille maximale que pourrait avoir un bloc de mémoire EMS.
  355. ─────────────────────────────────────────────────────────────────
  356.  
  357. La taille de ce bloc est définie par le type TEmsMaxSize déclaré de la façon
  358. suivante :
  359.  
  360.  
  361.    Const EmsMaxSize  = 65536 - 4;
  362.  
  363.    Type TEmsMaxSize = 0..EmsMaxSize;
  364.  
  365.  
  366.  
  367.                        ┌───────────────────────────────┐
  368.                        │ Les unités EmsDisk et EmsEms  │
  369.                        └───────────────────────────────┘
  370.  
  371.  
  372.  
  373. Ces deux unités étant utilisées en interne par EMS UTIlITIES nous n'en  feront
  374. qu'une brève description.
  375.  
  376. Ces deux unités sont rigoureusement symétriques et utilisent la même  syntaxe
  377. : toutes les fonctions de ces unités commencent par leurs noms.
  378.  
  379. L'unité EmsDisk est une interface pour l'émulation de mémoire EMS et EmsEms
  380. fait la même chose mais avec l'EMM ( Expanded Memory Manager ) et l'EMS.
  381.  
  382. Cotation : XXXX représente le nom de l'unité.
  383.  
  384. Function XXXX_Init : Boolean; procède à l'initialisation des fonctions de
  385. l'unité, elle retourne True si l'initialisation a réussie.
  386. On peut notemment utiliser la fonction EmsEms_init pour savoir si une mémoire
  387. EMS est présente mais il est plus judicieux d'utiliser la procédure
  388. d'initialisation générale de l'unité Ems.
  389.  
  390. Function XXXX_Done : Boolean; effectue la tâche inverse de la précédente.
  391.  
  392. Function XXXX_GetFrameSeg( var FrameSeg : Word ) : Boolean; retourne dans
  393. FrameSeg le segment du Page Frame et retourne True si l'opération a réussie.
  394.  
  395. Function XXXX_GetHandleFree( var MaxHandle : Word ) : Boolean; retourne dans
  396. MaxHandle le nombre de handle encore allouable, elle retourne aussi True s'il
  397. reste au moins un handle de libre et si tout c'est déroulé normalement sans
  398. erreur.
  399.  
  400. Function XXXX_AllocHandle( var Handle : Word ) : Boolean; alloue un handle EMS
  401. de 64ko et retourne True si réussie.
  402.  
  403. Function XXXX_ReleaseHandle( var Handle : Word ) : Boolean; libère un handle
  404. EMS et retourne True si pas d'erreur.
  405.  
  406. Functions XXXX_Maphandle( Handle : Word ) : Boolean; charge un handle EMS en
  407. mémoire ( fixe la mapping ) et retourne True si réusi.
  408.  
  409.  
  410.  
  411.                              ┌──────────────────┐
  412.                              │ L'unité EmsUtil. │
  413.                              └──────────────────┘
  414.  
  415.  
  416.  
  417. Pour réduire la complexité de la gestion utilisée par EMS UTILITIES, j'ai
  418. décidé de me servir d'une unité spécialement destinée à se charger de
  419. l'orientation des commandes soit vers l'unité EmsEms ou l'unité EmsDisk.
  420.  
  421. Cette unité adopte donc les même fonctions que les unités précédentes :
  422.  
  423. Function _Ems_Init : boolean;
  424. Function _Ems_GetFrameSeg( var FrameSeg : Word ) : Boolean;
  425. Function _Ems_GethandleFree( var MaxHandle : Word ) : Boolean;
  426. Function _Ems_AllocHandle( var Handle : Word ) : Boolean;
  427. Function _Ems_ReleaseHandle( var handle : Word ) : Boolean;
  428. Function _Ems_MapHandle( Handle : Word ) : Boolean;
  429. Function _Ems_Done : Boolean;
  430.  
  431.  
  432.  
  433.                                ╔══════════════╗
  434.                                ║ L'unité Ems. ║
  435.                                ╚══════════════╝
  436.  
  437.  
  438.  
  439. L'unité Ems incarne en fait toute la gestion de EMS UTILITIES.
  440.  
  441. En premier lieu, il faut savoir que ces fonctions utilisent des pointeur EMS.
  442.  
  443.  
  444. I) Qu'est-ce q'un pointeur EMS ?
  445. ────────────────────────────────
  446.  
  447.  
  448. Un pointeur EMS a la particularité d'avoir la même taille que le type POINTER
  449. mais il présente une structure. Il est déclaré de la façon suivante :
  450.  
  451.  
  452. Type TEmsPointer = Record
  453.            Handle : Word; ───────> Handle est index dans une table d'Handle
  454.                                    EMS
  455.            Ptr : Word; ──────────> Ptr est une adresse d'offset dans le Handle
  456.                                    EMS UTILITIES
  457.        End;
  458.  
  459.  
  460. Comme un pointeur EMS a la taille d'un POINTER, nous pouvons donc la
  461. transtyper. ( Role de l'unité EmsLib );
  462.  
  463.  
  464. II) Description des fonctions et de leurs utilisations.
  465. ───────────────────────────────────────────────────────
  466.  
  467.  
  468. 1) L'initialisation
  469. ───────────────────
  470.  
  471.  
  472.  
  473. Avant de pouvoir utiliser les fonctions de EMS UTILITIES, il faut procéder à
  474. leur initialisation, on peut procèder de la façon suivante :
  475.  
  476. begin
  477.    If _EmsInit then
  478.    Begin
  479.        ....
  480.            Corps du programme
  481.        ....
  482.    End
  483.    Else
  484.    Begin
  485.        ....
  486.            Message d'erreur
  487.        ....
  488.    End;
  489. End.
  490.  
  491.  
  492. Si l'on procède à l'initialisation comme si dessus, EMS UTILITIES utilisera
  493. les fonctions de l'EMM et de l'EMS. Or s'il n'y a pas de pilote EMS en
  494. mémoire, un message d'erreur apparaîtra.
  495.  
  496. Une solution consiste a modifier la variable EmsProc en la méttant à
  497. Ems_DiskProc. Mais là aussi ce n'est pas une solution, car si un pilote EMS
  498. est présent, on ne l'utilisera pas. La solution consiste à appeler chaque
  499. initialisation tour à tour de la façon suivante :
  500.  
  501. Begin
  502.     If Not(_EmsInit) then { Initialisation par defaut recherche de l'EMM }
  503.                            {et de l'EMS }
  504.    Begin { non pas d'EMS et d'EMM }
  505.        { on procède à l'initialisation de l'émulation }
  506.        EmsProc := Ems_DiskProc;
  507.        If Not(_EmsInit) then { Initialisation de l'émulation }
  508.        Begin { émulation impossible }
  509.                message d'erreur
  510.        End;
  511.    End;
  512.    ...
  513.        Corps du programme
  514.    ...
  515. End.
  516.  
  517.  
  518. Dès lors que la procédure d'initialisation a réussie, une procédure de sortie
  519. critique est installée pour être sûr que toute la mémoire EMS alloué par le
  520. programme soit effectivement libérée.
  521.  
  522.  
  523. Pendant l'initialisation des fonctions de EMS UTILITIES, un bloc de mémoire de
  524. 1 ko, pour mémoriser la liste des Handles EMS alloués, est allouée dans le
  525. tas. Veiller donc à laisser de l'espace mémoire pour la table des Handles EMS.
  526. Au cours de l'initialisation des fonctions d'émulation, un bloc de 65528
  527. octets ( plus grand bloc allouable avec GetMem ) est alloué dans le tas. Là
  528. aussi dans la cas où l'espace mémoire serait insuffisant, EmsErrorCode
  529. contiendrait la valeur EmsError_NotEnoughMemory et le programme se
  530. terminerait.
  531.  
  532.  
  533. 2) Allouer de la mémoire
  534. ────────────────────────
  535.  
  536. On alloue de la mémoire EMS avec _EmsGetMem.
  537.  
  538.    Function _EmsGetMem( var EmsPointer : TEmsPointer; Size : TEmsMaxSize ) :
  539. Boolean;
  540.  
  541. Cette fonction retourne True si l'allocation a réussie.
  542. EmsPointer pointe sur la zone allouée.
  543. Size est la taille du bloc à allouer
  544.  
  545.  
  546. NB : Size ne doit pas dépasser la taille de MaxPageBlockSize - 4 octets.
  547.  
  548.  
  549. 3) Libérer un bloc de mémoire EMS.
  550. ──────────────────────────────────
  551.  
  552.  
  553. On libère un bloc de mémoire EMS avec _EmsFreeMem.
  554.  
  555.    Function _EmsFreeMem( var EmsPointer : TEmsPointer; Size : TEmsMaxSize ) :
  556. Boolean;
  557.  
  558. Cette fonction attend dans EmsPointer un pointer EMS alloué précédemment  avec
  559. _EmsGetMem, ainsi que la taille à libérer.
  560.  
  561.  
  562. NB : LA TAILLE ALLOUEE DOIT ETRE IDENTIQUE A LA TAILLE LIBEREE.
  563.  
  564.  
  565. 4) Accèder à un bloc de mémoire EMS.
  566. ────────────────────────────────────
  567.  
  568.  
  569. On accède à un bloc de mémoire EMS avec _EmsAcces.
  570.  
  571.    Function _EmsAcces( EmsPointer : TEmsPointer ) : Pointer;
  572.  
  573. Cette fonction attend un pointer EMS préalablement allouée avec _EmsGetMem.
  574. Elle amène la handle en mémoire s'il n'y est pas et retourne un pointeur sur
  575. la zone.
  576.  
  577.  
  578. REMARQUE : le segment du pointer est Ems_FrameSeg.
  579.  
  580.  
  581. ATTENTION : Tout autre accès à la mémoire EMS, peut modifier le Handle
  582. actuellement en mémoire. Le pointeur qui a été retourné devient donc invalide
  583. car il pointe sur une zone erronée. ( voir la rubrique conseil lors de la
  584. programmation )
  585.  
  586.  
  587. 5) Verifier la validitée d'un pointer EMS.
  588. ──────────────────────────────────────────
  589.  
  590.  
  591. Il est possible de savoir si un pointeur EMS pointe effectivement sur une zone
  592. en mémoire EMS grâce à la fonction _EmsAssigned dont l'emploi est identique à
  593. l'instruction Turbo Pascal : Assigned.
  594.  
  595.    Function _EmsAssigned( EmsPointer : TEmsPointer ) : Boolean;
  596.  
  597. Cette fonction attend dans EmsPointer un pointeur EMS et retourne True s'il
  598. pointe sur une zone EMS.
  599.  
  600.  
  601.  
  602.                              ┌──────────────────┐
  603.                              │ L'unité EmsLib.  │
  604.                              └──────────────────┘
  605.  
  606.  
  607.  
  608. Cette unité permet d'utiliser les fonctions de EMS UTILITIES avec  des
  609. pointeurs.
  610.  
  611. Pour assurer la compatibilité entre les pointeurs EMS et les POINTERs, on
  612. utilise un type de transtypage :
  613.  
  614.  
  615. Type TPtrEms = Record
  616.        Case Boolean Of
  617.            True : ( EmsPtr : TEmsPointer );
  618.            False : ( Ptr : Pointer );
  619.      End;
  620.  
  621.  
  622. Cette unité redéfinie cinq fonctions et procédures :
  623.  
  624.    - L'initialisation :
  625.        Function Ems_Init : Boolean;  identique à _EmsInit;
  626.  
  627.  
  628.    - Allouer de la mémoire EMS :
  629.        Function Ems_GetMem( Size : Word ) : Pointer;  identique à _EmsGetMem
  630.                                                        mais le résultat est
  631.                                                        retourné par la
  632.                                                        fonction.
  633.  
  634.    - Libérer de la mémoire EMS :
  635.        Procedure Ems_FreeMem( var P : Pointer; Size : Word ); identique à
  636.                                                              _EmsFreeMem mais
  637.                                                              P a été retourné
  638.                                                              par Ems_GetMem.
  639.  
  640.    - Vérifier la validitée d'un pointeur sur de la mémoire EMS :
  641.        Function Ems_Assigned( P : Pointer ) : Boolean;  identique a
  642.                                                        _EmsAssigned
  643.  
  644.    - Accèder à un bloc de mémoire EMS :
  645.        Function Ems_Acces( P : Pointer ) : Pointer;  identique à _EmsAcces
  646.  
  647.                              ┌──────────────────┐
  648.                              │ L'unité EmsStr.  │
  649.                              └──────────────────┘
  650.  
  651.  
  652.  
  653. L'unité EmsStr est destinée plus particulièrement à être utilisée avec Turbo
  654. Vision en remplacement des fonctions NewStr et DisposeStr.
  655.  
  656. - Allocation dynamique d'une chaine de caractères :
  657.        Function Ems_NewStr( S : String ) : Pointer;
  658.  
  659. - Libération d'une chaine de caractères allouée avec Ems_NewStr :
  660.        Procedure Ems_DisposeStr( Var P : Pointer );
  661.  
  662. - Accèder à la chaine :
  663.        Function Ems_AccesStr( P : Pointer ) : PString;
  664.  
  665.  
  666. Voir le manuel de Turbo Vision.
  667.  
  668.  
  669.  
  670.       ┌────────────────────────────────────────────────────────────────┐
  671.       │ Chapitre 5 : Précautions et conseils lors de la programmation. │
  672.       └────────────────────────────────────────────────────────────────┘
  673.  
  674.  
  675. Vue que l'on ne peut accèder à toute la mémoire EMS en même temps, certains
  676. problèmes se posent lors de la création de listes chainées d'enregistrement.
  677.  
  678. Soit A un bloc de mémoire EMS. Ce bloc de mémoire étant structuré et Ptr étant
  679. un pointeur sur le prochain bloc de mémoire EMS.
  680.  
  681. Si l'on alloue un bloc B, dont l'adresse est mise dans Ptr (A). il se peut que
  682. l'allocation du bloc B ait modifié le Handle actuellement en mémoire, alors
  683. l'adresse du Bloc A serait erronée en mémoire.
  684.  
  685.  
  686. Par exemple : ( fichier LoadFile.PAS )
  687.  
  688.  
  689.    Type PLignePtr = ^TLignePtr;
  690.         TLignePtr = Record
  691.            Ligne : Pointer;  ──────> mémorise un pointeur sur la chaine
  692.                                      dynamique
  693.            Next : Pointer;  ───────> mémorise l'adresse du prochain TLignePtr
  694.         End;
  695.  
  696.  
  697. Si l'on utilise cette méthode, alors les résultats sont inattendus :
  698.  
  699.  
  700.    Procedure LoadFile;
  701.    Var P : Pointer;
  702.        Ligne : String;
  703.    Begin
  704.        P := Ems_GetMem(SizeOf(TLignePtr));
  705.        RootLigne := P;
  706.  
  707.        While Not(Eof(FichierText)) do
  708.        Begin
  709.            ReadLn(FichierText, Ligne);
  710.            PLignePtr(Ems_Acces(P))^.Ligne := Ems_NewStr(Ligne);
  711.            PLignePtr(Ems_Acces(P))^.Next := Ems_GetMem(SizeOf(TLignePtr));
  712.            P := PLignePtr(Ems_Acces(P))^.Next;
  713.        End;
  714.    End;
  715.  
  716.  
  717. En effet Turbo Pascal commencera par évaluer PlignePtr(Ems_Acces(P)) ce qui
  718. pourra charger le Handle 1 et Ems_NewStr(ligne) n'alloue pas la chaine dans
  719. le Handle 1, Turbo Pascal se servira de l'adresse retournée par la fonction,
  720. celle-ci n'étant plus valide car le Handle en mémoire n'est plus le même. Au
  721. pire cela ne peut rien faire, mais cela peut aussi détruire des données et
  722. provoquer un plantage.
  723.  
  724. Pour éviter tous ces désagréments, il convient de réserver une variable
  725. TLignePtr dans la pile par Var, d'allouer la chaine et le bloc suivant par
  726. rapport à cette variable puis d'accèder à la véritable variable en EMS et de
  727. recopier la variable de la pile.
  728.  
  729.  
  730.  
  731.    Procedure LoadFile;
  732.    Var P : Pointer;
  733.        Structure : TLignePtr;
  734.        Ligne : String;
  735.    Begin
  736.        P := Ems_GetMem(SizeOf(TLignePtr));
  737.        RootLigne := P;
  738.  
  739.        While Not(Eof(FichierText)) do
  740.        Begin
  741.            ReadLn(FichierText, Ligne);
  742.            Structure.Ligne := Ems_NewStr(Ligne);
  743.            Structure.Next := Ems_GetMem(SizeOf(TLignePtr));
  744.            PLignePtr(Ems_Acces(P))^ := Structure;
  745.            P := Structure.Next;
  746.            Strcuture.Next := nil;
  747.        End;
  748.    End;
  749.  
  750.  
  751. En règle générale, ne combinez JAMAIS deux instructions se référant à l'EMS
  752. sur des cotés opposés de la même ligne ( de part et d'autre du := ).
  753.  
  754. L'instruction suivante est valide : ( voir LoadFile.PAS )
  755.  
  756.  
  757.    PStr := Ems_AccesStr(PLignePtr(Ems_Acces(P))^.Ligne);
  758.  
  759.  
  760. car Turbo Pascal va dabord evaluer PLignePtr(Ems_Acces(P))^.Ligne et seulement
  761. après Ems_AccesStr(...); comme Ligne est un POINTER, il est transmit à
  762. Ems_AccesStr par la pile. Je vous conseille d'éviter cette méthode qui peut
  763. provoquer beaucoup de bogue qui seront très dûr à résoudre.
  764.  
  765.  
  766.                       ┌─────────────────────────────────┐
  767.                       │ Chapitre 6 : Enregistrez-vous ! │
  768.                       └─────────────────────────────────┘
  769.  
  770.  
  771.  
  772. EMS UTILITIES a nécessité de nombreuses heures de travail. Seulement si vous
  773. vous enregistrez, je pourais continuer de mettre à jour EMS UTILITIES. Vue
  774. les services rendus aux programmeurs par EMS UTILITIES, la modique somme de
  775. 150 FF n'est seulement qu'une formalité pour pouvoir disposer de EMS
  776. UTILITIES sans royalities dans vos programme.
  777.  
  778. Comment faire pour s'enregistrer ?
  779. ──────────────────────────────────
  780.  
  781. Il vous suffit d'envoyer une disquette vierge au format 3'1/2 720ko ou  1.44Mo
  782. à l'adresse suivante :
  783.  
  784.  
  785.                     ┌─────────────────────────────────────┐
  786.                     │     Aupetit Sébastien               │
  787.                     │ 58 Rue du Préfet Dalphonse - Notz   │
  788.                     │   36000 Châteauroux - France        │
  789.                     └─────────────────────────────────────┘
  790.  
  791.  
  792. accompagner de votre chèque de 150 FF à l'ordre de Sébastien Aupetit et d'une
  793. enveloppe affranchie au tarif lettre portant votre nom et votre adresse
  794. complète.
  795.  
  796. ATTENTION : Seul des Francs Français sont acceptés.
  797.  
  798. Dans un délai raisonnable, vous recevrez une version de EMS UTILITIES V1.00
  799. n'affichant pas de message de copyright.
  800.  
  801. Vous serez informer de toute nouvelle version de EMS UTILITIES.
  802.  
  803.  
  804.                  Merci ! J'espère que EMS UTILITIES vous a plu
  805.                 et que cette documentation est assez complète.
  806.  
  807.  
  808.  
  809.                                                              Sébastien Aupetit