C!T ROM 2/ctrom_ii_b.zip/ctrom_ii_b/PROGRAM/PASCAL/EXEC33/SPAWN.ASM

Assembly Source File | 1991-11-26 | 89KB | 3,536 lines

;
;    --- Version 3.3 91-11-26 15:42 ---
;
;    SPAWN.ASM - Main function for memory swapping spawn call.
;
;    Public Domain Software written by
;        Thomas Wagner
;        Ferrari electronic GmbH
;        Beusselstrasse 27
;        D-1000 Berlin 21
;        Germany
;
;>e
; Assemble with
;
; tasm  /DPASCAL spawn,spawnp          - Turbo Pascal (Tasm only), near
; tasm  /DPASCAL /DFARCALL spawn,spawnp    - Turbo Pascal (Tasm only), far
; ?asm  spawn;                  - C, default model (small)
; ?asm  /DMODL=large spawn          - C, large model
;
;    NOTE:    For C, change the 'model' directive below according to your
;        memory model, or define MODL=xxx on the command line.
;
;        For Turbo C Huge model, you must give /DTC_HUGE on the
;        command line, or define it here.
;
;
; Main function:
;
;   PASCAL:
;       function do_spawn (swapping: integer;
;                  execfname: string;
;               cmdtail: string;
;                  envlen: word;
;               var envp;
;               stdin: string;
;                   stdout: string;
;               stderr: string): integer;
;
;   C:
;       int do_spawn (int swapping,
;              char *execfname,
;              char *cmdtail,
;              unsigned envlen,
;              char *envp,
;              char *stdin,
;              char *stdout,
;              char *stderr)
;
;   Parameters:
;
;    swapping - swap/spawn/exec function:
;            < 0: Exec, don't swap
;                0: Spawn, don't swap
;            > 0: Spawn, swap
;                 in this case, prep_swap must have
;                 been called beforehand (see below).
;
;    cmdtail - command tail for EXEC.
;
;    execfname - name and path of file to execute.
;
;    envlen - length of environment copy (may be 0).
;
;    envp -  pointer to environment block (must be aligned on
;        paragraph boundary). Unused if envlen is 0.
;
;    'cmdtail' and 'execfname' must be zero terminated, even when
;    calling from Pascal. For Pascal, the length byte of the string
;    is ignored.
;
;   Returns:
;    0000..00ff:    Returncode of EXECed program
;    03xx:        DOS-Error xx calling EXEC
;    0500:        Swapping requested, but prep_swap has not
;            been called or returned an error
;    0501:        MCBs don't match expected setup
;    0502:        Error while swapping out
;    06xx:        DOS-Error xx on redirection
;
;
; For swapping, the swap method must be prepared before calling do_spawn.
;
;   PASCAL:
;    function prep_swap (method: word; swapfname: string): integer;
;   C:
;    int prep_swap (unsigned method, char *swapfname)
;
;   Parameters:
;
;    method    - bit-map of allowed swap devices:
;            01 - Allow EMS
;            02 - Allow XMS
;            04 - Allow File swap
;            10 - Try XMS first, then EMS
;            40 - Create file as "hidden"
;            80 - Use "create temp" call for file swap
;               100 - Don't preallocate file
;               200 - Check for Network, don't preallocate if net
;              4000 - Environment block will not be swapped
;
;    swapfname - swap file name (may be undefined if the
;            "method" parameters disallows file swap).
;            The string must be zero terminated, even
;            when calling from Pascal. For Pascal, the
;            length byte of the string is ignored.
;
;   Returns:
;
;       A positive integer on success:
;        1 - EMS swap initialized
;        2 - XMS swap initialized
;        4 - File swap initialized
;    A negative integer on failure:
;        -1 - Couldn't allocate swap space
;        -2 - The spawn module is located too low in memory
;<
;>d
; Assemblierung mit
;
; tasm  /DPASCAL spawn,spawnp          - Turbo Pascal (nur Tasm), near
; tasm  /DPASCAL /DFARCALL spawn,spawnp    - Turbo Pascal (nur Tasm), far
; ?asm  spawn;                  - C, default model (small)
; ?asm  /DMODL=large spawn          - C, large model
;
;    HINWEIS: Für C können Sie entweder die folgende 'model'-Direktive
;        Ihrem Speichermodell entsprechend ändern, oder beim
;        Assemblieren MODL=xxx in der Kommandozeile definieren.
;
;        Für Turbo C Huge model müssen Sie /DTC_HUGE beim Assemblieren
;        angeben, oder das Symbol in dieser Quelle definieren.
;
;
; Haupfunktion:
;
;   PASCAL:
;       function do_spawn (swapping: integer;
;                  execfname: string;
;               cmdtail: string;
;                  envlen: word;
;               var envp)
;
;   C:
;       int do_spawn (int swapping,
;              char *execfname,
;              char *cmdtail,
;              unsigned envlen,
;              char *envp)
;
;   Parameter:
;
;    swapping - swap/spawn/exec Funktion:
;            < 0: Exec, kein Auslagern, keine Rückkehr
;                0: Spawn, kein Auslagern
;            > 0: Spawn, Auslagern
;                 in diesem Fall muß vor Aufruf die Funktion
;                 prep_swap aufgerufen worden sein (siehe unten).
;
;    cmdtail - Parameter für das aufgerufene Programm.
;
;    execfname - Name und Pfad des auszuführenden Programms.
;
;    envlen - Länge der Umgebungsvariablen-Kopie (kann 0 sein).
;
;    envp -  Zeiger auf Umgebungsvariablen-Block (muß auf Paragraph-
;        Grenze adjustiert sein). Wird nicht benutzt wenn der
;        envlen Parameter 0 ist.
;
;    'cmdtail' und 'execfname' müssen 0-Terminiert sein, selbst wenn
;    der Aufruf von Pascal erfolgt. Bei Aufruf von Pascal wird das
;    Längenbyte am Anfang des Strings ignoriert.
;
;   Liefert:
;
;    0000..00ff:    Returncode des ausgeführten Programms
;    03xx:        DOS-Fehler xx beim Aufruf von EXEC
;    0500:        Auslagern angefordert, aber prep_swap wurde
;            nicht aufgerufen oder nicht erfolgreich ausgeführt
;    0501:        MCBs sind fehlerhaft bzw. verändert
;    0502:        Fehler bei Auslagerung
;    06xx:        DOS-Fehler xx bei Redirection
;
;
; Um Auslagern zu können, muß die Auslagerungs-Methode vor Aufruf von
; do_spawn vorbereitet werden.
;
;   PASCAL:
;    function prep_swap (method: byte; swapfname: string): integer;
;   C:
;    int prep_swap (unsigned char method, char *swapfname)
;
;   Parameter:
;
;    method    - Bit-Map der zulässigen Auslagerungsziele und Optionen:
;            01 - EMS zulassen
;            02 - XMS zulassen
;            04 - Datei zulassen
;            10 - Erst XMS, dann EMS versuchen
;            40 - Datei "hidden" erzeugen
;            80 - "create temp" Funktion bei Datei-Auslagerung
;               100 - Datei nicht präallozieren
;               200 - Netzwerk prüfen, nicht präallozieren wenn Netz
;              4000 - Environmentblock nicht auslagern
;
;    swapfname - Auslagerungsdateiname bzw. Pfad (kann undefiniert
;            sein wenn der "Method" Parameter keine Dateiauslagerung
;            zulässt).
;            Der String muß 0-Terminiert sein, selbst wenn
;            der Aufruf von Pascal erfolgt. Bei Aufruf von Pascal
;            wird das Längenbyte am Anfang des Strings ignoriert.
;
;   Liefert:
;
;       Einen positiven Wert bei Erfolg:
;        1 - EMS Auslagerung initialisiert
;        2 - XMS Auslagerung initialisiert
;        4 - Datei-Auslagerung initialisiert
;    Einen negativen Wert bei Fehler:
;        -1 - Kein Platz für Auslagerung
;        -2 - Das "spawn"-Modul ist zu nah am Beginn des Programms
;<
;--------------------------------------------------------------------------
;
;>e
;    Set NO_INHERIT to FALSE if you don't want do_exec to mess with
;    the handle table in the PSP, and/or you do want the child process
;    to inherit all open files.
;    If NO_INHERIT is TRUE, only the first five handles (the standard
;    ones) will be inherited, all others will be hidden. This allows
;    the child to open more files, and also protects you from the child
;    messing with any open handles.
;    NO_INHERIT should always be TRUE if you use functions to extend
;    the handle table (for more than 20 open files).
;
;    Set REDIRECT to FALSE if you do not want do_spawn to support redirection.
;
;    The following defines are for Turbo Pascal only:
;        Set PAS_FREE to TRUE to not swap the unused heap space.
;        Set TPAS_6 to TRUE for Turbo Pascal version 6.
;
;    When PAS_FREE is TRUE, the unused heap, i.e. the space between
;    HeapPtr and FreePtr for TP 5.x, or the space between HeapPtr and
;    HeapEnd for TP6.x, is temporarily chained into the DOS free space
;    list, and is not swapped out. Depending on your applications heap
;    usage, this can save a large amount of swap space, and considerably
;    speed up the swap.
;<
;>d
;    Setzen Sie NO_INHERIT auf FALSE wenn Sie nicht wollen, daß do_spawn
;    die Handle-Tabelle im PSP modifiziert, und/oder der Kindprozess
;    alle offenen Dateien erben soll.
;    Wenn NO_INHERIT TRUE ist, werden nur die ersten fünf Handles
;    (die Standard-Handles) vererbt, alle anderen werden versteckt.
;    Dies erlaubt dem Kindprozess, mehr Dateien zu öffnen, und schützt
;    Sie außerdem vor Änderungen an offenen Dateien.
;    NO_INHERIT sollte stets TRUE sein, wenn Sie Funktionen zur
;    Erweiterung der Handle-Tabelle (für mehr als 20 offene Dateien)
;    benutzen.
;
;    Setzen Sie REDIRECT auf FALSE wenn do_spawn keine Dateiumleitung
;    unterstützen soll.
;
;    Die folgenden Definitionen werden nur für Turbo Pascal benötigt:
;        Setzen Sie PAS_FREE auf TRUE wenn der unbenutzte Heap
;        nicht ausgelagert werden soll.
;        Setzen Sie TPAS_6 auf TRUE für Turbo Pascal Version 6.
;
;    Wenn PAS_FREE TRUE ist, wird der nicht belegte Heap, d.h. der
;    Bereich zwischen HeapPtr und FreePtr für TP 5.x, bzw. zwischen
;    HeapPtr und HeapEnd für TP 6.x, temporär in die DOS-Freispeicher-
;    Liste eingefügt, und damit nicht ausgelagert. Abhängig von der
;    Heap-Belegung Ihrer Applikation kann dies den Speicherbedarf
;    für die Auslagerung wesentlich verringern, und die Auslagerung
;    beschleunigen.
;<
;
FALSE        =    0
TRUE        =    NOT FALSE
;
NO_INHERIT    =    TRUE
REDIRECT    =    TRUE
;
PAS_FREE    =    FALSE
TPAS_6        =    FALSE
;
;
    IFDEF    PASCAL
    .model    tpascal
    IFDEF    FARCALL
    %out    Pascal, far calls
    ELSE
    %out    Pascal, near calls
    ENDIF
;
    extrn    prefixseg: word
    IF    PAS_FREE
    extrn    HeapPtr: dword
    IF    TPAS_6
    extrn    HeapEnd: dword
    ELSE
    extrn    FreePtr: dword
    ENDIF
    ENDIF
;
ptrsize    =    1
    ELSE
    IFNDEF    MODL
    .model    small,c
    %out    small model
    ELSE
%    .model    MODL,c
%    %out    MODL model
    ENDIF
;
ptrsize    =    @DataSize
;
    extrn    _psp: word
    ENDIF
;
    public    do_spawn
    public    prep_swap
    IFNDEF    PASCAL
    public    swap_prep
    ENDIF
;
stacklen    =    256        ;e local stack
                    ;d Lokaler Stack
;
;e    "ems_size" is the EMS block size: 16k.
;d    "ems_size" ist die EMS-Blockgröße: 16k.
;
ems_size    =    16 * 1024    ;e EMS block size
                    ;d EMS-Seiten-Größe
ems_parasize    =    ems_size / 16    ;e same in paragraphs
                    ;d desgleichen in Paragraphen
ems_shift    =    10        ;e shift factor for paragraphs
                    ;d Schiebefaktor für Paragraphen
ems_paramask    =    ems_parasize-1    ;e block mask
                    ;d Maske für Paragraphen
;
;e    "xms_size" is the unit of measurement for XMS: 1k
;d    "xms_size" ist die Blockgröße für XMS: 1k
;
xms_size    =    1024        ;e XMS block size
                    ;d XMS-Block-Größe
xms_parasize    =    xms_size / 16    ;e same in paragraphs
                    ;d desgleichen in Paragraphen
xms_shift    =    6        ;e shift factor for paragraphs
                    ;d Schiebefaktor für Paragraphen
xms_paramask    =    xms_parasize-1    ;e block mask
                    ;d Maske für Paragraphen
;
;e    Method flags
;d    Auslagerungsmethoden-Flags
;
USE_EMS        =    01h
USE_XMS        =    02h
USE_FILE    =    04h
XMS_FIRST    =    10h
HIDE_FILE    =    40h
CREAT_TEMP    =    80h
NO_PREALLOC    =    100h
CHECK_NET    =    200h
DONT_SWAP_ENV    =    4000h
;
;e    Return codes
;d    Resultatcodes
;
RC_TOOLOW    =    0102h
RC_BADPREP    =    0500h
RC_MCBERROR    =    0501h
RC_SWAPERROR    =    0502h
RC_REDIRFAIL    =    0600h
;
EMM_INT        =    67h
;
;e    The EXEC function parameter block
;d    Der Parameterblock für die EXEC-Funktion
;
exec_block    struc
envseg    dw    ?        ;e environment segment
                ;d Segmentadresse Umgebungsvariablenblock
ppar    dw    ?        ;e program parameter string offset
                ;d Programmparameterstring Offset
pparseg    dw    ?        ;e program parameter string segment
                ;d Programmparameterstring Segment
fcb1    dw    ?        ; FCB offset
fcb1seg    dw    ?        ; FCB segment
fcb2    dw    ?        ; FCB offset
fcb2seg    dw    ?        ; FCB segment
exec_block    ends
;
;e    Structure of an XMS move control block
;d    Struktur eines XMS move Kontrollblocks
;
xms_control    struc
lenlo        dw    ?    ;e length to move (doubleword)
                ;d Länge für Move (Doppelwort)
lenhi        dw    ?
srchnd        dw    ?    ;e source handle (0 for standard memory)
                ;d Quell-Handle (0 für Standardspeicher)
