home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / bpos2-v2.zip / RTL-FIX1.ZIP / FCTL.ASM next >
Assembly Source File  |  1993-11-19  |  23KB  |  439 lines
  1. ;//////////////////////////////////////////////////////
  2. ;/                                                    /
  3. ;/ Run-time Library für Borland Pascal 7.0 unter OS/2 /
  4. ;/ Datei-Routinen.                                    /
  5. ;/                                                    /
  6. ;/ 1993 Matthias Withopf / c't                        /
  7. ;/ Originalversion (c) 1988,92 Borland International  /
  8. ;/                                                    /
  9. ;//////////////////////////////////////////////////////
  10.  
  11.                 .286p
  12.  
  13.                 _NOMACROS_ = 1                  ; keine Macros definieren
  14.                 INCLUDE SE.ASM
  15.                 INCLUDE OS2.ASM
  16.  
  17. DATA            SEGMENT WORD PUBLIC
  18.                 EXTRN   FileMode:WORD,InOutRes:WORD
  19. DATA            ENDS
  20.  
  21. CODE            SEGMENT BYTE PUBLIC
  22.                 ASSUME  CS:CODE,DS:DATA
  23.  
  24.                 ;
  25.                 ; Konvertiere OS/2-Fehlercode in AX in DOS-Fehlercode.
  26.                 ; Falls kein korrespondierender Fehlercode existiert,
  27.                 ; wird der OS/2-Code mit gesetztem Bit 15 zurückgegeben.
  28.                 ;
  29.  
  30.                 PUBLIC  ConvErrCode
  31. ConvErrCode     PROC    NEAR
  32.                 CMP     AX,110
  33.                 JNZ     @@1
  34.                 MOV     AX,2
  35. @@1:            CMP     AX,88                   ; muß Code konvertiert werden ?
  36.                                                 ; Fehlercodes 1-87 sind gleich für MS-DOS und OS/2!
  37.                 JAE     @@Convert               ; ja -> setze Bit 15
  38.                 RET
  39.  
  40. @@Convert:      OR      AH,80H                  ; setze Bit 15 für OS/2-Fehlercode
  41.                 RET
  42. ConvErrCode     ENDP
  43.  
  44.                 ;
  45.                 ; Procedure Assign(Var f;Name : PChar);
  46.                 ;
  47.  
  48.                 PUBLIC  AssignFileC
  49. AssignFileC     PROC    PASCAL FAR
  50.                 MOV     DL,1                    ; setze Flag für PChar-Argument
  51.                 JMP     SHORT Assign
  52. AssignFileC     ENDP
  53.  
  54.                 ;
  55.                 ; Procedure Assign(Var f;Name : String);
  56.                 ;
  57.  
  58.                 PUBLIC  AssignFile
  59. AssignFile      PROC    PASCAL FAR
  60.                 XOR     DX,DX                   ;lösche Flag für PChar-Argument
  61. AssignFile      ENDP
  62.  
  63.                 ;
  64.                 ; Gemeinsame Routine für Assign.
  65.                 ;
  66.  
  67. Assign          PROC    PASCAL FAR
  68.                 ARG     A_File : DWORD,  \
  69.                         A_Name : DWORD
  70.                 PUSH    DS                      ; rette Datensegment
  71.                 LES     DI,A_File               ; lese Zeiger auf FileRec
  72.                 LDS     SI,A_Name               ; lese Zeiger auf Namen
  73.                 MOV     ES:[DI].fHandle,0       ; markiere Handle als ungültig
  74.                 MOV     ES:[DI].fMode,fmClosed  ; Datei ist geschlossen
  75.                 XOR     AX,AX                   ; lösche die
  76.                 MOV     CX,(fName-fBufSize)/2   ; restlichen
  77.                 ADD     DI,fBufSize             ; Komponenten
  78.                 CLD                             ; des
  79.                 REP     STOSW                   ; FileRecs
  80.                 MOV     CX,79                   ; lese max. Länge des Dateinamens
  81.                 OR      DX,DX                   ; ist es PChar-Routine ?
  82.                 JNE     @@CopyNameLoop          ; ja -> weiter
  83.                 LODSB                           ; lese Längenbyte des Namens
  84.                 CMP     CL,AL                   ; ist max. Länge überschritten ?
  85.                 JBE     @@CopyNameLoop          ; nein -> ok, weiter
  86.                 MOV     CL,AL                   ; schneide Namen ab
  87.                 JCXZ    @@CopyNameEnd           ; falls Namen Leerstring -> weiter
  88. @@CopyNameLoop: LODSB                           ; lese Zeichen aus angegebenem Dateinamen
  89.                 OR      AL,AL                   ; Ende erreicht (bei PChar-Routine) ?
  90.                 JE      @@CopyNameEnd           ; ja -> Kopieren des Namens beenden
  91.                 STOSB                           ; speichere Zeichen in TextRec
  92.                 LOOP    @@CopyNameLoop          ; gesamten Namen kopieren
  93. @@CopyNameEnd:  XOR     AL,AL                   ; schließe Namen in TextRec
  94.                 STOSB                           ; mit Nullbyte ab
  95.                 POP     DS                      ; stelle Datensegment wieder her
  96.                 RET
  97. Assign          ENDP
  98.  
  99.                 ;
  100.                 ; Procedure Close(Var f);
  101.                 ;
  102.  
  103.                 PUBLIC  CloseFile
  104. CloseFile       PROC    PASCAL FAR
  105.                 ARG     A_File : DWORD
  106.                 LES     DI,A_File               ; lese Zeiger auf FileRec
  107.                 CALL    OpenCheck               ; ist Datei geöffnet ?
  108.                 JNE     @@Exit                  ; falls nein -> Ende
  109.                 MOV     BX,ES:[DI].fHandle      ; lese Handle der Datei
  110.                 CMP     BX,2                    ; ist es Handle für Standard-I/O ?
  111.                 JBE     @@Closed                ; ja -> nicht schließen
  112.                 PUSH    BX                      ; übergebe FileHandle
  113.                 CALL    DosClose                ; schließe Datei
  114.                 CALL    ConvErrCode             ; konvertiere Fehlercode nach OS/2-Code
  115.                 OR      AX,AX                   ; ist Fehler aufgetreten ?
  116.                 JZ      @@Closed                ; nein -> Ende
  117.                 MOV     InOutRes,AX             ; speichere Fehlercode
  118. @@Closed:       MOV     ES:[DI].fMode,fmClosed  ; markiere Datei als geschlossen
  119. @@Exit:         RET
  120. CloseFile       ENDP
  121.  
  122.                 ;
  123.                 ; Procedure Reset(Var f;RecSize : Word);
  124.                 ;
  125.  
  126.                 PUBLIC  ResetFile
  127. ResetFile       PROC    PASCAL FAR
  128.                 MOV     AX,FILE_OPEN            ; lese Flags für Öffnen
  129.                 XOR     DX,DX                   ; Handle der Standard-Eingabe := 0
  130.                 JMP     SHORT OpenFile          ; -> öffne Datei
  131. ResetFile       ENDP
  132.  
  133.                 ;
  134.                 ; Procedure Rewrite(Var f;RecSize : Word);
  135.                 ;
  136.  
  137.                 PUBLIC  RewriteFile
  138. RewriteFile     PROC    PASCAL FAR
  139.                 MOV     AX,FILE_CREATE OR FILE_OPEN; lese Flags für neue Datei
  140.                 MOV     DX,1                    ; Handle der Standard-Ausgabe := 1
  141. RewriteFile     ENDP
  142.  
  143.                 ;
  144.                 ; Open file
  145.                 ;
  146.  
  147. OpenFile        PROC    PASCAL FAR
  148.                 ARG     A_FileP   : DWORD, \
  149.                         A_RecSize : WORD
  150.                 LOCAL   L_Handle  : WORD,  \
  151.                         L_Action  : WORD
  152.                 LES     DI,A_FileP              ; lese Zeiger auf FileRec
  153.                 CMP     ES:[DI].fMode,fmClosed  ; ist die Datei geschlossen ?
  154.                 JE      @@FileClosed            ; ja -> weiter
  155.                 CMP     ES:[DI].fMode,fmInOut   ; ist die Datei geöffnet ?
  156.                 JE      @@CloseFile             ; ja -> Datei zuerst schließen
  157.                 MOV     InOutRes,102            ; sonst Fehler: 'File not assigned'
  158.                 JMP     SHORT @@Exit            ; -> Ende
  159.  
  160. @@CloseFile:    PUSH    AX                      ; rette
  161.                 PUSH    DX                      ; Register
  162.                 PUSH    ES                   ;{CT} Save ES:DI
  163.                 PUSH    DI                   ;{CT}  "     "
  164.                 PUSH    ES                      ; übergebe Zeiger
  165.                 PUSH    DI                      ; auf FileRec
  166.                 PUSH    CS                      ; schließe Datei, bevor
  167.                 CALL    CloseFile               ; sie wieder geöffnet wird
  168.                 POP     DI                   ;{CT} REcover File REC
  169.                 POP     ES                   ;{CT} Recover file REC
  170.                 POP     DX                      ; hole Register
  171.                 POP     AX                      ; zurück
  172. @@FileClosed:   CMP     ES:[DI].fName,0         ; soll Standard-Ein-/Ausgabe geöffnet werden ?
  173.                 JE      @@OpenOk                ; ja -> weiter, bereits offen
  174.                 LEA     DX,[DI].fName           ; übergebe
  175.                 PUSH    ES                      ; Zeiger auf
  176.                 PUSH    DX                      ; Dateinamen
  177.                 LEA     DX,L_Handle             ; übergebe Zeiger auf
  178.                 PUSH    SS                      ; Speicherbereich, wo
  179.                 PUSH    DX                      ; DateiHandle abgelegt wird
  180.                 LEA     DX,L_Action             ; übergebe Zeiger auf
  181.                 PUSH    SS                      ; Speicherbereich, wo
  182.                 PUSH    DX                      ; ausgeführte Aktion abgelegt wird
  183.                 XOR     DX,DX                   ; übergebe
  184.                 PUSH    DX                      ; Größe
  185.                 PUSH    DX                      ; von 0
  186.                 PUSH    FILE_NORMAL             ; Flag für normale Datei
  187.                 PUSH    AX                      ; übergebe Open Flags
  188. ;                MOV     AX,OPEN_ACCESS_READWRITE; öffne für Ein-/Ausgabe
  189. ;                OR      AX,FileMode             ; übergebe
  190.                 MOV     AX,Filemode          ;{CT} enable opening readonly file.
  191.                 PUSH    AX                      ; Open Mode
  192.                 PUSH    DX                      ; übergebe 0L
  193.                 PUSH    DX                      ; (reserviert)
  194.                 CALL    DosOpen                 ; öffne Datei
  195.                 MOV     DX,L_Handle             ; lese Handle der neuen Datei
  196.                 CALL    ConvErrCode             ; konvertiere Fehlercode nach OS/2-Code
  197.                 OR      AX,AX                   ; Fehler aufgetreten ?
  198.                 JZ      @@OpenOk                ; nein -> ok, weiter
  199.                 MOV     InOutRes,AX             ; speichere Fehlercode
  200.                 JMP     SHORT @@Exit            ; -> Ende
  201.  
  202. @@OpenOk:       XCHG    AX,DX                   ; lese Handle in AX
  203.                 MOV     ES:[DI].fMode,fmInOut   ; setze Dateimodus
  204.                 MOV     ES:[DI].fHandle,AX      ; speichere Handle
  205.                 MOV     AX,A_RecSize            ; speichere angegebene
  206.                 MOV     ES:[DI].fBufSize,AX     ; Record-Größe im FileRec
  207. @@Exit:         RET
  208. OpenFile        ENDP
  209.  
  210.                 ;
  211.                 ; Procedure Truncate(Var f);
  212.                 ;
  213.  
  214.                 PUBLIC  TruncFile
  215. TruncFile       PROC    PASCAL FAR
  216.                 ARG     A_FileP   : DWORD
  217.                 LOCAL   L_FilePos : DWORD
  218.                 LES     DI,A_FileP              ; lese Zeiger auf FileRec
  219.                 CALL    OpenCheck               ; ist Datei geöffnet ?
  220.                 JNE     @@Exit                  ; nein -> weiter
  221.                 PUSH    ES:[DI].fHandle         ; bestimme aktuelle Position
  222.                 XOR     AX,AX                   ; übergebe 0
  223.                 PUSH    AX                      ; als
  224.                 PUSH    AX                      ; Positionsangabe
  225.                 PUSH    FILE_CURRENT            ; von aktueller Position aus
  226.                 LEA     BX,L_FilePos            ; lese Zeiger auf Word, in dem
  227.                 PUSH    SS                      ; die aktuelle Position des
  228.                 PUSH    BX                      ; Datei-Zeigers gespeichert wird
  229.                 CALL    DosChgFilePtr           ; erfrage aktuelle Position der Datei
  230.                 CALL    ConvErrCode             ; konvertiere Fehlercode nach OS/2-Code
  231.                 OR      AX,AX                   ; ist Fehler aufgetreten ?
  232.                 JNZ     @@Error                 ; ja -> Ende
  233.                 PUSH    ES:[DI].fHandle         ; übergebe FileHandle
  234.                 PUSH    L_FilePos.segm          ; übergebe neue
  235.                 PUSH    L_FilePos.offs          ; Dateigröße
  236.                 CALL    DosNewSize              ; schneide Datei ab
  237.                 CALL    ConvErrCode             ; konvertiere Fehlercode nach OS/2-Code
  238.                 OR      AX,AX                   ; ist Fehler aufgetreten ?
  239.                 JZ      @@Exit                  ; nein -> weiter
  240. @@Error:        MOV     InOutRes,AX             ; speichere Fehlercode
  241. @@Exit:         RET
  242. TruncFile       ENDP
  243.  
  244.                 ;
  245.                 ; Teste, ob Datei geöffnet ist.
  246.                 ;
  247.  
  248. OpenCheck       PROC    NEAR
  249.                 CMP     ES:[DI].fMode,fmInOut   ; ist Datei offen ?
  250.                 JE      @@Exit                  ; ja -> Ende
  251.                 MOV     InOutRes,103            ; sonst Fehler: 'File not open'
  252. @@Exit:         RET
  253. OpenCheck       ENDP
  254.  
  255.                 ;
  256.                 ; Procedure Read(Var f;Var V);
  257.                 ;
  258.  
  259.                 PUBLIC  ReadFile
  260. ReadFile        PROC    PASCAL FAR
  261.                 XOR     AH,AH                   ; setze Flag für Lesen
  262.                 MOV     DX,100                  ; Fehlernummer für 'Disk read error'
  263.                 JMP     SHORT InOutFile         ; -> lese Datei
  264. ReadFile        ENDP
  265.  
  266.                 ;
  267.                 ; Procedure Write(Var f;Var V);
  268.                 ;
  269.  
  270.                 PUBLIC  WriteFile
  271. WriteFile       PROC    PASCAL FAR
  272.                 MOV     AH,1                    ; setze Flag für Schreiben
  273.                 MOV     DX,101                  ; Fehlernummer für 'Disk write error'
  274. WriteFile       ENDP
  275.  
  276.                 ;
  277.                 ; Typed file I/O
  278.                 ;
  279.  
  280. InOutFile       PROC    PASCAL FAR
  281.                 ARG     A_FileP    : DWORD, \
  282.                         A_BufferP  : DWORD
  283.                 LOCAL   L_Count    : WORD
  284.                 LES     DI,A_FileP              ; lese Zeiger auf FileRec
  285.                 CALL    OpenCheck               ; ist Datei geöffnet ?
  286.                 JNE     @@Exit                  ; nein -> Fehler, Ende
  287.                 PUSH    DS                      ; rette Datensegment
  288.                 PUSH    DX                      ; rette Fehlernummer
  289.                 PUSH    ES:[DI].fHandle         ; übergebe FileHandle
  290.                 LDS     DX,A_BufferP            ; übergebe
  291.                 PUSH    DS                      ; Zeiger auf
  292.                 PUSH    DX                      ; Buffer
  293.                 PUSH    ES:[DI].fBufSize        ; übergebe Anzahl Bytes zum Lesen/Schreiben
  294.                 LEA     BX,L_Count              ; übergebe Zeiger auf Word,
  295.                 PUSH    SS                      ; in dem die tatsächliche Anzahl
  296.                 PUSH    BX                      ; gelesener/geschriebener Bytes gespeichert wird
  297.                 OR      AH,AH                   ; Schreiben ?
  298.                 JZ      @@Read                  ; nein -> Lesen
  299.                 CALL    DosWrite                ; schreibe Block in Datei
  300.                 JMP     SHORT @@Ok              ; -> weiter
  301.  
  302. @@Read:         CALL    DosRead                 ; lese Block aus Datei
  303. @@Ok:           CALL    ConvErrCode             ; konvertiere Fehlercode nach OS/2-Code
  304.                 POP     DX                      ; hole Fehlernummer zurück
  305.                 POP     DS                      ; hole Datensegment zurück
  306.                 OR      AX,AX                   ; ist Fehler aufgetreten ?
  307.                 JNZ     @@Error                 ; ja -> speichere Fehlernummer
  308.                 MOV     AX,L_Count              ; lese Anzahl gelesener/geschriebener Bytes
  309.                 CMP     AX,ES:[DI].fBufSize     ; konnte alles verarbeitet werden ?
  310.                 JE      @@Exit                  ; ja -> Ende
  311.                 MOV     AX,DX                   ; lese Fehlernummer in AX
  312. @@Error:        MOV     InOutRes,AX             ; speichere Fehlernummer
  313. ;@@Exit:         LEAVE                          ; nur A_BufferP vom Stack nehmen,
  314. ;                RET     4                      ; A_FileP dort lassen !
  315. @@Exit:         RET                             ;{CT} This exitproc was screwed up
  316. InOutFile       ENDP
  317.  
  318.                 ;
  319.                 ; Procedure BlockRead(Var f : File;Var Buf;Count : Word;Var Result : Word);
  320.                 ;
  321.  
  322.                 PUBLIC  ReadBlock
  323. ReadBlock       PROC    PASCAL FAR
  324.                 XOR     BL,BL                   ; setze Flag für Lesen
  325.                 MOV     CX,100                  ; Fehlernummer für 'Disk read error'
  326.                 JMP     SHORT InOutBlock
  327. ReadBlock       ENDP
  328.  
  329.                 ;
  330.                 ; Procedure BlockWrite(Var f : File;Var Buf;Count : Word;Var Result : Word);
  331.                 ;
  332.  
  333.                 PUBLIC  WriteBlock
  334. WriteBlock      PROC    PASCAL FAR
  335.                 MOV     BL,1                    ; setze Flag für Schreiben
  336.                 MOV     CX,101                  ; Fehlernummer für 'Disk write error'
  337. WriteBlock      ENDP
  338.  
  339.                 ;
  340.                 ; Ein-/Ausgabe von untypisierten Dateien.
  341.                 ;
  342.  
  343. InOutBlock      PROC    PASCAL FAR
  344.                 ARG     A_FileP   : DWORD, \
  345.                         A_BufferP : DWORD, \
  346.                         A_Count   : WORD,  \
  347.                         A_ResultP : DWORD
  348.                 LOCAL   L_Count   : WORD
  349.                 LES     DI,A_FileP              ; lese Zeiger auf FileRec
  350.                 CALL    OpenCheck               ; ist Datei geöffnet ?
  351.                 JNE     @@NotOpen               ; nein -> Fehler, Ende
  352.                 MOV     AX,A_Count              ; lese Anzahl zu lesender/schreibender Bytes
  353.                 OR      AX,AX                   ; 0 Bytes lesen/schreiben ?
  354.                 JE      @@ZeroBuf               ; ja -> weiter
  355.                 PUSH    DS                      ; rette Datensegment
  356.                 PUSH    CX                      ; rette Fehlernummer
  357.                 PUSH    ES:[DI].fHandle         ; übergebe FileHandle
  358.                 LDS     DX,A_BufferP            ; übergebe
  359.                 PUSH    DS                      ; Zeiger auf
  360.                 PUSH    DX                      ; Buffer
  361.                 MUL     ES:[DI].fBufSize        ; Anzahl Bytes := RecCount * RecSize
  362.                 PUSH    AX                      ; übergebe Anzahl Bytes zum Lesen/Schreiben
  363.                 LEA     DX,L_Count              ; übergebe Zeiger auf Word,
  364.                 PUSH    SS                      ; in dem die tatsächliche Anzahl
  365.                 PUSH    DX                      ; gelesener/geschriebener Bytes gespeichert wird
  366.                 OR      BL,BL                   ; Schreiben ?
  367.                 JZ      @@Read                  ; nein -> Lesen
  368.                 CALL    DosWrite                ; schreibe Block in Datei
  369.                 JMP     SHORT @@Ok              ; -> weiter
  370.  
  371. @@Read:         CALL    DosRead                 ; lese Block aus Datei
  372. @@Ok:           POP     CX                      ; hole Fehlernummer zurück
  373.                 POP     DS                      ; hole Datensegment zurück
  374.                 CALL    ConvErrCode             ; konvertiere Fehlercode nach OS/2-Code
  375.                 OR      AX,AX                   ; ist Fehler aufgetreten ?
  376.                 JNZ     @@Error                 ; ja -> speichere Fehlernummer
  377.                 MOV     AX,L_Count              ; berechne Anzahl
  378.                 XOR     DX,DX                   ; der gelesenen/geschriebenen
  379.                 DIV     ES:[DI].fBufSize        ; Records
  380. @@ZeroBuf:      LES     DI,A_ResultP            ; lese Zeiger auf Ergebnis-Word
  381.                 MOV     DX,ES                   ; ist Ergebnis-Word
  382.                 OR      DX,DI                   ; überhaupt angegeben ?
  383.                 JE      @@NoResult              ; nein -> weiter
  384.                 MOV     ES:[DI],AX              ; speichere Anzahl Records im Ergebnis-Word
  385.                 JMP     SHORT @@Exit            ; -> Ende
  386.  
  387. @@NoResult:     CMP     AX,A_Count              ; wurde alles verarbeitet ?
  388.                 JE      @@Exit                  ; ja -> Ende
  389.                 MOV     InOutRes,CX             ; sonst setze Fehlercode
  390.                 JMP     SHORT @@Exit            ; -> Ende
  391.  
  392. @@Error:        MOV     InOutRes,AX             ; speichere Fehlercode
  393. @@NotOpen:      LES     DI,A_ResultP            ; lese Zeiger auf Ergebnis-Word
  394.                 MOV     DX,ES                   ; ist Ergebnis-Word
  395.                 OR      DX,DI                   ; überhaupt angegeben ?
  396.                 JE      @@Exit                  ; nein -> Ende
  397.                 XOR     AX,AX                   ; speichere 0 als
  398.                 MOV     ES:[DI],AX              ; Ergebnis im Fehlerfall
  399. @@Exit:         RET
  400. InOutBlock      ENDP
  401.  
  402.                 ;
  403.                 ; Procedure Seek(Var f;Pos : LongInt);
  404.                 ;
  405.  
  406.                 PUBLIC  SeekFile
  407. SeekFile        PROC    PASCAL FAR
  408.                 ARG     A_FileP   : DWORD, \
  409.                         A_FilePos : DWORD
  410.                 LOCAL   L_FilePtr : DWORD
  411.                 LES     DI,A_FileP              ; lese Zeiger auf FileRec
  412.                 CALL    OpenCheck               ; ist Datei geöffnet ?
  413.                 JNE     @@Exit                  ; nein -> Fehler, Ende
  414.                 MOV     AX,A_FilePos.w2         ; berechne
  415.                 MUL     ES:[DI].fBufSize        ; die
  416.                 MOV     CX,AX                   ; neue
  417.                 MOV     AX,A_FilePos.w0         ; Position
  418.                 MUL     ES:[DI].fBufSize        ; des
  419.                 ADD     CX,DX                   ; Datei-Zeigers
  420. ;                PUSH    [DI].fHandle            ; übergebe FileHandle
  421.                 PUSH    ES:[DI].fHandle      ;{CT} Push correct filehandle
  422.                 PUSH    CX                      ; übergebe neue Position
  423.                 PUSH    AX                      ; des Datei-Zeigers
  424.                 PUSH    FILE_BEGIN              ; vom Dateianfang aus
  425.                 LEA     BX,L_FilePtr            ; lese Zeiger auf Word, in dem
  426.                 PUSH    SS                      ; die neue Position des
  427.                 PUSH    BX                      ; Datei-Zeigers gespeichert wird
  428.                 CALL    DosChgFilePtr           ; setze Datei-Zeiger
  429.                 OR      AX,AX                   ; ist Fehler aufgetreten ?
  430.                 JZ      @@Exit                  ; nein -> Ende
  431.                 CALL    ConvErrCode             ; konvertiere Fehlercode nach OS/2-Code
  432.                 MOV     InOutRes,AX             ; speichere Fehlercode
  433. @@Exit:         RET
  434. SeekFile        ENDP
  435.  
  436. CODE            ENDS
  437.  
  438.                 END
  439.