home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / dtx9302 / pastrick / xms.pas < prev   
Encoding:
Pascal/Delphi Source File  |  1993-02-23  |  7.1 KB  |  316 lines

  1. (* ****************************************************** *)
  2. (*                        XMS.PAS                         *)
  3. (*                 XMS-Zugriffs-Routinen                  *)
  4. (*           (c) 1993 Andres Cvitkovich & DMV             *)
  5. (* ****************************************************** *)
  6. UNIT XMS;
  7.  
  8. INTERFACE
  9.  
  10. VAR
  11.   XmsThere : BOOLEAN;
  12.                    { TRUE, wenn XMS-Speicher vorhanden ist }
  13.   XmsErrorCode : BYTE;
  14.              { Fehlercode nach XMS-Funktion; 0=kein Fehler }
  15.  
  16.   FUNCTION  XmsVersion : WORD;
  17.   FUNCTION  XmsKBytesAvail : WORD;
  18.   FUNCTION  XmsTotalKBytes : WORD;
  19.   FUNCTION  AllocateXmsBlock(KBytes : WORD) : WORD;
  20.   FUNCTION  DeallocateXmsHandle(Handle : WORD) : BOOLEAN;
  21.   PROCEDURE MoveToXmsBlock(Data : Pointer; Size : LongInt;
  22.                            Handle : WORD; xOffset : LongInt);
  23.   PROCEDURE MoveFromXmsBlock(Handle : WORD; xOffset: LongInt;
  24.                              Data : Pointer; Size : LongInt);
  25.   PROCEDURE MoveToXms(buf : Pointer; Size : LongInt;
  26.                       xHdl : WORD; Offs : LongInt);
  27.   PROCEDURE MoveFromXms(xHdl : WORD; Offs : LongInt;
  28.                         buf : Pointer; Size : LongInt);
  29.  
  30. IMPLEMENTATION
  31.  
  32. VAR
  33.   XmsEntry    : PROCEDURE;
  34.   HIMEM_stack : ARRAY [0..255] OF WORD;
  35.   Info_Block  : RECORD
  36.                   Bytes   : LongInt;
  37.                   src_hdl : WORD;
  38.                   src_ptr : Pointer;
  39.                   dst_hdl : WORD;
  40.                   dst_ptr : Pointer
  41.                 END;
  42.  
  43.   PROCEDURE NormalizePointer(VAR p : Pointer); ASSEMBLER;
  44.   ASM
  45.     LES  DI, p
  46.     MOV  ax, ES:[DI]
  47.     MOV  CL, 4
  48.     SHR  AX, CL
  49.     ADD  ES:[DI+2], AX
  50.     AND  ES:[DI], Word(0Fh)
  51.   END;
  52.  
  53.   FUNCTION XmsInstalled : BOOLEAN; ASSEMBLER;
  54.   ASM
  55.     MOV  XmsThere, FALSE
  56.     MOV  AX, 4300h
  57.     INT  2Fh
  58.     CMP  AL, 80h
  59.     JNE  @no
  60.     INC  XmsThere
  61.   @no:
  62.     MOV  AL, XmsThere
  63.   END;
  64.  
  65.   PROCEDURE SetEntry; ASSEMBLER;
  66.   ASM
  67.     MOV  AX, 4310h
  68.     INT  2Fh
  69.     MOV  Word (XmsEntry), BX
  70.     MOV  Word (XmsEntry+2), ES
  71.   END;
  72.  
  73.   PROCEDURE XmsDrv; NEAR; ASSEMBLER;
  74.   ASM
  75.     JMP  @overdata
  76.   @axs:
  77.     DW   0
  78.   @sss:
  79.     DW   0
  80.   @ssp:
  81.     DW   0
  82.   @overdata:
  83.     MOV  Word Ptr CS:@sss, SS
  84.     MOV  Word Ptr CS:@ssp, SP
  85.     MOV  Word Ptr CS:@axs, AX
  86.     MOV  AX, SEG HIMEM_stack
  87.     CLI
  88.     MOV  SS, AX
  89.     MOV  SP, (OFFSET HIMEM_stack) + (TYPE HIMEM_stack)
  90.     MOV  AX, Word Ptr CS:@axs
  91.     STI
  92.     CALL XmsEntry
  93.     CLI
  94.     MOV  SS, Word Ptr CS:@sss
  95.     MOV  SP, Word Ptr CS:@ssp
  96.     STI
  97.     PUSH DS
  98.     PUSH AX
  99.     MOV  AX, SEG @Data
  100.     MOV  DS, AX
  101.     MOV  XmsErrorCode, BL
  102.     POP  AX
  103.     POP  DS
  104.   END;
  105.  
  106.   FUNCTION XmsVersion : WORD; ASSEMBLER;
  107.   ASM
  108.     XOR  AX, AX
  109.     CMP  XmsThere, FALSE
  110.     JE   @@1
  111.     CALL XmsDrv
  112.   @@1:
  113.   END;
  114.  
  115.   FUNCTION XmsKBytesAvail : WORD; ASSEMBLER;
  116.   ASM
  117.     XOR  AX, AX
  118.     CMP  XmsThere, FALSE
  119.     JE   @@1
  120.     MOV  AH, 8
  121.     CALL XmsDrv
  122.   @@1:
  123.   END;
  124.  
  125.   FUNCTION XmsTotalKBytes : WORD; ASSEMBLER;
  126.   ASM
  127.     XOR  AX, AX
  128.     CMP  XmsThere, FALSE
  129.     JE   @@1
  130.     MOV  AH, 8
  131.     CALL XmsDrv
  132.     MOV  AX, DX
  133.   @@1:
  134.   END;
  135.  
  136.   FUNCTION AllocateXmsBlock(KBytes: WORD): WORD; ASSEMBLER;
  137.   ASM
  138.     XOR  AX, AX
  139.     CMP  XmsThere, FALSE
  140.     JE   @@1
  141.     MOV  AH, 9
  142.     MOV  DX, KBytes
  143.     CALL XmsDrv
  144.     OR   AX, AX
  145.     JZ   @@1
  146.     MOV  AX, DX
  147.   @@1:
  148.   END;
  149.  
  150.   FUNCTION DeallocateXmsHandle(Handle : WORD) : BOOLEAN;
  151.   ASSEMBLER;
  152.   ASM
  153.     CMP  XmsThere, FALSE
  154.     JE   @@1
  155.     MOV  AH, 0Ah
  156.     MOV  DX, Handle
  157.     CALL XmsDrv
  158.   @@1:
  159.   END;
  160.  
  161.   PROCEDURE MoveToXmsBlock(Data : Pointer; Size : LongInt;
  162.                            Handle : WORD; xOffset: LongInt);
  163.   ASSEMBLER;
  164.   ASM
  165.     CMP  XmsThere, FALSE
  166.     JE   @@2
  167.     MOV  CX, Handle
  168.     MOV  BL, 0A5h
  169.     JCXZ @@1
  170.     PUSH DS
  171.     MOV  AX, SEG Info_Block
  172.     MOV  ES, AX
  173.     MOV  DI, OFFSET Info_Block
  174.     PUSH ES
  175.     PUSH DI
  176.     CLD
  177.     MOV  AX, Word (Size)
  178.     STOSW
  179.     MOV  AX, Word (Size+2)
  180.     STOSW
  181.     XOR  AX, AX
  182.     STOSW
  183.     MOV  AX, Word (Data)
  184.     STOSW
  185.     MOV  AX, Word (Data+2)
  186.     STOSW
  187.     MOV  AX, CX
  188.     STOSW
  189.     MOV  AX, Word (xOffset)
  190.     STOSW
  191.     MOV  AX, Word (xOffset+2)
  192.     STOSW
  193.     POP  SI
  194.     POP  DS
  195.     MOV  AH, 0Bh
  196.     CALL XmsDrv
  197.     POP  DS
  198.     OR   AX,AX
  199.     JZ   @@1
  200.     XOR  BL,BL
  201.   @@1:
  202.     MOV  XmsErrorCode, BL
  203.   @@2:
  204.   END;
  205.  
  206.   PROCEDURE MoveFromXmsBlock(Handle: WORD; xOffset: LongInt;
  207.                              Data: Pointer; Size: LongInt);
  208.   ASSEMBLER;
  209.   ASM
  210.     CMP  XmsThere, FALSE
  211.     JE   @@2
  212.     MOV  CX, Handle
  213.     MOV  BL, 0A5h
  214.     JCXZ @@1
  215.     PUSH DS
  216.     MOV  AX, SEG Info_Block
  217.     MOV  ES, AX
  218.     MOV  DI, OFFSET Info_Block
  219.     PUSH ES
  220.     PUSH DI
  221.     CLD
  222.     MOV  AX, Word (Size)
  223.     STOSW
  224.     MOV  AX, Word (Size+2)
  225.     STOSW
  226.     MOV  AX, CX
  227.     STOSW
  228.     MOV  AX, Word (xOffset)
  229.     STOSW
  230.     MOV  AX, Word (xOffset+2)
  231.     STOSW
  232.     XOR  AX, AX
  233.     STOSW
  234.     MOV  AX, Word (Data)
  235.     STOSW
  236.     MOV  AX, Word (Data+2)
  237.     STOSW
  238.     POP  SI
  239.     POP  DS
  240.     MOV  AH, 0Bh
  241.     CALL XmsDrv
  242.     POP  DS
  243.     OR   AX,AX
  244.     JZ   @@1
  245.     XOR  BL,BL
  246.   @@1:
  247.     MOV  XmsErrorCode, BL
  248.   @@2:
  249.   END;
  250.  
  251.   PROCEDURE MoveToXms(buf : Pointer; Size : LongInt;
  252.                       xHdl : WORD; Offs : LongInt);
  253.   TYPE
  254.     BPtr = ^BYTE;
  255.   VAR
  256.     tmpbuf : ARRAY [1..2] OF BYTE;
  257.     p      : Pointer;
  258.   BEGIN
  259.     IF Size = 0 THEN Exit;
  260.     IF Odd (Size) THEN BEGIN
  261.       IF Size = 1 THEN BEGIN
  262.         IF Offs = 0 THEN BEGIN
  263.           MoveFromXmsBlock (xHdl, 0, @tmpbuf, 2);
  264.           tmpbuf [1] := BPtr(buf)^;
  265.           MoveToXmsBlock (@tmpbuf, 2, xHdl, 0);
  266.         END ELSE BEGIN
  267.           MoveFromXmsBlock (xHdl, Offs-1, @tmpbuf, 2);
  268.           tmpbuf [2] := BPtr(buf)^;
  269.           MoveToXmsBlock (@tmpbuf, 2, xHdl, Offs-1);
  270.         END;
  271.       END ELSE BEGIN
  272.         p := buf;
  273.         NormalizePointer (p);
  274.         MoveToXmsBlock (p, 2, xHdl, Offs);
  275.         Inc(Longint (p));
  276.         NormalizePointer (p);
  277.         MoveToXmsBlock (p, Size-1, xHdl, Offs+1);
  278.       END;
  279.     END ELSE
  280.       MoveToXmsBlock (buf, Size, xHdl, Offs);
  281.   END;
  282.  
  283.   PROCEDURE MoveFromXms(xHdl : WORD; Offs : LongInt;
  284.                         buf : Pointer; Size : LongInt);
  285.   TYPE
  286.     BPtr = ^Byte;
  287.   VAR
  288.     tmpbuf : ARRAY [1..2] OF BYTE;
  289.     p      : Pointer;
  290.   BEGIN
  291.     IF Size = 0 THEN Exit;
  292.     IF Odd(Size) THEN BEGIN
  293.       IF Size = 1 THEN BEGIN
  294.         IF Offs = 0 THEN BEGIN
  295.           MoveFromXmsBlock(xHdl, 0, @tmpbuf, 2);
  296.           BPtr(buf)^ := tmpbuf [1];
  297.         END ELSE BEGIN
  298.           MoveFromXmsBlock(xHdl, Offs-1, @tmpbuf, 2);
  299.           BPtr(buf)^ := tmpbuf [2];
  300.         END;
  301.       END ELSE BEGIN
  302.         p := buf;  NormalizePointer (p);
  303.         MoveFromXmsBlock(xHdl, Offs, p, 2);
  304.         Inc(LongInt(p));  NormalizePointer (p);
  305.         MoveFromXmsBlock(xHdl, Offs+1, p, Size-1);
  306.       END;
  307.     END ELSE
  308.       MoveFromXmsBlock(xHdl, Offs, buf, Size);
  309.   END;
  310.  
  311. BEGIN
  312.   IF XmsInstalled THEN SetEntry;
  313. End.
  314. (* ****************************************************** *)
  315. (*                  Ende von XMS.PAS                      *)
  316.