srclo        dw    ?    ;e source address (doubleword or seg:off)
                ;d Quell-Adresse (Doppelwort oder seg:off)
srchi        dw    ?
desthnd        dw    ?    ;e destination handle (0 for standard memory)
                ;d Ziel-Handle (0 für Standardspeicher)
destlo        dw    ?    ;e destination address (doubleword or seg:off)
                ;d Ziel-Adresse (Doppelwort oder seg:off)
desthi        dw    ?
xms_control    ends
;
;e    The structure of the start of an MCB (memory control block)
;d    Die Struktur des Beginns eines MCB (Speicher-Kontrollblock)
;
mcb        struc
id        db    ?
owner        dw    ?
paras        dw    ?
mcb        ends
;>e
;    The structure of an internal MCB descriptor.
;    CAUTION: This structure is assumed to be no larger than 16 bytes
;    in several places in the code, and to be exactly 16 bytes when
;    swapping in from file. Be careful when changing this structure.
;<
;>d
;    Die Struktur eines internen MCB-Descriptors.
;    ACHTUNG: An mehreren Stellen im Code wird angenommen, daß die
;    Länge dieser Struktur 16 Bytes nicht überschreitet. Beim
;    Zurücklesen von Datei wird angenommen, daß die Länge exakt 16
;    Bytes beträgt. Bei Änderungen in dieser Struktur ist daher
;    Vorsicht geboten.
;<
mcbdesc        struc
addr        dw    ?    ;e paragraph address of the MCB
                ;d Paragraph-Adresse des MCB
msize        dw    ?    ;e size in paragraphs (excluding header)
                ;d Größe in Paragraphen (Ausschließlich Header)
swoffset    dw    ?    ;e swap offset (0 in all blocks except first)
                ;d Auslagerungs-Offset (0 in allen Blöcken
                ;d außer dem ersten)
swsize        dw    ?    ;e swap size (= msize + 1 except in first)
                ;d Auslagerungsgröße (= msize + 1 außer
                ;d im ersten Block)
num_follow    dw    ?    ;e number of following MCBs
                ;d Zahl der folgenden MCBs
        dw    3 dup(?) ;e pad to paragraph (16 bytes)
                 ;d Auffüllen auf Paragraphen (16 Bytes)
mcbdesc        ends
;
;e    The variable block set up by prep_swap
;d    Der Variablenblock der durch prep_swap initialisiert wird
;
prep_block    struc
xmm        dd    ?        ;e XMM entry address
                    ;d Einsprungadresse XMM
first_mcb    dw    ?        ;e Segment of first MCB
                    ;d Segment des ersten MCB
psp_mcb        dw    ?        ;e Segment of MCB of our PSP
                    ;d Segment des MCB unseres PSP
env_mcb        dw    ?        ;e MCB of Environment segment
                    ;d MCB des Umgebungsvariablenblocks
noswap_mcb    dw    ?        ;e Env MCB that may not be swapped
                    ;d Env MCB der nicht Ausgelagert wird
        IF    NOT NO_INHERIT
noswap_mcb2    dw    ?        ;e Handle MCB that may not be swapped
                    ;d Handle MCB der nicht Ausgelagert wird
        ENDIF
        IFDEF    PASCAL
        IF    PAS_FREE
pmemid        db    ?
pmempar        dw    ?
        ENDIF
        ENDIF
ems_pageframe    dw    ?        ;e EMS page frame address
                    ;d EMS-Seiten-Adresse
handle        dw    ?        ;e EMS/XMS/File handle
                    ;d Handle für EMS/XMS/Datei
total_mcbs    dw    ?        ;e Total number of MCBs
                    ;d Gesamtzahl MCBs
swapmethod    db    ?        ;e Method for swapping
                    ;d Auslagerungsmethode
swapfilename    db    81 dup(?)    ;e Swap file name if swapping to file
                    ;d Auslagerungsdateiname
prep_block    ends
;
;----------------------------------------------------------------------
;>e
;    Since we'll be moving code and data around in memory,
;    we can't address locations in the resident block with
;    normal address expressions. MASM does not support
;    defining variables with a fixed offset, so we have to resort
;    to a kludge, and define the shrunk-down code as a structure.
;    It would also be possible to use an absolute segment for the
;    definition, but this is not supported by the Turbo Pascal linker.
;
;    All references to low-core variables from low-core itself
;    are made through DS, so we define a text macro "lmem" that
;    expands to "ds:". When setting up low core from the normal
;    code, ES is used to address low memory, so this can't be used.
;<
;>d
;    Da Code und Daten in andere Speicherbereiche kopiert werden,
;    können Adressen im residenten Teil nicht mit normalen Adress-
;    ausdrücken angesprochen werden. MASM unterstützt leider nicht
;    die Definition von Variablen mit festen Offsets, sodaß wir
;    den residenten Teil als Struktur definieren müssen. Eine Definition
;    als absolutes Segment wäre zwar in MASM möglich, dies wird jedoch
;    vom Turbo Pascal Linker nicht unterstützt.
;
;    Alle Referenzen auf Variablen im residenten Teil von diesem
;    Teil selbst geschehen über DS, hierfür kann daher ein Text-Makro
;    "lmem" definiert werden, das zu "ds:" expandiert wird. Beim
;    Aufsetzen des residenten Teils vom normalen Programm geschieht
;    die Adressierung über ES, sodaß dieses Makro dort nicht verwendet
;    werden darf.
;<
lmem    equ    <ds:>
;>e
;    The memory structure for the shrunk-down code, excluding the
;    code itself. The code follows this block.
;    The start of this block is the PSP.
;<
;>d
;    Die Struktur des residenten Teils, ausschließlich des Programm-
;    Codes. Der Programmcode folgt diesem Block.
;    Der Beginn dieses Blocks ist der PSP.
;<
parseg        struc
        db    18h dup(?)
psp_handletab    db    20 dup(?)    ; Handle Table
psp_envptr    dw    ?        ; Environment Pointer
        dd    ?
psp_handlenum    dw    ?        ; Number of Handles (DOS >= 3.3)
psp_handleptro    dw    ?        ; Handle Table Pointer (DOS >= 3.3)
psp_handleptrs    dw    ?        ; Handle Table Pointer Segment
        db    5ch-38h dup(?)    ;e start after PSP
                    ;d Start nach PSP
;
save_ss        dw    ?        ;e 5C - saved global ss
                    ;d 5C - Sicherung globales SS
save_sp        dw    ?        ;e 5E - saved global sp
                    ;d 5E - Sicherung globaler SP
xfcb1        db    16 dup(?)    ;e 60..6F - default FCB
                    ;d 60..6F - Standard-FCB
xfcb2        db    16 dup(?)    ;e 70..7F - default FCB
                    ;d 70..7f - Standard-FCB
zero        dw    ?        ;e 80 Zero command tail length (dummy)
                    ;d 80 Null-Kommandozeile (Dummy)
;
expar        db    TYPE exec_block dup (?) ; exec-parameter-block
spx        dw    ?        ;e saved local sp
                    ;d Sicherung lokaler SP
div0_off    dw    ?        ;e divide by zero vector save
                    ;d Sicherung divide-by-zero Vektor
div0_seg    dw    ?
        IF    NO_INHERIT
lhandlesave    db    26 dup(?)    ;e saved handle table and pointer
                    ;d Sicherung Handle-Tabelle und Pointer
        IF    REDIRECT
lredirsav    db    6 dup(?)    ;e saved redirection handles
                    ;d Sicherung Umleitungs-Handles
        ENDIF
        ENDIF
        IF    REDIRECT
lstdinsav    dw    3 dup(?)    ;e duped redirection handles
                    ;d Umleitungs-Handles aus 'dup'
        ENDIF
filename    db    82 dup(?)    ;e exec filename
                    ;d EXEC-Dateiname
progpars    db    128 dup(?)    ;e command tail
                    ;d Kommandozeile
        db    stacklen dup(?)    ;e local stack space
                    ;d Lokaler Stackbereich
mystack        db    ?
lprep        db    TYPE prep_block dup(?)    ;e the swapping variables
                        ;d die Auslagerungsvariablen
lcurrdesc    db    TYPE mcbdesc dup(?)    ;e the current MCB descriptor
                        ;d Descriptor aktueller MCB
lxmsctl        db    TYPE xms_control dup(?)
eretcode    dw    ?        ;e EXEC return code
                    ;d Resultatcode EXEC
retflags    dw    ?        ;e EXEC return flags
                    ;d Resultatflags EXEC
cgetmcb        dw    ?        ;e address of get_mcb
                    ;d Adresse von get_mcb
;
parseg    ends
;
param_len    =    ((TYPE parseg + 1) / 2) * 2    ; make even
codebeg        =    param_len
;
    .code
;
;------------------------------------------------------------------------
;
lowcode_begin:
;>e
;       The following parts of the program code will be moved to
;    low core and executed there, so there must be no absolute
;    memory references.
;    The call to get_mcb must be made indirect, since the offset
;    from the swap-in routine to get_mcb will not be the same
;    after moving.
;
;
;    get_mcb allocates a block of memory by modifying the MCB chain
;    directly.
;
;    On entry, lcurrdesc has the mcb descriptor for the block to
;          allocate.
;
;    On exit,  Carry is set if the block couldn't be allocated.
;
;    Uses     AX, BX, CX, ES
;    Modifies lprep.first_mcb
;<
;>d
;       Der folgende Teil des Programm-Codes wird in den unteren Speicher-
;    bereich kopiert und dort ausgeführt, es dürfen daher keine
;    absoluten Speicheradressen verwendet werden.
;    Der Aufruf von get_mcb muß indirekt erfolgen, da der Offset
;    der Einlagerungs-Routine zu get_mcb nach dem Kopieren nicht
;    mehr mit der Definition übereinstimmt.
;
;
;    get_mcb alloziert einen Speicherblock durch direkte Modifikation
;        der MCB-Kette.
;
;    Bei Einsprung enthält lcurrdesc den Deskriptor für den zu
;        allozierenden Block.
;
;    Bei Rückkehr ist das Carry-Flag gesetzt wenn der Block nicht
;        alloziert werden konnte.
;
;    Benutzt    AX, BX, CX, ES
;    Modifiziert lprep.first_mcb
;<
get_mcb    proc    near
;
    mov    ax,lmem lprep.first_mcb
    mov    bx,lmem lcurrdesc.addr
;
getmcb_loop:
    mov    es,ax
    cmp    ax,bx
    ja    gmcb_abort        ;e halt if MCB > wanted
                    ;d Abbrechen wenn MCB > gewünschtem
    je    mcb_found        ;e jump if same addr as wanted
                    ;d jump wenn Adresse gleich gewünschter
    add    ax,es:paras        ;e last addr
                    ;d Letze Adresse
    inc    ax            ; next mcb
    cmp    ax,bx
    jbe    getmcb_loop        ;e Loop if next <= wanted
                    ;d Nochmal wenn nächster <= gewünschter
;
;>e
;    The wanted MCB starts within the current MCB. We now have to
;    create a new MCB at the wanted position, which is initially
;    free, and shorten the current MCB to reflect the reduced size.
;<
;>d
;    Der gewünschte MCB beginnt innerhalb des laufenden MCB. Es muß
;    nun ein MCB an der gewünschten Position eingerichtet werden, und
;    der laufende MCB ist zu kürzen.
;<
    cmp    es:owner,0
    jne    gmcb_abort        ;e halt if not free
                    ;d Abbruch wenn nicht frei
    mov    bx,es            ;e current
                    ;d laufender
    inc    bx            ;e + 1 (header doesn't count)
                    ;d + 1 (Header zählt nicht)
    mov    ax,lmem lcurrdesc.addr
    sub    ax,bx            ;e paragraphs between MCB and wanted
                    ;d Paragraphen zwischen MCB
                    ;d und gewünschtem
    mov    bx,es:paras        ;e paras in current MCB
                    ;d Paragraphen in laufendem MCB
    sub    bx,ax            ;e remaining paras
                    ;d Restliche Paragraphen
    dec    bx            ;e -1 for header
                    ;d -1 für Header
    mov    es:paras,ax        ;e set new size for current
                    ;d neue Größe für laufenden Setzen
    mov    cl,es:id        ;e old id
                    ;d Alte ID
    mov    es:id,4dh        ;e set id: there is a next
                    ;d Setze ID: es gibt einen nächsten
    mov    ax,lmem lcurrdesc.addr
    mov    es,ax
    mov    es:id,cl        ;e and init to free
                    ;d und initialisiere auf Frei
    mov    es:owner,0
    mov    es:paras,bx
;>e
;    We have found an MCB at the right address. If it's not free,
;    abort. Else check the size. If the size is ok, we're done
;    (more or less).
;<
;>d
;    Wir haben einen MCB an der korrekten Adresse. Falls er nicht
;    frei ist, abbrechen. Sonst Größe prüfen. Falls die Größe
;    korrekt ist, sind wir (mehr oder weniger) fertig.
;<
mcb_found:
    mov    es,ax
    cmp    es:owner,0
    je    mcb_check        ;e continue if free
                    ;d weiter wenn Frei
;
gmcb_abort:
    stc
    ret
;
mcb_check:
    mov    ax,es:paras        ;e size
                    ;d Größe
    cmp    ax,lmem lcurrdesc.msize    ;e needed size
                    ;d gewünschte Größe
    jae    mcb_ok            ;e ok if enough space
                    ;d OK wenn genug Platz
;>e
;    If there's not enough room in this MCB, check if the next
;    MCB is free, too. If so, coalesce both MCB's and check again.
;<
;>d
;    Wenn in diesem MCB nicht genug Platz ist, den nächsten MCB
;    prüfen ob er ebenfalls frei ist. Falls ja, beide Blöcke
;    kombinieren und nochmals prüfen.
;<
    cmp    es:id,4dh
    jnz    gmcb_abort        ;e halt if no next
                    ;d Abbruch wenn kein nächster
    push    es            ;e save current
                    ;d Laufenden sichern
    mov    bx,es
    add    ax,bx
    inc    ax            ;e next MCB
                    ;d nächter MCB
    mov    es,ax
    cmp    es:owner,0        ;e next free ?
                    ;d ist der nächste frei?
    jne    gmcb_abort        ;e halt if not
                    ;d Abbruch wenn nein
    mov    ax,es:paras        ;e else load size
                    ;d sonst Größe laden
    inc    ax            ;e + 1 for header
                    ;d + 1 für Header
    mov    cl,es:id        ;e and load ID
                    ;d und ID laden
    pop    es            ;e back to last MCB
                    ;d zurück zum letzten MCB
    add    es:paras,ax        ;e increase size
                    ;d Größe erhöhen
    mov    es:id,cl        ;e and store ID
                    ;d und ID abspeichern
    jmp    mcb_check        ;e now try again
                    ;d nochmal versuchen
;>e
;    The MCB is free and large enough. If it's larger than the
;    wanted size, create another MCB after the wanted.
;<
;>d
;    Der MCB ist frei und groß genug. Wenn er größer als die gewünschte
;    Größe ist, muß ein weiterer MCB nach dem gewünschten erzeugt werden.
;<
mcb_ok:
    mov    bx,es:paras
    sub    bx,lmem lcurrdesc.msize
    jz    mcb_no_next        ;e ok, no next to create
                    ;d OK, kein neuer einzurichten
    push    es
    dec    bx            ;e size of next block
                    ;d Größe des nächsten Blocks
    mov    ax,es
    add    ax,lmem lcurrdesc.msize
    inc    ax            ;e next MCB addr
                    ;d Adresse des nächsten MCB
    mov    cl,es:id        ;e id of this block
                    ;d ID dieses Blocks
    mov    es,ax            ;e address next
                    ;d nächsten adressieren
    mov    es:id,cl        ;e store id
                    ;d ID abspeichern
    mov    es:paras,bx        ;e store size
                    ;d Größe abspeichern
    mov    es:owner,0        ;e and mark as free
                    ;d und als frei markieren
    pop    es            ;e back to old MCB
                    ;d zurück zum alten MCB
    mov    es:id,4dh        ;e mark next block present
                    ;d markieren daß weiterer existiert
    mov    ax,lmem lcurrdesc.msize    ;e and set size to wanted
                    ;d und Größe auf gewünschte setzen
    mov    es:paras,ax
;
mcb_no_next:
    mov    es:owner,cx        ;e set owner to current PSP
                    ;d owner auf laufenden PSP setzen
;>e
;    Set the 'first_mcb' pointer to the current one, so we don't
;    walk through all the previous blocks the next time.
;    Also, check if the block we just allocated is the environment
;    segment of the program. If so, restore the environment pointer
;    in the PSP.
;<
;>d
;    Der 'first_mcb'-Pointer wird auf den aktuellen gesetzt,
;    damit beim nächsten Mal nicht wieder alle vorangegangenen
;    Blöcke abgelatscht werden müssen.
;    Außerdem wird der gerade allozierte Block geprüft, ob es der
;    Umgebungsvariablenblock des Programms ist. Wenn ja, wird der
;    entsprechende Pointer im PSP wiederhergestellt.
;<
    mov    ax,es
    mov    lmem lprep.first_mcb,ax
    cmp    lmem lprep.env_mcb,ax
    jne    getmcb_finis
    inc    ax
    mov    lmem psp_envptr,ax
;
getmcb_finis:
    clc
    ret                ;e all finished (whew!)
                    ;d endlich geschafft
;
get_mcb    endp
;
;
ireti:
    iret
;
;>e
;    The actual EXEC call.
;    Registers on entry:
;        BX    = paragraphs to keep (0 if no swap)
;        CX     = length of environment to copy (words) or zero
;        DS:SI    = environment source
;        ES:DI    = environment destination
;        (ES = our low core code segment)
;
;
;    copy environment buffer down if present
;<
;>d
;    Der eigentliche EXEC Aufruf.
;    Register bei Einsprung:
;        BX    = Residente Paragraphen (0 wenn keine Auslagerung)
;        CX     = Länge des Umgebungsvariablenblocks in Worten oder 0
;        DS:SI    = Quelladresse Umgebungsvariablenblock
;        ES:DI    = Zieladresse Umgebungsvariablenblock
;        (ES = Adresse residenter Teil)
;
;
;    Umgebungsvariablenblock nach unten kopieren wenn vorhanden
;<
doexec:
    jcxz    noenvcpy
    rep movsw
;
noenvcpy:
    push    es            ; DS = ES = low core = PSP
    pop    ds
    or    bx,bx
    jz    no_shrink
;
;e    first, shrink the base memory block down.
;d    Zuerst den Basisblock reduzieren.
;
        mov    ah,04ah
    int     21h                     ; resize memory block
;>e
;    Again walk all MCBs. This time, all blocks owned by the
;    current process are released.
;<
;>d
;    Wieder mal alle MCBs durchgehen. Diesmal werden alle Blöcke
;    die zu diesem Prozeß gehören freigegeben.
;<
    mov    si,lmem lprep.first_mcb
    or    si,si
    jz    no_shrink
    mov    dx,lmem lprep.psp_mcb
    mov    bx,dx
    inc    bx            ; base PSP (MCB owner)
    mov    di,lmem lprep.noswap_mcb
;
free_loop:
    cmp    si,dx
    je    free_next        ;e don't free base block
                    ;d Basisblock nicht freigeben
    cmp    si,di
    je    free_next

    IF    NOT NO_INHERIT
    cmp    si,lmem lprep.noswap_mcb2
    je    free_next
    ENDIF

    mov    es,si
    cmp    bx,es:owner        ;e our process?
                    ;d unser Prozeß?
    jne    free_next        ;e next if not
                    ;d nächsten wenn nein
    cmp    si,lmem lprep.env_mcb    ;e is this the environment block?
                    ;d ist dies der Umgebungsvariablenblock?
    jne    free_noenv
    mov    ds:psp_envptr,0        ;e else clear PSP pointer
                    ;d sonst PSP-pointer löschen
;
free_noenv:
    inc    si
    mov    es,si
    dec    si
    mov    ah,049h            ;e free memory block
                    ;d Speicher freigeben
    int    21h
;
free_next:
    mov    es,si
    cmp    es:id,4dh        ;e normal block?
                    ;d Normaler Block?
    jne    free_ready        ;e ready if end of chain
                    ;d Fertig wenn Ende der Kette
    add    si,es:paras        ;e start + length
                    ;d Beginn + Länge
    inc    si            ;e next MCB
                    ;d Nächster MCB
    jmp    free_loop
;
free_ready:
    mov    ax,ds
    mov    es,ax
;
no_shrink:
    mov    dx,filename        ;e params for exec
                    ;d Parameter für EXEC
    mov    bx,expar
    mov    ax,04b00h
    int    21h            ; exec
;>e
;    Return from EXEC system call. Don't count on any register except
;    CS to be restored (DOS 2.11 and previous versions killed all regs).
;<
;>d
;    Rückkehr vom EXEC Aufruf. Alle Register außer CS können zerstört
;    sein (DOS-Versionen 2.11 und früher zerstörten auch SS und SP).
;<
    mov    bx,cs
    mov    ds,bx
    mov    es,bx
    cli
    mov    ss,bx
    mov    sp,lmem spx
    sti
    cld
    mov    lmem eretcode,ax    ;e save return code
                    ;d Resultatcode sichern
    pushf
    pop    bx
    mov    lmem retflags,bx    ;e and returned flags
                    ;d und die gelieferten Flags
;
;e    Cancel Redirection
;d    Dateiumleitung aufheben
;
    IF    REDIRECT
    IF    NO_INHERIT
    mov    si,lredirsav
    mov    di,psp_handletab+5
    mov    cx,3
    rep movsw
    ENDIF
    mov    si,lstdinsav
    xor    cx,cx
;
lredirclose:
    lodsw
    cmp    ax,-1
    je    lredclosenext
    mov    bx,ax
    mov    ah,46h
    int    21h
;
lredclosenext:
    inc    cx
    cmp    cx,3
    jb    lredirclose
    ENDIF
;
    cmp    lmem lprep.swapmethod,0
    je    exec_memok
    jg    exec_expand
;
;    Terminate.
;
    test    lmem retflags,1        ; carry?
    jnz    exec_term        ;e use EXEc retcode if set
                    ;d Resultat von EXEC liefern wenn ja
    mov    ah,4dh            ;e else get program return code
                    ;d Sonst Resultat von Programm holen
    int    21h
;
exec_term:
    mov    ah,4ch
    int    21h
;
;
exec_expand:
    mov    ah,4ah            ; expand memory
    mov    bx,lmem lcurrdesc.msize
    int    21h
    jnc    exec_memok
    mov    ax,4cffh
    int    21h            ;e terminate on error
                    ;d Abbrechen bei Fehler
;
;e    Swap memory back
;d    Zurücklesen Speicher
;
    nop
;
exec_memok:
;
;e    FALL THROUGH to the appropriate swap-in routine
;d    Weiter in der passenden Einlagerungsroutine
;
;
getmcboff    =    offset get_mcb - offset lowcode_begin
iretoff        =    offset ireti - offset lowcode_begin
doexec_entry    =    offset doexec - offset lowcode_begin
base_length    =    offset $ - offset lowcode_begin
;
;-----------------------------------------------------------------------
;>e
;    The various swap in routines follow. Only one of the routines
;    is copied to low memory.
;    Note that the routines are never actually called, the EXEC return
;    code falls through. The final RET thus will return to the restored
;    memory image.
;
;    On entry, DS must point to low core.
;    On exit to the restored code, DS is unchanged.
;
;
;    swapin_ems:    swap in from EMS.
;<
;>d
;    Es folgen die verschiedenen Wiederherstellungsroutinen. Nur
;    eine der Routinen wird in den residenten Teil kopiert.
;    Beachten Sie, daß die Routinen nicht tatsächlich aufgerufen
;    werden, der Code nach dem EXEC-Aufruf läuft in sie hinein. Das
;    abschließende RET kehrt daher in das wiederhergestellte Haupt-
;    programm zurück.
;
;    Bei Einsprung zeight DS auf den Basis-PSP.
;    Bei Rückkehr in das wiederhergestellte Programm ist DS unverändert.
;
;
;    swapin_ems:    Wiederherstellen von EMS.
;<
swapin_ems    proc    far
;
    xor    bx,bx
    mov    si,ems_parasize
    mov    dx,lmem lprep.handle    ; EMS handle
;
swinems_main:
    push    ds
    mov    cx,lmem lcurrdesc.swsize    ;e block length in paras
                        ;d Blocklänge in Paragraphen
    mov    di,lmem lcurrdesc.swoffset    ;e swap offset
                        ;d Lese-Offset
    mov    es,lmem lcurrdesc.addr        ;e segment to swap
                        ;d Lese-Segment
    mov    ds,lmem lprep.ems_pageframe    ; page frame address
;
    mov    ax,ems_parasize        ;e max length
                    ;d Maximale Länge
    sub    ax,si            ;e minus current offset
                    ;d Minus laufender Offset
    jnz    swinems_ok        ;e go copy if nonzero
                    ;d Kopieren wenn nicht 0
;
swinems_loop:
    mov    ax,4400h        ;e map in next page
                    ;d Nächste EMS-Page einmappen
    int    EMM_INT
    or    ah,ah
    jnz    swinems_error
    mov    si,0            ;e reset offset
                    ;d Offset zurücksetzen
    inc    bx            ;e bump up page number
                    ;d Seitennummer erhöhen
    mov    ax,ems_parasize        ;e max length to copy
                    ;d Maximale Länge
;
swinems_ok:
    cmp    ax,cx            ;e length to copy
                    ;d zu kopierende Länge
    jbe    swinems_doit        ;e go do it if <= total length
                    ;d kopieren wenn <= Gesamtlänge
    mov    ax,cx            ;e else use total length
                    ;d sonst Gesamtlänge kopieren
;
swinems_doit:
    sub    cx,ax            ;e subtract copy length from total
                    ;d Gesamtlänge -= kopierte Länge
    push    cx            ;e and save
                    ;d sichern
    push    ax            ;e save the copy length in paras
                    ;d Sichern Kopierlänge in Paragraphen
    push    si
    push    di
    mov    cl,3
    shl    ax,cl            ;e convert to number of words (!)
                    ;d Konvertieren in Anzahl Worte (!)
    inc    cl
    shl    si,cl            ;e convert to byte address
                    ;d In Byte-Adresse konvertieren
    mov    cx,ax
    rep movsw
    pop    di
    pop    si
    pop    cx            ;e copy length in paras
                    ;d Kopierlänge in Paragraphen
    mov    ax,es
    add    ax,cx            ;e add copy length to dest segment
                    ;d Kopierlänge auf Zielsegment
    add    si,cx            ;e and EMS page offset
                    ;d und EMS-Seiten-Offset addieren
    mov    es,ax
    pop    cx            ;e remaining length
                    ;d Restlänge
    or    cx,cx            ;e did we copy everything?
                    ;d Alles kopiert?
    jnz    swinems_loop        ;e go loop if not
                    ;d Nochmal wenn nein
;
    pop    ds
    cmp    lmem lcurrdesc.num_follow,0    ;e another MCB?
                        ;d noch ein MCB?
    je    swinems_complete    ;e exit if not
                    ;d Fertig wenn nein
;
;e    Another MCB follows, read next mcb descriptor into currdesc
;d    Ein weiterer MCB folgt, lesen MCB Deskriptor nach currdesc
;
    cmp    si,ems_parasize
    jb    swinems_nonewpage    ;e no new block needed
                    ;d kein neuer Block nötig
    mov    ax,4400h        ; map page, phys = 0
    int    EMM_INT
    or    ah,ah
    jnz    swinems_error1
    mov    si,0
    inc    bx
;
swinems_nonewpage:
    push    si
    push    ds
    mov    ax,ds
    mov    es,ax
    mov    ds,lmem lprep.ems_pageframe    ; page frame address
    mov    cl,4
    shl    si,cl            ;e convert to byte address
                    ;d in Byte-Adresse konvertieren
    mov    cx,TYPE mcbdesc
    mov    di,lcurrdesc
    rep movsb
    pop    ds
    pop    si
    inc    si            ;e one paragraph
                    ;d Einen Paragraphen
;
    push    bx
    call    lmem cgetmcb
    pop    bx
    jc    swinems_error1
    jmp    swinems_main
;
swinems_complete:
    mov    ah,45h            ;e release EMS pages
                    ;d Freigeben EMS-Speicher
    int    EMM_INT
    ret
;
swinems_error:
    pop    ds
swinems_error1:
    mov    ah,45h            ;e release EMS pages on error
                    ;d Bei Fehler EMS freigeben
    int    EMM_INT
    mov    ax,4cffh
    int    21h            ; terminate
;
swapin_ems    endp
;
swinems_length    = offset $ - offset swapin_ems
;
;
;e    swapin_xms:    swap in from XMS.
;d    swapin_xms:    Wiederherstellen von XMS.
;
swapin_xms    proc    far
;
    mov    ax,lmem lprep.handle    ; XMS handle
    mov    lmem lxmsctl.srchnd,ax     ;e source is XMS
                    ;d Quelle ist XMS
    mov    lmem lxmsctl.desthnd,0     ;e dest is normal memory
                    ;d Ziel ist Standardspeicher
    mov    lmem lxmsctl.srclo,0
    mov    lmem lxmsctl.srchi,0
;
swinxms_main:
    mov    ax,lmem lcurrdesc.swsize ;e size in paragraphs
                     ;d Größe in Paragraphen
    mov    cl,4
    rol    ax,cl            ;e size in bytes + high nibble
                    ;d Größe in Bytes + high nibble
    mov    dx,ax
    and    ax,0fff0h        ; low word
    and    dx,0000fh        ; high word
    mov    lmem lxmsctl.lenlo,ax    ;e into control block
                    ;d in den Kontrollblock
    mov    lmem lxmsctl.lenhi,dx
    mov    ax,lmem lcurrdesc.swoffset    ;e swap offset
                        ;d Lese-Offset
    mov    lmem lxmsctl.destlo,ax         ;e into control block
                        ;d in den Kontrollblock
    mov    ax,lmem lcurrdesc.addr        ;e segment to swap
                        ;d Lese-Segment
    mov    lmem lxmsctl.desthi,ax
    mov    si,lxmsctl
    mov    ah,0bh
    call    lmem lprep.xmm        ; move it
    or    ax,ax
    jz    swinxms_error
    mov    ax,lmem lxmsctl.lenlo    ;e adjust source addr
                    ;d Quelladresse adjustieren
    add    lmem lxmsctl.srclo,ax
    mov    ax,lmem lxmsctl.lenhi
    adc    lmem lxmsctl.srchi,ax
;
    cmp    lmem lcurrdesc.num_follow,0    ;e another MCB?
                        ;d noch ein MCB?
    je    swinxms_complete
;
    mov    lmem lxmsctl.lenlo,TYPE mcbdesc
    mov    lmem lxmsctl.lenhi,0
    mov    lmem lxmsctl.desthi,ds
    mov    lmem lxmsctl.destlo,lcurrdesc
    mov    si,lxmsctl
    mov    ah,0bh
    call    lmem lprep.xmm        ; move it
    or    ax,ax
    jz    swinxms_error
    add    lmem lxmsctl.srclo,16    ; one paragraph
    adc    lmem lxmsctl.srchi,0
;
    call    lmem cgetmcb
    jc    swinxms_error
    jmp    swinxms_main
;
swinxms_complete:
    mov    ah,0ah            ;e release XMS frame
                    ;d Freigeben XMS-Speicher
    mov    dx,lmem lprep.handle       ; XMS handle
    call    lmem lprep.xmm
    ret
;
swinxms_error:
    mov    ah,0ah            ;e release XMS frame on error
                    ;d Bei Fehler XMS-Speicher freigeben
    call    lmem lprep.xmm
    mov    ax,4c00h
    int    21h
;
swapin_xms    endp
;
swinxms_length    = offset $ - offset swapin_xms
;
;
;e    swapin_file:    swap in from file.
;d    swapin_file:    Wiederherstellen von Datei.
;
swapin_file    proc    far
;
    mov    dx,lprep.swapfilename
    mov    ax,3d00h            ; open file
    int    21h
    jc    swinfile_error2
    mov    bx,ax                ; file handle
;
swinfile_main:
    push    ds
    mov    cx,lmem lcurrdesc.swsize    ;e size in paragraphs
                        ;d Blocklänge in Paragraphen
    mov    dx,lmem lcurrdesc.swoffset    ; swap offset
    mov    ds,lmem lcurrdesc.addr        ; segment to swap
;
swinfile_loop:
    mov    ax,cx
    cmp    ah,8h            ;e above 32k?
                    ;d mehr als 32k?
    jbe    swinfile_ok        ;e go read if not
                    ;d lesen wenn nein
    mov    ax,800h            ;e else read 32k
                    ;d sonst 32k lesen
;
swinfile_ok:
    sub    cx,ax            ;e remaining length
                    ;d Restlänge
    push    cx            ;e save it
                    ;d sichern
    push    ax            ;e and save paras to read
                    ;d Sichern Länge in Paragraphen
    mov    cl,4
    shl    ax,cl            ;e convert to bytes
                    ;d Konvertieren in Anzahl Bytes
    mov    cx,ax
    mov    ah,3fh            ; read
    int    21h
    jc    swinfile_error
    cmp    ax,cx
    jne    swinfile_error
    pop    cx            ;e paras read
                    ;d Gelesene Paragraphen
    mov    ax,ds
    add    ax,cx            ;e bump up dest segment
                    ;d Add. Kopierlänge auf Zielsegment
    mov    ds,ax
    pop    cx            ;e remaining length
                    ;d Restlänge
    or    cx,cx            ;e anything left?
                    ;d Noch etwas übrig?
    jnz    swinfile_loop        ;e go loop if yes
                    ;d Nochmal wenn ja
;
    pop    ds
    cmp    lmem lcurrdesc.num_follow,0    ; another MCB?
                        ;d noch ein MCB?
    je    swinfile_complete    ;e ready if not
                    ;d Fertig wenn nein
    mov    cx,16            ;e read one paragraph
                    ;d einen Paragraphen lesen
    mov    dx,lcurrdesc
    mov    ah,3fh
    int    21h
    jc    swinfile_error1
    cmp    ax,cx
    jne    swinfile_error1
;
    push    bx
    call    lmem cgetmcb
    pop    bx
    jc    swinfile_error1
    jmp    swinfile_main
;
;
swinfile_complete:
    mov    ah,3eh            ; close file
    int    21h
    mov    dx,lprep.swapfilename
    mov    ah,41h            ; delete file
    int    21h
    ret
;
swinfile_error:
    pop    cx
    pop    cx
    pop    ds
swinfile_error1:
    mov    ah,3eh            ; close file
    int    21h
swinfile_error2:
    mov    dx,lprep.swapfilename
    mov    ah,41h            ; delete file
    int    21h
    mov    ax,4cffh
    int    21h
;
swapin_file    endp
;
swinfile_length    = offset $ - offset swapin_file
;
;
;e    swapin_none:    no swap, return immediately.
;d    swapin_none:    Kein Wiederherstellen, nur Rückkehr.
;
swapin_none    proc    far
;
    ret
;
swapin_none    endp
;
;
    IF    swinems_length GT swinxms_length
swcodelen    =    swinems_length
    ELSE
swcodelen    =    swinxms_length
    ENDIF
    IF    swinfile_length GT swcodelen
swcodelen    =    swinfile_length
    ENDIF
;
swap_codelen    =    ((swcodelen + 1) / 2) * 2
;
codelen        =    base_length + swap_codelen
reslen        =    codebeg + codelen
keep_paras    =    (reslen + 15) shr 4    ;e paragraphs to keep
                        ;d Residente Paragraphen
swapbeg        =    keep_paras shl 4    ;e start of swap space
                        ;d Beginn Auslagerungsbereich
savespace    =    swapbeg - 5ch    ;e length of overwritten area
                    ;d Länge überschriebener Bereich
;
;--------------------------------------------------------------------
;
    IFDEF    PASCAL
    .data
    extrn    swap_prep: prep_block
    ELSE
    IFDEF    TC_HUGE
    .fardata?    my_data
    ELSE
    .data?
    ENDIF
    ENDIF
;
;>e
;    Space for saving the part of the memory image below the
;    swap area that is overwritten by our code.
;<
;>d
;    Platz zum Sichern des Teils des Speichers der vom
;    Aus-/Einlagerungscode und den Variablen überschrieben wird.
;<
save_dat    db    savespace dup(?)
;>e
;    Variables used while swapping out.
;    The "swap_prep" structure is initialized by prep_swap.
;<
;>d
;    Variablen zur Benutzung beim Auslagern.
;    Die "swap_prep" Struktur wird durch prep_swap initialisiert.
;<
    IFNDEF    PASCAL
swap_prep    prep_block    <>
    ENDIF
nextmcb        mcbdesc        <>
currdesc    mcbdesc        <>
xmsctl        xms_control    <>
ems_curpage    dw        ?    ;e current EMS page number
                    ;d Laufende Nummer EMS-Seite
ems_curoff    dw        ?    ;e current EMS offset (paragraph)
                    ;d Laufender EMS Offset (Paragraph)
;
;--------------------------------------------------------------------
;
    .code
;>e
;    swapout_ems:    swap out an MCB block to EMS.
;
;    Entry:    "currdesc"     contains description of block to swap
;        "nextmcb"    contains MCB-descriptor of next block
;                if currdesc.num_follow is nonzero
;
;    Exit:    0 if OK, != 0 if error, Zero-flag set accordingly.
;
;    Uses:    All regs excpt DS
;<
;>d
;    swapout_ems:    Auslagern eines MCB nach EMS.
;
;    Ein:    "currdesc"     Beschreibung des auszulagernden Blocks
;        "nextmcb"    MCB-Deskriptor des nächsten Blocks
;                wenn currdesc.num_follow nicht 0 ist.
;
;    Aus:    0 wenn OK, != 0 bei Fehler, Zero-flag entsprechend gesetzt.
;
;    Benutzt: Alle Register außer DS
;<
swapout_ems    proc    near
;
    push    ds
    mov    cx,currdesc.swsize    ;e block length in paras
                    ;d Blocklänge in Paragraphen
    mov    si,currdesc.swoffset    ; swap offset
    mov    dx,swap_prep.handle    ; EMS handle
    mov    bx,ems_curpage        ;e current EMS page
                    ;d laufende EMS Seite
    mov    di,ems_curoff        ;e current EMS page offset (paras)
                    ;d laufender EMS Offset (Paragraph)
    mov    es,swap_prep.ems_pageframe    ; page frame address
    mov    ds,currdesc.addr    ; segment to swap
;
    mov    ax,ems_parasize        ;e max length
                    ;d Maximale Länge
    sub    ax,di            ;e minus current offset
                    ;d Minus laufender Offset
    jnz    swems_ok        ;e go copy if there's room
                    ;d Kopieren wenn noch Platz ist
;
swems_loop:
    mov    ax,4400h        ;e map in next page
                    ;d Nächste EMS-Page einmappen
    int    EMM_INT
    or    ah,ah
    jnz    swems_error
    mov    di,0            ;e reset offset
                    ;d Offset zurücksetzen
    inc    bx            ;e bump up page number
                    ;d Seitennummer erhöhen
    mov    ax,ems_parasize        ;e max length to copy
                    ;d Maximale Länge
;
swems_ok:
    cmp    ax,cx            ;e length to copy
                    ;d zu kopierende Länge
    jbe    swems_doit        ;e go do it if <= total length
                    ;d kopieren wenn <= Gesamtlänge
    mov    ax,cx            ;e else use total length
                    ;d sonst Gesamtlänge kopieren
;
swems_doit:
    sub    cx,ax            ;e subtract copy length from total
                    ;d Gesamtlänge -= kopierte Länge
    push    cx            ;e and save
                    ;d sichern
    push    ax            ;e save the copy length in paras
                    ;d Sichern Kopierlänge in Paragraphen
    push    si
    push    di
    mov    cl,3
    shl    ax,cl            ;e convert to number of words (!)
                    ;d Konvertieren in Anzahl Worte (!)
    inc    cl
    shl    di,cl            ;e convert to byte address
                    ;d In Byte-Adresse konvertieren
    mov    cx,ax
    rep movsw
    pop    di
    pop    si
    pop    cx            ;e copy length in paras
                    ;d Kopierlänge in Paragraphen
    mov    ax,ds
    add    ax,cx            ;e add copy length to source segment
                    ;d Kopierlänge auf Zielsegment
    add    di,cx            ;e and EMS page offset
                    ;d und EMS-Seiten-Offset addieren
    mov    ds,ax
    pop    cx            ;e remaining length
                    ;d Restlänge
    or    cx,cx            ;e did we copy everything?
                    ;d Alles kopiert?
    jnz    swems_loop        ;e go loop if not
                    ;d Nochmal wenn nein
;
    pop    ds
    cmp    currdesc.num_follow,0    ;e another MCB?
                    ;d noch ein MCB?
    je    swems_complete        ;e exit if not
                    ;d Fertig wenn nein
;
;e    Another MCB follows, append nextmcb to save block.
;d    Ein weiterer MCB folgt, nextmcb an Block anfügen.
;
    cmp    di,ems_parasize
    jb    swems_nonewpage        ;e no new block needed
                    ;d kein neuer Block nötig
    mov    ax,4400h        ; map page, phys = 0
    int    EMM_INT
    or    ah,ah
    jnz    swems_error1
    mov    di,0
    inc    bx
;
swems_nonewpage:
    push    di
    mov    cl,4
    shl    di,cl            ;e convert to byte address
                    ;d in Byte-Adresse konvertieren
    mov    cx,TYPE mcbdesc
    mov    si,offset nextmcb
    rep movsb
    pop    di
    inc    di            ;e one paragraph
                    ;d Einen Paragraphen
;
swems_complete:
    mov    ems_curpage,bx
    mov    ems_curoff,di
    xor    ax,ax
    ret
;
swems_error:
    pop    ds
swems_error1:
    mov    ah,45h            ;e release EMS pages on error
                    ;d Bei Fehler EMS freigeben
    int    EMM_INT
    mov    ax,RC_SWAPERROR
    or    ax,ax
    ret
;
swapout_ems    endp
;
;>e
;    swapout_xms:    swap out an MCB block to XMS.
;
;    Entry:    "currdesc"     contains description of block to swap
;        "nextmcb"    contains MCB-descriptor of next block
;                if currdesc.num_follow is nonzero
;
;    Exit:    0 if OK, -1 if error, Zero-flag set accordingly.
;
;    Uses:    All regs excpt DS
;<
;>d
;    swapout_xms:    Auslagern eines MCB nach XMS.
;
;    Ein:    "currdesc"     Beschreibung des auszulagernden Blocks
;        "nextmcb"    MCB-Deskriptor des nächsten Blocks
;                wenn currdesc.num_follow nicht 0 ist.
;
;    Aus:    0 wenn OK, != 0 bei Fehler, Zero-flag entsprechend gesetzt.
;
;    Benutzt: Alle Register außer DS
;<
swapout_xms    proc    near
;
    push    ds
    pop    es
    mov    ax,currdesc.swsize    ;e size in paragraphs
                    ;d Größe in Paragraphen
    mov    cl,4
    rol    ax,cl            ;e size in bytes + high nibble
                    ;d Größe in Bytes + high nibble
    mov    dx,ax
    and    ax,0fff0h        ; low word
    and    dx,0000fh        ; high word
    mov    xmsctl.lenlo,ax        ; into control block
    mov    xmsctl.lenhi,dx
    mov    xmsctl.srchnd,0        ;e source is normal memory
                    ;d Quelle ist Standardspeicher
    mov    ax,currdesc.swoffset    ; swap offset
    mov    xmsctl.srclo,ax        ; into control block
    mov    ax,currdesc.addr    ; segment to swap
    mov    xmsctl.srchi,ax
    mov    ax,swap_prep.handle    ; XMS handle
    mov    xmsctl.desthnd,ax
    mov    si,offset xmsctl
    mov    ah,0bh
    call    swap_prep.xmm        ; move it
    or    ax,ax
    jz    swxms_error
    mov    ax,xmsctl.lenlo        ;e adjust destination addr
                    ;d Zieladresse adjustieren
    add    xmsctl.destlo,ax
    mov    ax,xmsctl.lenhi
    adc    xmsctl.desthi,ax
;
    cmp    currdesc.num_follow,0    ;e another MCB?
                    ;d noch ein MCB?
    je    swxms_complete
;
    mov    xmsctl.lenlo,TYPE mcbdesc
    mov    xmsctl.lenhi,0
    mov    xmsctl.srchi,ds
    mov    xmsctl.srclo,offset nextmcb
    mov    si,offset xmsctl
    mov    ah,0bh
    call    swap_prep.xmm        ; move it
    or    ax,ax
    jz    swxms_error
    add    xmsctl.destlo,16    ; one paragraph
    adc    xmsctl.desthi,0
;
swxms_complete:
    xor    ax,ax
    ret
;
swxms_error:
    mov    ah,0ah            ;e release XMS frame on error
                    ;d Bei Fehler XMS-Speicher freigeben
    mov    dx,swap_prep.handle    ; XMS handle
    call    swap_prep.xmm
    mov    ax,RC_SWAPERROR
    or    ax,ax
    ret
;
swapout_xms    endp
;
;>e
;    swapout_file:    swap out an MCB block to file.
;
;    Entry:    "currdesc"     contains description of block to swap
;        "nextmcb"    contains MCB-descriptor of next block
;                if currdesc.num_follow is nonzero
;
;    Exit:    0 if OK, -1 if error, Zero-flag set accordingly.
;
;    Uses:    All regs excpt DS
;<
;>d
;    swapout_file:    Auslagern eines MCB auf Datei.
;
;    Ein:    "currdesc"     Beschreibung des auszulagernden Blocks
;        "nextmcb"    MCB-Deskriptor des nächsten Blocks
;                wenn currdesc.num_follow nicht 0 ist.
;
;    Aus:    0 wenn OK, != 0 bei Fehler, Zero-flag entsprechend gesetzt.
;
;    Benutzt: Alle Register außer DS
;<
swapout_file    proc    near
;
    push    ds
    mov    cx,currdesc.swsize    ;e size in paragraphs
                    ;d Blocklänge in Paragraphen
    mov    bx,swap_prep.handle    ; file handle
    mov    dx,currdesc.swoffset    ; swap offset
    mov    ds,currdesc.addr    ; segment to swap
;
swfile_loop:
    mov    ax,cx
    cmp    ah,8h            ;e above 32k?
                    ;d mehr als 32k?
    jbe    swfile_ok        ;e go write if not
                    ;d schreiben wenn nein
    mov    ax,800h            ;e else write 32k
                    ;d sonst 32k schreiben
;
swfile_ok:
    sub    cx,ax            ;e remaining length
                    ;d Restlänge
    push    cx            ;e save it
                    ;d sichern
    push    ax            ;e and save paras to write
                    ;d Sichern Länge in Paragraphen
    mov    cl,4
    shl    ax,cl            ;e convert to bytes
                    ;d Konvertieren in Anzahl Bytes
    mov    cx,ax
    mov    ah,40h            ; write
    int    21h
    jc    swfile_error
    cmp    ax,cx
    jne    swfile_error
    pop    cx            ;e paras written
                    ;d Geschriebene Paragraphen
    mov    ax,ds
    add    ax,cx            ;e bump up source segment
                    ;d Add. Kopierlänge auf Quellsegment
    mov    ds,ax
    pop    cx            ;e remaining length
                    ;d Restlänge
    or    cx,cx            ;e anything left?
                    ;d Noch etwas übrig?
    jnz    swfile_loop        ;e go loop if yes
                    ;d Nochmal wenn ja
;
    pop    ds
    cmp    currdesc.num_follow,0    ;e another MCB?
                    ;d noch ein MCB?
    je    swfile_complete        ;e ready if not
                    ;d Fertig wenn nein
    mov    cx,16            ;e write one paragraph
                    ;d einen Paragraphen schreiben
    mov    dx,offset nextmcb
    mov    ah,40h
    int    21h
    jc    swfile_error1
    cmp    ax,cx
    jne    swfile_error1
;
swfile_complete:
    xor    ax,ax
    ret
;
swfile_error:
    pop    cx
    pop    cx
    pop    ds
swfile_error1:
    mov    ah,3eh            ; close file
    int    21h
    mov    dx,offset swap_prep.swapfilename
    mov    ah,41h            ; delete file
    int    21h
    mov    ax,RC_SWAPERROR
    or    ax,ax
    ret
;
swapout_file    endp
;
;--------------------------------------------------------------------------
;
    IF    REDIRECT
;>e
;    @redirect: Redirect a file.
;
;    Entry:    DS:SI = Filename pointer
;        AX zero if filename is NULL
;        CX    = Handle to redirect
;        ES:DI = Handle save pointer
;
;    Exit:    Carry set on error, then AL has DOS error code
;        ES:DI updated
;
;    Uses:    AX,BX,DX,SI
;<
;>d
;    @redirect: Umleiten einer Datei.
;
;    Entry:    DS:SI = Zeiger auf Dateinamen
;        AX ist 0 wenn Dateinamenszeiger NULL ist
;        CX    = Umzuleitendes Handle
;        ES:DI = Zeiger auf Handle-Sicherungswort
;
;    Exit:    Carry gesetzt bei Fehler, dann ist AL=DOS-Fehlercode
;        ES:DI wird modifiziert.
;
;    Uses:    AX,BX,DX,SI
;<
@redirect    proc    near
        local    doserr
;
    or    ax,ax
    jz    no_redirect
    cmp    byte ptr [si],0
    jne    do_redirect
;
no_redirect:
    mov    ax,-1
    stosw
    ret
;
do_redirect:
    IFDEF    PASCAL
    inc    si            ;e skip length byte
                    ;d Längenbyte überspringen
    ENDIF
    or    cx,cx
    jnz    redir_write
    mov    dx,si
    mov    ax,3d00h    ; open file, read only
    int    21h
    mov    doserr,ax
    jc    redir_failed
;
redir_ok:
    mov    dx,ax
    mov    ah,45h        ; duplicate handle
    mov    bx,cx
    int    21h
    mov    doserr,ax
    jc    redir_failed_dup
    push    ax
    mov    bx,dx
    mov    ah,46h        ; force duplicate handle
    int    21h
    mov    doserr,ax
    pop    ax
    jc    redir_failed_force
    stosw
    mov    ah,3eh        ; close file
    int    21h
    clc
    ret
;
redir_failed_force:
    mov    bx,ax
    mov    ah,3eh        ; close file
    int    21h
;
redir_failed_dup:
    mov    bx,dx
    mov    ah,3eh        ; close file
    int    21h
;
redir_failed:
    mov    ax,doserr
    stc
    ret
;
redir_write:
    cmp    byte ptr [si],'>'
    jne    no_append
    inc    si
    mov    dx,si
    mov    ax,3d02h        ; open file, read/write
    int    21h
    jc    no_append
    mov    bx,ax
    push    cx
    mov    ax,4202h        ; move file, offset from EOF
    xor    cx,cx
    mov    dx,cx
    int    21h
    mov    doserr,ax
    pop    cx
    mov    ax,bx
    jnc    redir_ok
    mov    dx,ax
    jmp    redir_failed_dup
;
no_append:
    mov    dx,si
    mov    ah,3ch
    push    cx
    xor    cx,cx
    int    21h
    mov    doserr,ax
    pop    cx
    jc    redir_failed
    jmp    redir_ok
;
@redirect    endp
;
    ENDIF
;
;--------------------------------------------------------------------------
;
    IFDEF    PASCAL
    IF    PAS_FREE
;
;e    @freepas: Chain unused Pascal Heap into DOS free list.
;d    @freepas: Den unbenutzten Pascal Heap in die DOS Freiliste einfügen.
;
@freepas    proc    near
;
    mov    swap_prep.pmemid,0    ;e Init to no free block
                    ;d Init auf keinen freien Block
;>e
;    Load pointer to end of unused heap. For TP 5.x, this is
;    FreePtr (which has to be adjusted if the offset part is 0).
;    For TP 6.x, it is HeapEnd.
;    For both versions, there may be data located after this
;    pointer, so we may have to create an MCB.
;<
;>d
;    Zeiger auf Ende des unbenutzten Heap laden. Für TP 5.x, der Zeiger
;    ist FreePtr (muß adjustiert werden wenn der Offset-Teil 0 ist).
;    Für TP 6.x ist es HeapEnd.
;    Für beide Versionen können nach diesem Zeiger noch Daten folgen,
;    sodaß eventuell ein MCB erzeugt werden muß.
;<
    IF    TPAS_6
    mov    ax,word ptr HeapEnd
    mov    dx,word ptr HeapEnd+2
    ELSE
    mov    ax,word ptr FreePtr
    mov    dx,word ptr FreePtr+2
    or    ax,ax            ; offset 0?
    jnz    freepok
    add    dx,1000h        ; adjust segment
freepok:
    ENDIF
    mov    cl,4
    shr    ax,cl
    add    ax,dx        ;e FreeList/HeapEnd segment (rounded down)
                ;d Segment von Freiliste/HeapEnd (abgerundet)
    dec    ax        ; MCB addr FreeList/HeapEnd segment
    mov    si,ax
;
    mov    bx,word ptr HeapPtr
    mov    dx,word ptr HeapPtr+2
    add    bx,0fh
    shr    bx,cl
    add    bx,dx        ; heap end segment (rounded up)
    mov    di,bx
;
    sub    ax,bx        ; free heap size
    jc    pnofree
    cmp    ax,1024        ;e don't bother if less than 16k
                ;d nicht freigeben wenn weniger als 16k
    jbe    pnofree
;
    mov    ax,PrefixSeg    ; PSP
    sub    bx,ax        ; size of space in use
    dec    ax        ; MCB
    mov    es,ax
    inc    ax
;
;e    Modify base MCB to contain only the part up to HeapPtr.
;d    Den Basis-MCB modifizieren, daß er nur den Teil bis HeapPtr enthält.
;
    mov    cl,es:id    ; save MCB ID
    mov    swap_prep.pmemid,cl
    mov    es:id,'M'
    mov    dx,es:paras
    mov    swap_prep.pmempar,dx
    mov    es:paras,bx
;
;e    Insert new, free, MCB at address HeapPtr.
;d    Neuen, als frei markierten, MCB an Adresse HeapPtr einfügen.
;
    mov    es,di        ; HeapPtr
    sub    dx,bx
    dec    dx
    mov    es:id,'M'
    mov    es:owner,0
    mov    bx,si        ; HeapEnd/FreeList
    sub    bx,di        ; - HeapPtr
    dec    bx        ; - 1 (MCB)
    mov    es:paras,bx
;
    sub    dx,bx
    dec    dx
    jnz    frnotempty
    inc    es:paras
    mov    es:id,cl
    jmp    short pnofree
;>e
;    There is a non-empty block after HeapEnd/FreePtr. Insert an MCB
;    with Owner = PSP.
;<
;>d
;    Es existiert ein nicht leerer Block nach HeapEnd/FreePtr. Einen
;    MCB mit Owner = PSP erzeugen.
;<
frnotempty:
    mov    es,si        ; HeapEnd/FreeList
    mov    es:id,cl
    mov    es:owner,ax
    mov    es:paras,dx
;
pnofree:
    ret
;
@freepas    endp
;>e
;    @restpas - restore original memory layout modified by @freepas
;<
;>d
;    @restpas - von @freepas modifiziertes Original-Speicher-Layout
;           wiederherstellen
;<
@restpas    proc    near
;
    mov    al,swap_prep.pmemid
    or    al,al
    jz    norestpas
    mov    bx,PrefixSeg
    dec    bx
    mov    es,bx
    mov    es:id,al
    mov    ax,swap_prep.pmempar
    mov    es:paras,ax
;
norestpas:
    ret
;
@restpas    endp
    ENDIF
    ENDIF
;
;--------------------------------------------------------------------------
;--------------------------------------------------------------------------
;
;
    IFDEF    PASCAL
    IFDEF    FARCALL
do_spawn    PROC    far swapping: word, execfname: dword, params: dword, envlen: word, envp: dword, stdin: dword, stdout: dword, stderr: dword
    ELSE
do_spawn    PROC    near swapping: word, execfname: dword, params: dword, envlen: word, envp: dword, stdin: dword, stdout: dword, stderr: dword
    ENDIF
    ELSE
do_spawn    PROC    uses si di,swapping: word, execfname:ptr byte,params:ptr byte,envlen:word,envp:ptr byte,stdin:ptr byte, stdout:ptr byte, stderr:ptr byte
    ENDIF
    local    datseg,pspseg,currmcb,dos33
;
    IFDEF    TC_HUGE
    mov    ax,SEG my_data
    mov    ds,ax
    ENDIF
;
    mov    datseg,ds        ;e save default DS
                    ;d Default-DS sichern
;
    mov    dos33,0
    mov    ax,3000h        ; get DOS version
    int    21h
    cmp    al,3
    jb    notdos33
    ja    isdos33
    cmp    ah,33
    jb    notdos33
isdos33:
    mov    dos33,1
notdos33:
;
    IFDEF    PASCAL
    cld
    mov    bx,prefixseg
    ELSE
    IFDEF    TC_HUGE
    mov    ax,SEG _psp
    mov    es,ax
    mov    bx,es:_psp
    ELSE
    mov    bx,_psp
    ENDIF
    ENDIF
    mov    pspseg,bx
;
;e    Check if spawn is too low in memory
;d    Prüfen ob dieses Modul zu weit unten im Speicher liegt
;
    mov    ax,cs
    mov    dx,offset lowcode_begin
    mov    cl,4
    shr    dx,cl
    add    ax,dx            ;e normalized start of this code
                    ;d Normalisierter Beginn des Codes
    mov    dx,keep_paras        ;e the end of the modified area
                    ;d Ende des modifizierten Bereichs
    add    dx,bx            ;e plus PSP = end paragraph
                    ;d plus PSP = letzer Paragraph
    cmp    ax,dx
    ja    doswap_ok    ;e ok if start of code > end of low mem
                ;d OK wenn Code-Beginn > Ende residenter Teil
    mov    ax,RC_TOOLOW
    ret
;
doswap_ok:
    cmp    swapping,0
    jle    method_ok
;
;e    check the swap method, to make sure prep_swap has been called
;d    Prüfen Auslagerungsmethode um sicherzustellen daß prep_swap
;d    aufgerufen wurde.
;
    mov    al,swap_prep.swapmethod
    cmp    al,USE_EMS
    je    method_ok
    cmp    al,USE_XMS
    je    method_ok
    cmp    al,USE_FILE
    je    method_ok
    mov    ax,RC_BADPREP
    ret
;>e
;    Save the memory below the swap space.
;    We must do this before swapping, so the saved memory is
;    in the swapped out image.
;    Anything else we'd want to save on the stack or anywhere
;    else in "normal" memory also has to be saved here, any
;    modifications done to memory after the swap will be lost.
;
;    Note that the memory save is done even when not swapping,
;    because we use some of the variables in low core for
;    simplicity.
;<
;>d
;    Sichern des Speichers unterhalb des Auslagerungsbereichs.
;    Dies muß vor dem Auslagern geschehen damit der gesicherte
;    Bereich mit im Ausgelagerten Abbild ist.
;    Auch alles Andere das auf dem Stack oder sonst im "normalen"
;    Speicher gesichert werden soll muß hier gesichert werden,
;    da alle Modifikationen des Speichers die nach dem Auslagern
;    erfolgen verloren gehen.
;
;    Das Sichern des Speichers ist auch notwendig wenn keine Auslagerung
;    stattfindet, da Teile des sonst residenten Bereichs im unteren
;    Speicher in jedem Fall verwendet werden.
;<
method_ok:
    mov    es,datseg
    mov    ds,pspseg        ;e DS points to PSP
                    ;d DS zeigt auf PSP
    mov    si,5ch
    mov    di,offset save_dat
    mov    cx,savespace / 2    ;e NOTE: savespace is always even
                    ;d HINWEIS: savespace ist stets gerade
    rep movsw
;
    mov    ds,datseg
    IFDEF    PASCAL
    IF    PAS_FREE
    call    @freepas
    ENDIF
    ENDIF
;
    mov    ax,swapping
    cmp    ax,0
    jg    begin_swap
;>e
;    not swapping, prep_swap wasn't called. Init those variables in
;      the 'swap_prep' block we need in any case.
;<
;>d
;    Keine Auslagerung, prep_swap wurde nicht aufgerufen. Die Variablen
;    im 'swap_prep'-Block initialisieren die in jedem Fall gebraucht werden.
;<
    mov    swap_prep.swapmethod,al
    je    no_reduce
;
    mov    ax,pspseg
    dec    ax
    mov    swap_prep.psp_mcb,ax
    mov    swap_prep.first_mcb,ax
    inc    ax
    mov    es,ax
    mov    bx,es:psp_envptr
    mov    swap_prep.env_mcb,bx
    mov    swap_prep.noswap_mcb,0
    cmp    envlen,0
    jne    swp_can_swap_env
    mov    swap_prep.noswap_mcb,bx
;
swp_can_swap_env:
    IF    NOT NO_INHERIT
    mov    swap_prep.noswap_mcb2,0
    cmp    dos33,0
    je    swp_no_exthandle
    mov    ax,es:psp_handleptrs
    mov    bx,es
    cmp    ax,bx
    je    swp_no_exthandle
    dec    ax
    mov    swap_prep.noswap_mcb2,ax
;
swp_no_exthandle:
    ENDIF
    xor    bx,bx
    mov    es,bx
    mov    ah,52h            ; get list of lists
    int    21h
    mov    ax,es
    or    ax,bx
    jz    no_reduce
    mov    es,es:[bx-2]        ; first MCB
    cmp    es:id,4dh        ; normal ID?
    jne    no_reduce
    mov    swap_prep.first_mcb,es
;
no_reduce:
    jmp    no_swap1
;
;e    set up first block descriptor
;d    Ersten Block-Deskriptor aufsetzen
;
begin_swap:
    mov    ax,swap_prep.first_mcb
    mov    currmcb,ax
    mov    es,swap_prep.psp_mcb    ;e let ES point to base MCB
                    ;d ES zeigt auf Basis-MCB
    mov    ax,es:paras
    mov    currdesc.msize,ax
    sub    ax,keep_paras
    mov    currdesc.swsize,ax
    mov    currdesc.addr,es
    mov    currdesc.swoffset,swapbeg + 16
;e        NOTE: swapbeg is 1 para higher when seen from MCB
;d        HINWEIS: swapbeg ist 1 Paragraph höher vom MCB aus gesehen
    mov    ax,swap_prep.total_mcbs
    mov    currdesc.num_follow,ax
;
;e    init other vars
;d    andere Variablen initialisieren
;
    mov    xmsctl.destlo,0
    mov    xmsctl.desthi,0
    mov    ems_curpage,0
    mov    ems_curoff,ems_parasize
;>e
;    Do the swapping. Each MCB block (except the last) has an
;    "mcbdesc" structure appended that gives location and size
;    of the next MCB.
;<
;>d
;    Auslagerung ausführen. An jeden MCB-Block (außer den letzten)
;    wird eine "mcbdesc" Struktur zur Beschreibung von Adresse und
;    Größe des nächsten Blocks angefügt.
;<
swapout_main:
    cmp    currdesc.num_follow,0    ;e next block?
                    ;d Gibt es einen nächsten?
    je    swapout_no_next        ;e ok if not
                    ;d OK wenn nein
;>e
;    There is another MCB block to be saved. So we don't have
;    to do two calls to the save routine with complicated
;    parameters, we set up the next MCB descriptor beforehand.
;    Walk the MCB chain starting at the current MCB to find
;    the next one belonging to this process.
;<
;>d
;    Es gibt einen weiteren auszulagernden MCB-Block. Um die
;    Auslagerungsroutine nicht getrennt für den MCB-Deskriptor
;    aufrufen zu müssen (mit einer entsprechend aufwendigeren
;    Parameterversorgung), wird der Deskriptor für den Folgeblock
;    vor Aufruf erstellt.
;    Dazu muß die MCB-Kette, beginnend beim derzeitigen Block,
;    durchgegangen werden um den nächsten zum Prozeß gehörenden
;    Block zu finden.
;<
    mov    ax,currmcb
    mov    bx,pspseg
    mov    cx,swap_prep.psp_mcb
    mov    dx,swap_prep.noswap_mcb
;
swm_mcb_walk:
    mov    es,ax
    cmp    ax,cx
    je    swm_next_mcb
    cmp    ax,dx
    je    swm_next_mcb
    IF    NOT NO_INHERIT
    cmp    ax,swap_prep.noswap_mcb2
    je    swm_next_mcb
    ENDIF
;
    cmp    bx,es:owner        ;e our process?
                    ;d Dieser Prozeß?
    je    swm_mcb_found        ;e found it if yes
                    ;d gefunden wenn ja
;
swm_next_mcb:
    cmp    es:id,4dh        ;e normal block?
                    ;d Normaler Block?
    jne    swm_mcb_error        ;e error if end of chain
                    ;d Fehler wenn Ende der Kette
    add    ax,es:paras        ; start + length
    inc    ax            ; next MCB
    jmp    swm_mcb_walk
;
;e    MCB found, set up an mcbdesc in the "nextmcb" structure
;d    MCB gefunden, aufsetzen mcbdesc in der "nextmcb" Struktur
;
swm_mcb_found:
    mov    nextmcb.addr,es
    mov    ax,es:paras        ;e get number of paragraphs
                    ;d Anzahl Paragraphen
    mov    nextmcb.msize,ax    ;e and save
                    ;d sichern
    inc    ax
    mov    nextmcb.swsize,ax
    mov    bx,es
    add    bx,ax
    mov    currmcb,bx
    mov    nextmcb.swoffset,0
    mov    ax,currdesc.num_follow
    dec    ax
    mov    nextmcb.num_follow,ax
;
swapout_no_next:
    cmp    swap_prep.swapmethod,USE_EMS
    je    swm_ems
    cmp    swap_prep.swapmethod,USE_XMS
    je    swm_xms
    call    swapout_file
    jmp    short swm_next
;
swm_ems:
    call    swapout_ems
    jmp    short swm_next
;
swm_xms:
    call    swapout_xms
;
swm_next:
    jnz    swapout_error
    cmp    currdesc.num_follow,0
    je    swapout_complete
;>e
;    next MCB exists, copy the "nextmcb" descriptor into
;    currdesc, and loop.
;<
;>d
;    Es gibt einen Folgeblock, der "nextmcb" Deskriptor wird in den
;    "currdesc" Deskriptor kopiert, und das ganze noch mal von vorn.
;<
    mov    es,datseg
    mov    si,offset nextmcb
    mov    di,offset currdesc
    mov    cx,TYPE mcbdesc
    rep movsb
    jmp    swapout_main
;
;
swm_mcb_error:
    mov    ax,RC_MCBERROR
;
swapout_kill:
    cmp    swapping,0
    jl    swapout_error
    push    ax
    cmp    swap_prep.swapmethod,USE_FILE
    je    swm_mcberr_file
    cmp    swap_prep.swapmethod,USE_EMS
    je    swm_mcberr_ems
;
    mov    ah,0ah            ;e release XMS frame on error
                    ;d Bei Fehler XMS-Block freigeben
    mov    dx,swap_prep.handle    ; XMS handle
    call    swap_prep.xmm
    pop    ax
    jmp    short swapout_error
;
swm_mcberr_ems:
    mov    dx,swap_prep.handle    ; EMS handle
    mov    ah,45h            ;e release EMS pages on error
                    ;d Bei Fehler EMS freigeben
    int    EMM_INT
    pop    ax
    jmp    short swapout_error
;
swm_mcberr_file:
    mov    bx,swap_prep.handle
    cmp    bx,-1
    je    swm_noclose
    mov    ah,3eh            ; close file
    int    21h
swm_noclose:
    mov    dx,offset swap_prep.swapfilename
    mov    ah,41h            ; delete file
    int    21h
    pop    ax
;
swapout_error:
    IFDEF    PASCAL
    IF    PAS_FREE
    call    @restpas
    ENDIF
    ENDIF
    ret
;
;>e
;    Swapout complete. Close the handle (EMS/file only),
;    then set up low memory.
;<
;>d
;    Auslagerung abgeschlossen. Die Datei bzw. die EMS-Seite wird
;    geschlossen, und der residente Bereich wird initialisiert.
;<
swapout_complete:
    cmp    swap_prep.swapmethod,USE_FILE
    jne    swoc_nofile
;
;e    File swap: Close the swap file to make the handle available
;d    Auslagerung auf Datei: Datei schließen um den Handle freizumachen
;
    mov    bx,swap_prep.handle
    mov    swap_prep.handle,-1
    mov    ah,3eh
    int    21h            ; close file
    mov    si,offset swapin_file
    jnc    swoc_ready
    mov    ax,RC_SWAPERROR
    jmp    swapout_kill
;
swoc_nofile:
    cmp    swap_prep.swapmethod,USE_EMS
    jne    swoc_xms
;
;e    EMS: Unmap page
;d    EMS: Seite unzugänglich machen
;
    mov    ax,4400h
    mov    bx,-1
    mov    dx,swap_prep.handle
    int    EMM_INT
    mov    si,offset swapin_ems
    jmp    short swoc_ready
;
swoc_xms:
    mov    si,offset swapin_xms
    jmp    short swoc_ready
;
no_swap1:
    mov    si,offset swapin_none
;
;e    Copy the appropriate swap-in routine to low memory.
;d    Kopieren der der Auslagerungsmethode entsprechenden Routine
;d    in den residenten Teil.
;
swoc_ready:
    mov    es,pspseg
    mov    cx,swap_codelen / 2
    mov    di,codebeg + base_length
    push    ds
    mov    ax,cs
    mov    ds,ax
    rep movsw
;>e
;    And while we're at it, copy the MCB allocation routine (which
;    also includes the initial MCB release and exec call) down.
;<
;>d
;    Außerdem die MCB-Allozierungsroutine und den EXEC-Aufruf
;    nach unten kopieren.
;<
    mov    cx,base_length / 2
    mov    di,param_len
    mov    si,offset lowcode_begin
    rep movsw
;
    pop    ds
    mov    bx,es
    dec    bx
    mov    es,bx        ;e let ES point to base MCB
                ;d ES zeigt jetzt auf den Basisblock
;>e
;    Again set up the base MCB descriptor, and copy it as well as
;    the variables set up by prep_swap to low memory.
;    This isn't too useful if we're not swapping, but it doesn't
;    hurt, either. The only variable used when not swapping is
;    lprep.swapmethod.
;<
;>d
;    Der Deskriptor für den Basisblock wird erneut aufgesetzt und,
;    zusammen mit dem Variablenblock der durch prep_swap initialisiert
;    wurde, nach unten kopieren.
;    Wenn gar nicht ausgelagert wird, ist dies eigentlich nicht nicht
;    notwendig, es schadet aber auch nicht. Die einzige Variable
;    die in diesem Fall benötigt wird ist lprep.swapmethod.
;<
    mov    ax,es:paras
    mov    currdesc.msize,ax
    sub    ax,keep_paras
    mov    currdesc.swsize,ax
    mov    currdesc.addr,es
    mov    currdesc.swoffset,swapbeg + 16
    mov    ax,swap_prep.total_mcbs
    mov    currdesc.num_follow,ax
;
    mov    es,pspseg        ;e ES points to PSP again
                    ;d ES zeigt wieder auf PSP
;
    mov    cx,TYPE prep_block
    mov    si,offset swap_prep
    mov    di,lprep
    rep movsb
    mov    cx,TYPE mcbdesc
    mov    si,offset currdesc
    mov    di,lcurrdesc
    rep movsb
;
;e    now set up other variables in low core
;d    Nun werden die weiteren Variablen im residenten Tail initialisiert.
;
    mov    ds,pspseg
    mov    ds:cgetmcb,getmcboff + codebeg
    mov    ds:eretcode,0
    mov    ds:retflags,0
;
;>e
;    If 'NO_INHERIT' is nonzero, save the entries of the
;    handle table, and set the last 15 to 0ffh (unused).
;<
;>d
;    Wenn 'NO_INHERIT' nicht 0 ist, Retten der Handle-Tabelle
;    und Setzen der letzten 15 Einträge auf 0ffh (unbenutzt).
;<
    IF    NO_INHERIT
    mov    si,psp_handletab
    mov    di,lhandlesave
    mov    cx,10
    rep movsw
    mov    si,psp_handlenum    ;e Length of handle table
                    ;d Länge Handle-Tabelle
    mov    ax,[si]
    stosw
    mov    word ptr [si],20    ;e set to default to be safe
                    ;d Auf Standardwert setzten
    add    si,2
    lodsw                ;e Handle table pointer
                    ;d Zeiger auf Handle-Tabelle
    mov    bx,ax
    stosw
    lodsw
    stosw
    cmp    dos33,0
    je    no_handlecopy
    cmp    ax,pspseg
    jne    copy_handles
    cmp    bx,psp_handletab
    je    no_handlecopy
;>e
;    if the handle table pointer in the PSP does not point to
;    the default PSP location, copy the first five entries from
;    this table into the PSP - but only if we have DOS >= 3.3.
;<
;>d
;    Wenn der Handle-Tabellen-Pointer im PSP nicht auf den
;    Standard-Platz im PSP zeigt, die ersten fünf Einträge
;    aus dieser Tabelle in den PSP kopieren - aber nur bei
;    einer DOS-Version >= 3.3.
;<
copy_handles:
    mov    ds,ax
    mov    si,bx
    mov    di,psp_handletab
    mov    es:psp_handleptro,di
    mov    es:psp_handleptrs,es
    movsw
    movsw
    movsb
;
no_handlecopy:
    mov    di,psp_handletab+5
    mov    ax,0ffffh
    stosb
    mov    cx,7
    rep stosw
;
    ENDIF
;
;e    Handle Redirection
;d    Dateiumleitung behandeln
;
    IF    REDIRECT
    mov    es,pspseg
    mov    di,lstdinsav
    mov    ax,-1
    stosw
    stosw
    stosw
    mov    di,lstdinsav
    xor    cx,cx
    IF    ptrsize
    lds    si,stdin
    mov    ax,ds
    or    ax,si
    ELSE
    mov    si,stdin
    mov    ds,datseg
    or    si,si
    ENDIF
    call    @redirect
    jc    failed_redir
    inc    cx
    IF    ptrsize
    lds    si,stdout
    mov    ax,ds
    or    ax,si
    ELSE
    mov    si,stdout
    or    si,si
    ENDIF
    call    @redirect
    jc    failed_redir
    inc    cx
    IF    ptrsize
    lds    si,stderr
    mov    ax,ds
    or    ax,si
    ELSE
    mov    si,stderr
    or    si,si
    ENDIF
    call    @redirect
    jnc    redir_complete
;
failed_redir:
    push    ax
;
;e    restore handle table and pointer
;d    Wiederherstellen Handle-Tabelle und Pointer
;
    mov    ds,pspseg
    mov    si,lstdinsav
    xor    cx,cx
;
redirclose:
    lodsw
    cmp    ax,-1
    je    redclosenext
    mov    bx,ax
    mov    ah,46h
    int    21h
;
redclosenext:
    inc    cx
    cmp    cx,3
    jb    redirclose
;
    IF    NO_INHERIT
    mov    ds,pspseg
    mov    es,pspseg
    mov    si,lhandlesave
    mov    di,psp_handletab
    mov    cx,10
    rep movsw
    mov    di,psp_handlenum
    movsw
    movsw
    movsw
    ENDIF
;
;e    Restore overwritten part of program
;d    Den überschriebenen Teil des Programms wiederherstellen
;
    mov    ds,datseg
    mov    es,pspseg
    mov    si,offset save_dat
    mov    di,5ch
    mov    cx,savespace
    rep movsb
;
    pop    ax
    mov    ah,RC_REDIRFAIL SHR 8
    jmp    swapout_kill
;
redir_complete:
    IF    NO_INHERIT
    mov    ds,pspseg
    mov    es,pspseg
    mov    si,psp_handletab+5
    mov    di,lredirsav
    mov    cx,3
    rep movsw
    mov    di,psp_handletab+5
    mov    cx,3
    mov    ax,0ffffh
    rep stosw
    ENDIF
    ENDIF
;
;e    Prepare exec parameter block
;d    Parameterblock für EXEC-Aufruf vorbereiten
;
    mov    ax,es
    mov    es:expar.fcb1seg,ax
    mov    es:expar.fcb2seg,ax
    mov    es:expar.pparseg,ax
    mov    es:expar.envseg,0
;>e
;    The 'zero' word is located at 80h in the PSP, the start of
;    the command line. So as not to confuse MCB walking programs,
;    a command line length of zero is inserted here.
;<
;>d
;    Das 'zero'-Wort ist an Adresse 80h im PSP, dem Beginn der
;    Kommandozeile. Um Programme die die MCB-Kette abarbeiten
;    und dabei möglicherweise auf diese Kommandozeile zugreifen
;    nicht zu verwirren, wird eine leere Kommandozeile eingefügt.
;<
    mov    es:zero,0d00h        ;e 00h,0dh = empty command line
                    ;d 00h,0dh = Leere Kommandozeile
;
;e    Init default fcb's by parsing parameter string
;d    Default FCB-Blöcke aus dem Parameter-String füllen
;
    IF    ptrsize
    lds    si,params
    ELSE
    mov    si,params
    mov    ds,datseg
    ENDIF
    IFDEF    PASCAL
    inc    si            ;e skip length byte
                    ;d Längenbyte überspringen
    ENDIF
    push    si
    mov    di,xfcb1
    mov    es:expar.fcb1,di
    push    di
    mov    cx,16
    xor    ax,ax
    rep stosw            ;e init both fcb's to 0
                    ;d Beide FCBs mit 0 vorbesetzen
    pop    di
    mov    ax,2901h
    int    21h
    mov    di,xfcb2
    mov    es:expar.fcb2,di
    mov    ax,2901h
    int    21h
    pop    si
;
;e    move command tail string into low core
;d    Kommandozeile in residenten Teil transferieren
;
    mov    di,progpars
    mov    es:expar.ppar,di
    xor    cx,cx
    inc    di
cmdcpy:
    lodsb
    or    al,al
    jz    cmdcpy_end
    stosb
    inc    cx
    jmp    cmdcpy
;
cmdcpy_end:
    mov    al,0dh
    stosb
    mov    es:progpars,cl
;
;e    move filename string into low core
;d    Dateinamen in residenten Teil transferieren
;
    IF    ptrsize
    lds    si,execfname
    ELSE
    mov    si,execfname
    ENDIF
    IFDEF    PASCAL
    inc    si
    ENDIF
    mov    di,filename
fncpy:
    lodsb
    stosb
    or    al,al
    jnz    fncpy
;
;e    Setup environment copy
;d    Umgebungsvariablenblock-Kopie aufsetzen
;
    mov    bx,keep_paras        ;e paras to keep
                    ;d Residente Paragraphen
    mov    cx,envlen        ;e environment size
                    ;d Größe Umgebungsvariablen
    jcxz    no_environ        ;e go jump if no environment
                    ;d Fertig wenn keine Umgebung
    cmp    swapping,0
    jne    do_envcopy
;>e
;    Not swapping, use the environment pointer directly.
;    Note that the environment copy must be paragraph aligned.
;<
;>d
;    Keine Auslagerung, der Umgebungs-Zeiger kann direkt verwendet
;    werden. Dazu muß die Kopie der Umgebungsvariablen auf Paragraphen-
;    Grenze adjustiert sein.
;<
    IF    ptrsize
    mov    ax,word ptr (envp)+2
    mov    bx,word ptr (envp)
    ELSE
    mov    ax,ds
    mov    bx,envp
    ENDIF
    add    bx,15            ;e make sure it's paragraph aligned
                    ;d auf Paragraphengrenze bringen
    mov    cl,4
    shr    bx,cl            ;e and convert to segment addr
                    ;d in Segment-Adresse konvertieren
    add    ax,bx
    mov    es:expar.envseg,ax    ;e new environment segment
                    ;d Neues Umgebungs-Segment
    xor    cx,cx            ;e mark no copy
                    ;d Markieren daß keine Kopie nötig
    xor    bx,bx            ;e and no shrink
                    ;d und keine Speicherreduzierung
    jmp    short no_environ
;>e
;    Swapping or EXECing without return. Set up the pointers for
;    an environment copy (we can't do the copy yet, it might overwrite
;    this code).
;<
;>d
;    Auslagerung, oder EXEC ohne Rückkehr. Die Zeiger für das
;    kopieren der Umgebungsvariablen aufsetzen. Der Block darf
;    jetzt noch nicht kopiert werden, da dies eventuell den gerade
;    ausgeführten Code überschreiben könnte.
;<
do_envcopy:
    inc    cx
    shr    cx,1            ;e words to copy
                    ;d Zu kopierende Worte
    mov    ax,cx            ;e convert envsize to paras
                    ;d in Paragraphen konvertieren
    add    ax,7
    shr    ax,1
    shr    ax,1
    shr    ax,1
    add    bx,ax            ;e add envsize to paras to keep
                    ;d Größe zu residenter addieren
    IF    ptrsize
    lds    si,envp
    ELSE
    mov    si,envp
    ENDIF
;
    mov    ax,es            ;e low core segment
                    ;d Segmentadresse residenter Teil
    add    ax,keep_paras        ;e plus fixed paras
                    ;d plus residente Paragraphen
    mov    es:expar.envseg,ax    ;e = new environment segment
                    ;d = neues Umgebungs-Segment
;
;e    Save stack regs, switch to local stack
;d    Sichern Stack-Register, Umschalten auf lokalen Stack
;
no_environ:
    mov    es:save_ss,ss
    mov    es:save_sp,sp
    mov    ax,es
    cli
    mov    ss,ax
    mov    sp,mystack
    sti
;
    push    cx            ; save env length
    push    si            ; save env pointer
    push    ds            ; save env segment
;
;e    save and patch INT0 (division by zero) vector
;d    Sichern und überschreiben INT0 (division by zero) Vektor
;
    xor    ax,ax
    mov    ds,ax
    mov    ax,word ptr ds:0
    mov    es:div0_off,ax
    mov    ax,word ptr ds:2
    mov    es:div0_seg,ax
    mov    word ptr ds:0,codebeg + iretoff
    mov    word ptr ds:2,es
;
    pop    ds            ; pop environment segment
    pop    si            ; pop environment offset
    pop    cx            ; pop environment length
    mov    di,swapbeg        ;e environment destination
                    ;d Zieladresse Umgebungsblock
;
;e    Push return address on local stack
;d    Rückkehradresse auf lokalen Stack bringen
;
    push    cs            ;e push return segment
                    ;d Rückkehr-Segment pushen
    mov    ax,offset exec_cont
    push    ax            ;e push return offset
                    ;d Rückkehr-Offset pushen
    mov    es:spx,sp        ;e save stack pointer
                    ;d Stack-Zeiger sichern
;
;e    Goto low core code
;d    In den residenten Teil springen
;
    push    es            ;e push entry segment
                    ;d Einsprungssegment pushen
        mov    ax,codebeg + doexec_entry
        push    ax            ;e push entry offset
                    ;d Einsprungsoffset pushen
;e    ret    far            ; can't use RET here because
;d    ret    far            ; RET kann hier wegen der .model-
    db    0cbh            ;e of .model
                    ;d Direktive nicht verwendet werden
;
;----------------------------------------------------------------
;>e
;    Low core code will return to this location, with DS set to
;    the PSP segment.
;<
;>d
;    Der residente Teil kehrt hierher zurück, mit DS = PSP-Segment.
;<
exec_cont:
    push    ds
    pop    es
    cli
    mov    ss,ds:save_ss        ;e reload stack
                    ;d Stack zurückladen
    mov    sp,ds:save_sp
    sti
;
;e    restore handle table and pointer
;d    Wiederherstellen Handle-Tabelle und Pointer
;
    IF    NO_INHERIT
    mov    si,lhandlesave
    mov    di,psp_handletab
    mov    cx,10
    rep movsw
    mov    di,psp_handlenum
    movsw
    movsw
    movsw
    ENDIF
;
;e    restore INT0 (division by zero) vector
;d    INT0 (division by zero) Vektor wiederherstellen
;
    xor    cx,cx
    mov    ds,cx
    mov    cx,es:div0_off
    mov    word ptr ds:0,cx
    mov    cx,es:div0_seg
    mov    word ptr ds:2,cx
;
    mov    ds,datseg
;
    IFDEF    PASCAL
    IF    PAS_FREE
    push    es
    call    @restpas
    pop    es
    ENDIF
    ENDIF
;
    mov    ax,es:eretcode
    mov    bx,es:retflags
;
;e    Restore overwritten part of program
;d    Den überschriebenen Teil des Programms wiederherstellen
;
    mov    si,offset save_dat
    mov    di,5ch
    mov    cx,savespace
    rep movsb
;
    test    bx,1            ;e carry set?
                    ;d Carry-Flag gesetzt?
    jnz    exec_fault        ;e return EXEC error code if fault
                    ;d EXEC Fehler-code liefern wenn ja
    mov    ah,4dh            ;e else get program return code
                    ;d Sonst Programm-Rückgabewert holen
    int    21h
    ret
;
exec_fault:
    mov    ah,3            ;e return error as 03xx
                    ;d EXEC-Fehler als 03xx liefern
    ret
;
do_spawn    ENDP
;
;----------------------------------------------------------------------------
;----------------------------------------------------------------------------
;
emm_name    db    'EMMXXXX0'
;>e
;    prep_swap - prepare for swapping.
;
;    This routine checks all parameters necessary for swapping,
;    and attempts to set up the swap-out area in EMS/XMS, or on file.
;    In detail:
;
;         1) Check whether the do_spawn routine is located
;        too low in memory, so it would get overwritten.
;        If this is true, return an error code (-2).
;
;         2) Walk the memory control block chain, adding up the
;        paragraphs in all blocks assigned to this process.
;
;         3) Check EMS (if the method parameter allows EMS):
;        - is an EMS driver installed?
;        - are sufficient EMS pages available?
;        if all goes well, the EMS pages are allocated, and the
;        routine returns success (1).
;
;         4) Check XMS (if the method parameter allows XMS):
;        - is an XMS driver installed?
;        - is a sufficient XMS block available?
;        if all goes well, the XMS block is allocated, and the
;        routine returns success (2).
;
;         5) Check file swap (if the method parameter allows it):
;        - try to create the file
;        - pre-allocate the file space needed by seeking to the end
;          and writing a byte.
;        If the file can be written, the routine returns success (4).
;
;         6) Return an error code (-1).
;<
;>d
;    prep_swap - Auslagerung vorbereiten.
;
;    Diese Routine prüft die zur Auslagerung nötigen Parameter,
;    und versucht den Auslagerungsbereich in EMS, XMS, oder auf Datei,
;    vorzubereiten.
;    Im einzelnen:
;
;         1) Prüfen ob die do_spawn-Routine so niedrig liegt daß
;        sie durch die Auslagerung überschrieben würde.
;        Ist dies der Fall, Fehler (-2) liefern.
;
;         2) Die MCB-Kette durchlaufen, dabei die Länge in Paragraphen
;        aller Blöcke addieren die zu diesem Prozeß gehören.
;
;         3) EMS prüfen (wenn der method Parameter EMS erlaubt):
;        - ist ein EMS Treiber installiert?
;        - sind genügend EMS-Seiten verfügbar?
;        Wenn dies erfüllt ist, werden die EMS-Seiten alloziert,
;        und die Routine liefert einen Erfolgscode (1).
;
;         4) XMS prüfen (wenn der method Parameter XMS erlaubt):
;        - ist ein XMS Treiber installiert?
;        - ist ein ausreichend großer XMS-Bereich verfügbar?
;        Wenn dies erfüllt ist, wird der XMS-Bereich alloziert,
;        und die Routine liefert einen Erfolgscode (2).
;
;         5) Dateiauslagerung prüfen (wenn der method Parameter es erlaubt):
;        - die Datei erzeugen,
;        - den benötigten Platz auf Datei prä-allozieren indem
;          an das Ende positioniert und ein Byte geschrieben wird.
;        Konnte die Datei geschrieben werden, liefert die Routine
;        einen Erfolgscode (4).
;
;         6) Fehlercode liefern (-1).
;<
    IFDEF    PASCAL
    IFDEF    FARCALL
prep_swap    PROC    far pmethod: word, swapfname: dword
    ELSE
prep_swap    PROC    near pmethod: word, swapfname: dword
    ENDIF
    ELSE
prep_swap    PROC    uses si di,pmethod:word,swapfname:ptr byte
    ENDIF
    LOCAL    totparas: word
;
    IFDEF    TC_HUGE
    mov    ax,SEG my_data
    mov    ds,ax
    ENDIF
;
    IFDEF    PASCAL
    cld
    mov    ax,prefixseg
    ELSE
    IFDEF    TC_HUGE
    mov    ax,SEG _psp
    mov    es,ax
    mov    ax,es:_psp
    ELSE
    mov    ax,_psp
    ENDIF
    ENDIF
;
    dec    ax
    mov    swap_prep.psp_mcb,ax
    mov    swap_prep.first_mcb,ax    ;e init first MCB to PSP
                    ;d ersten MCB auf PSP initialisieren
;
;e    Make a copy of the environment pointer in the PSP
;d    Eine Kopie vom Umgebungsvariablenblock-Pointer des PSP sichern
;
    inc    ax
    mov    es,ax
    mov    bx,es:psp_envptr
    dec    bx
    mov    swap_prep.env_mcb,bx
    mov    swap_prep.noswap_mcb,0
    test    pmethod,DONT_SWAP_ENV
    jz    can_swap_env
    mov    swap_prep.noswap_mcb,bx
;
can_swap_env:
    IF    NOT NO_INHERIT
    push    ax
    mov    swap_prep.noswap_mcb2,0
    mov    ax,3000h
    int    21h
    cmp    al,3
    jb    no_exthandle
    ja    check_exthandle
    cmp    ah,33
    jb    no_exthandle
;
check_exthandle:
    mov    ax,es:psp_handleptrs
    mov    bx,es
    cmp    ax,bx
    je    no_exthandle
    dec    ax
    mov    swap_prep.noswap_mcb2,ax
;
no_exthandle:
    pop    ax
    ENDIF
;
;e    Check if spawn is too low in memory
;d    Prüfen ob dieses Modul zu weit unten im Speicher liegt
;
    mov    bx,cs
    mov    dx,offset lowcode_begin
    mov    cl,4
    shr    dx,cl
    add    bx,dx            ;e normalized start of this code
                    ;d Normalisierter Beginn des Codes
    mov    dx,keep_paras        ;e the end of the modified area
                    ;d Ende des modifizierten Bereichs
    add    dx,ax            ;e plus PSP = end paragraph
                    ;d plus PSP = letzer Paragraph
    cmp    bx,dx
    ja    prepswap_ok    ;e ok if start of code > end of low mem
                ;d OK wenn Code-Beginn > Ende residenter Teil
    mov    ax,-2
    mov    swap_prep.swapmethod,al
    ret
;>e
;    Walk the chain of memory blocks, adding up the paragraphs
;    in all blocks belonging to this process.
;    We try to find the first MCB by getting DOS's "list of lists",
;    and fetching the word at offset -2 of the returned address.
;    If this fails, we use our PSP as the starting point.
;<
;>d
;    Die Speicherblöcke durchgehen und die Größe aller zu diesem
;    Prozeß gehörenden Blöcke zusammenzählen.
;    Der Anfang der MCB-Liste wird aus der DOS "list of lists"
;    abgeleitet. Das Wort an Offset -2 der gelieferten Adresse
;    enthält die erste MCB-Adresse. Falls dies fehlschlägt, wird
;    der PSP als Ausgangspunkt benutzt.
;<
prepswap_ok:
    IFDEF    PASCAL
    IF    PAS_FREE
    call    @freepas
    ENDIF
    ENDIF
    xor    bx,bx
    mov    es,bx
    mov    ah,52h            ; get list of lists
    int    21h
    mov    ax,es
    or    ax,bx
    jz    prep_no_first
    mov    es,es:[bx-2]        ; first MCB
    cmp    es:id,4dh        ; normal ID?
    jne    prep_no_first
    mov    swap_prep.first_mcb,es
;
prep_no_first:
    mov    es,swap_prep.psp_mcb    ;e ES points to base MCB
                    ;d ES zeigt auf Basis-Block
    mov    cx,es            ;e save this value
                    ;d diesen Wert sichern
    mov    bx,es:owner        ;e the current process
                    ;d Der aktuelle Prozeß
    mov    dx,es:paras        ;e memory size in the base block
                    ;d Speichergröße des Basisblocks
    sub    dx,keep_paras        ;e minus resident paragraphs
                    ;d Abzüglich residente Paragraphen
    mov    si,0            ;e number of MCBs except base
                    ;d Zähler für MCBs außer Basis
    mov    di,swap_prep.noswap_mcb
    mov    ax,swap_prep.first_mcb
    mov    swap_prep.first_mcb,0
;
prep_mcb_walk:
    mov    es,ax
    cmp    ax,cx            ;e base block?
                    ;d Basisblock?
    je    prep_walk_next        ;e then don't count again
                    ;d dann nicht nochmal zählen
    cmp    ax,di            ;e Non-swap MCB?
    je    prep_walk_next        ;e then don't count
                    ;d dann nicht zählen
    IF    NOT NO_INHERIT
    cmp    ax,swap_prep.noswap_mcb2
    je    prep_walk_next
    ENDIF
;
    cmp    bx,es:owner        ;e our process?
                    ;d aktueller Prozeß?
    jne    prep_walk_next        ;e next if not
                    ;d nächsten wenn nein
    inc    si
    mov    ax,es:paras        ;e else get number of paragraphs
                    ;d sonst Größe in Paragraphen laden
    add    ax,2            ; + 1 for descriptor + 1 for MCB
    add    dx,ax            ;e total number of paras
                    ;d Gesamtzahl Paragraphen
    cmp    swap_prep.first_mcb,0
    jne    prep_walk_next
    mov    swap_prep.first_mcb,es
;
prep_walk_next:
    cmp    es:id,4dh        ;e normal block?
                    ;d normaler Block?
    jne    prep_mcb_ready        ;e ready if end of chain
                    ;d Fertig wenn ende der Kette
    mov    ax,es
    add    ax,es:paras        ; start + length
    inc    ax            ; next MCB
    jmp    prep_mcb_walk
;
prep_mcb_ready:
    mov    totparas,dx
    mov    swap_prep.total_mcbs,si
;
    IFDEF    PASCAL
    IF    PAS_FREE
    call    @restpas
    ENDIF
    ENDIF
;
    test    pmethod,XMS_FIRST
    jnz    check_xms
;
;e    Check for EMS swap
;d    EMS-auslagerung prüfen
;
check_ems:
    test    pmethod,USE_EMS
    jz    prep_no_ems
;
    push    ds
    mov    al,EMM_INT
    mov    ah,35h
    int    21h            ;e get EMM int vector
                    ;d EMM-Interrupt Vektor laden
    mov    ax,cs
    mov    ds,ax
    mov    si,offset emm_name
    mov    di,10
    mov    cx,8
    repz cmpsb            ;e EMM name present?
                    ;d ist der EMM-Name vorhanden?
    pop    ds
    jnz    prep_no_ems
;
    mov    ah,40h            ;e get EMS status
                    ;d EMS-Status abfragen
    int    EMM_INT
    or    ah,ah            ; EMS ok?
    jnz    prep_no_ems
;
    mov    ah,46h            ;e get EMS version
                    ;d EMS-Version abfragen
    int    EMM_INT
    or    ah,ah            ; AH must be 0
    jnz    prep_no_ems
;
    cmp    al,30h            ; >= version 3.0?
    jb    prep_no_ems
;
    mov    ah,41h            ;e Get page frame address
                    ;d EMS-Frame-Adresse holen
    int    EMM_INT
    or    ah,ah
    jnz    prep_no_ems
;
;e    EMS present, try to allocate pages
;d    EMS vorhanden, versuche Seiten zu allozieren
;
    mov    swap_prep.ems_pageframe,bx
    mov    bx,totparas
    add    bx,ems_paramask
    mov    cl,ems_shift
    shr    bx,cl
    mov    ah,43h            ; allocate handle and pages
    int    EMM_INT
    or    ah,ah            ;e success?
                    ;d erfolgreich?
    jnz    prep_no_ems
;
;e    EMS pages allocated, swap to EMS
;d    EMS-Seiten alloziert, auslagern auf EMS
;
    mov    swap_prep.handle,dx
    mov    ax,USE_EMS
    mov    swap_prep.swapmethod,al
    ret
;
;e    No EMS allowed, or EMS not present/full. Try XMS.
;d    EMS nicht erlaubt, oder EMS nicht vorhanden/voll. XMS versuchen.
;
prep_no_ems:
    test    pmethod,XMS_FIRST
    jnz    check_file        ;e don't try again
                    ;d nicht nochmal versuchen
;
check_xms:
    test    pmethod,USE_XMS
    jz    prep_no_xms
;
    mov    ax,4300h        ;e check if XMM driver present
                    ;d prüfen ob XMM-Treiber vorhanden
    int    2fh
    cmp    al,80h            ;e is XMM installed?
                    ;d ist XMM installiert?
    jne    prep_no_xms
    mov    ax,4310h        ;e get XMM entrypoint
                    ;d XMM-Einsprungadresse holen
    int    2fh
    mov    word ptr swap_prep.xmm,bx    ;e save entry address
                    ;d Einsprungadresse sichern
    mov    word ptr swap_prep.xmm+2,es
;
    mov    dx,totparas
    add    dx,xms_paramask        ;e round to nearest multiple of 1k
                    ;d Auf volle 1k aufrunden
    mov    cl,xms_shift
    shr    dx,cl            ;e convert to k
                    ;d konvertiern in k
    mov    ah,9            ;e allocate extended memory block
                    ;d Extended memory block allozieren
    call    swap_prep.xmm
    or    ax,ax
    jz    prep_no_xms
;
;e    XMS block allocated, swap to XMS
;d    XMS-Block alloziert, Auslagern auf XMS.
;
    mov    swap_prep.handle,dx
    mov    ax,USE_XMS
    mov    swap_prep.swapmethod,al
    ret
;
;e    No XMS allowed, or XMS not present/full. Try File swap.
;d    XMS nicht erlaubt, oder XMS nicht vorhanden/voll. Datei versuchen.
;
prep_no_xms:
    test    pmethod,XMS_FIRST
    jz    check_file
    jmp    check_ems
;
check_file:
    test    pmethod,USE_FILE
    jnz    prep_do_file
    jmp    prep_no_file
;
prep_do_file:
    push    ds
    IF    ptrsize
    lds    dx,swapfname
    ELSE
    mov    dx,swapfname
    ENDIF
    IFDEF    PASCAL
    inc    dx            ;e skip length byte
                    ;d Längenbyte überspringen
    ENDIF
    mov    cx,2            ; hidden attribute
    test    pmethod,HIDE_FILE
    jnz    prep_hide
    xor    cx,cx            ; normal attribute
;
prep_hide:
    mov    ah,3ch            ; create file
    test    pmethod,CREAT_TEMP
    jz    prep_no_temp
    mov    ah,5ah
;
prep_no_temp:
    int    21h            ; create/create temp
    jnc    prep_got_file
    jmp    prep_no_file
;
prep_got_file:
    mov    bx,ax            ; handle
;
;e    save the file name
;d    Dateinamen sichern
;
    pop    es
    push    es
    mov    di,offset swap_prep.swapfilename
    mov    cx,81
    mov    si,dx
    rep movsb
;
    pop    ds
    mov    swap_prep.handle,bx
;
;e    preallocate the file
;d    Datei-Speicherplatz prä-allozieren
;
    test    pmethod,NO_PREALLOC
    jnz    prep_noprealloc
    test    pmethod,CHECK_NET
    jz    prep_nonetcheck
;
;e    check whether file is on a network drive, and don't preallocate
;e    if so. preallocation can slow down swapping significantly when
;e    running on certain networks (Novell)
;d    Prüfen ob Datei auf einem Netwerk-Laufwerk liegt, und nicht
;d    präallozieren wenn ja. Ein Präallozieren kann den Swap-Vorgang
;d    erheblich verlangsamen wenn es auf Novell-Drives ausgeführt wird.
;
    mov    ax,440ah    ; check if handle is remote
    int    21h
    jc    prep_nonetcheck    ;e assume not remote if function fails
                ;d kein Netz wenn Funktion Fehler liefert
    test    dh,80h        ;e DX bit 15 set ?
                ;d Ist Bit 15 von DX gesetzt?
    jnz    prep_noprealloc    ;e remote if yes
                ;d Netzwerk-Datei wenn ja
;
prep_nonetcheck:
    mov    dx,totparas
    mov    cl,4
    rol    dx,cl
    mov    cx,dx
    and    dx,0fff0h
    and    cx,0000fh
    sub    dx,1
    sbb    cx,0
    mov    si,dx            ; save
    mov    ax,4200h        ; move file pointer, absolute
    int    21h
    jc    prep_file_err
    cmp    dx,cx
    jne    prep_file_err
    cmp    ax,si
    jne    prep_file_err
    mov    cx,1            ;e write 1 byte
                    ;d 1 Byte schreiben
    mov    ah,40h
    int    21h
    jc    prep_file_err
    cmp    ax,cx
    jne    prep_file_err
;
    mov    ax,4200h        ; move file pointer, absolute
    xor    dx,dx
    xor    cx,cx            ;e rewind to beginning
                    ;d Auf Anfang zurückpositionieren
    int    21h
    jc    prep_file_err
;
prep_noprealloc:
    mov    ax,USE_FILE
    mov    swap_prep.swapmethod,al
    ret
;
prep_file_err:
    mov    ah,3eh            ; close file
    int    21h
    mov    dx,offset swap_prep.swapfilename
    mov    ah,41h            ; delete file
    int    21h
;
prep_no_file:
    mov    ax,-1
    mov    swap_prep.swapmethod,al
    ret
;
prep_swap    endp
;
    end