Gestione a basso livello della memoria

Il compilatore C 

Memoria convenzionale 

/********************

    BARNINGA_Z! - 1991

    DOSSEG.C - getdosseg()

    unsigned cdecl getdosseg(void);
    Restituisce: l'indirizzo di segmento di IO.SYS o IBMDOS.COM

    COMPILABILE CON TURBO C++ 2.0

        tcc -O -d -c -mx dosseg.c

    dove -mx puo' essere -mt -ms -mc -mm -ml -mh

********************/
#include <dos.h>

unsigned cdecl getdosseg(void)
{
    union REGS regs;
    struct SREGS sregs;

    regs.h.ah = 0x34;
    intdos(&regs,&regs);
    segread(&sregs);
    return(sregs.es);
}

/********************

    BARNINGA_Z! - 1991

    DOSSEG.C - getdosseg()

    unsigned cdecl getdosseg(void);
    Restituisce: l'indirizzo di segmento di IO.SYS o IBMDOS.COM

    COMPILABILE CON BORLAND C++ 2.0

        bcc -O -d -c -k- -mx dosaddr.c

    dove -mx puo' essere -mt -ms -mc -mm -ml -mh

********************/
#pragma  inline
#pragma  option -k-      // per maggiore efficienza

unsigned cdecl getdosseg(void)
{
    _AX = 0x34;
    asm int 21h;
    return(_ES);
}

/********************

    BARNINGA_Z! - 1991

    FIRSTMCB.C - getfirstmcb()

    unsigned cdecl getfirstmcb(void);
    Restituisce: l'indirizzo di segmento del primo MCB

    COMPILABILE CON BORLAND C++ 2.0

        bcc -O -d -c -mx firstmcb.c

    dove -mx puo' essere -mt -ms -mc -mm -ml -mh

********************/
#include <dos.h>

unsigned cdecl getfirstmcb(void)
{
    union REGS regs;
    struct SREGS sregs;

    regs.h.ah = 0x52;
    intdos(&regs,&regs);
    segread(&sregs);
    return(*(unsigned far *)MK_FP(sregs.es,regs.x.bx-2));
}

/********************

    BARNINGA_Z! - 1991

    FIRSTMCB.C - getfirstmcb()

    unsigned cdecl getfirstmcb(void);
    Restituisce: l'indirizzo di segmento del primo MCB

    COMPILABILE CON BORLAND C++ 2.0

        bcc -O -d -c -k- -mx firstmcb.c

    dove -mx puo' essere -mt -ms -mc -mm -ml -mh

********************/
#pragma  inline
#pragma  option -k-      // per maggiore efficienza

unsigned cdecl getfirstmcb(void)
{
    asm mov ah,52h;
    asm int 21h;
    asm mov ax,es:[bx-2];
    return(_AX);
}

struct MCB {
    char     pos;
    unsigned psp;
    unsigned dim;
    char     reserved[3];
    char     name[8];
};

/********************

    BARNINGA_Z! - 1991

    PARSEMCB.C - parsemcb()

    unsigned cdecl parsemcb(struct MCB *mcb,unsigned mcbseg);
    struct MCB *mcb;     puntatore ad una struttura di tipo MCB: deve
                         essere gia' allocata
    unsigned   ncbseg;   indirizzo (segmento) del MCB da copiare

    Restituisce: l'indirizzo (segmento) dell'area di RAM controllata dal
                 MCB dopo avere copiato il contenuto del MCB nella
                 struttura mcb.

    COMPILABILE CON BORLAND C++ 2.0

        bcc -O -d -c -mx parsemcb.c

    dove -mx puo' essere -mt -ms -mc -mm -ml -mh

********************/
#pragma  inline

#include <dos.h>

unsigned cdecl parsemcb(struct MCB *mcb,unsigned mcbseg)
{
    asm push ds;

#if defined(__TINY__) || defined(__SMALL__) || defined(__MEDIUM__)

    asm push ds;   // il compilatore assume che nei modelli "piccoli"
    asm pop es;    // SS e DS coincidano, percio' si puo' usare DS
    asm mov di,mcb;

#else

    asm les di,dword ptr mcb;      // modello dati "grandi": mcb e' una doubleword

#endif

    asm mov ds,mcbseg;     // DS:SI punta al Memory Control Block
    asm xor si,si; // ES:DI punta alla struttura mcb
    asm mov cx,8;  // copia 8 words (16 bytes)
    asm cld;
    asm cli;
    asm rep movsw;
    asm sti;
    asm pop ds;
    return(mcbseg+1);
}

/********************

    BARNINGA_Z! - 1991

    MCBCHAIN.C - getmcbchain()

    struct MCB * cdecl getmcbchain(unsigned basemcb);
    unsigned basemcb;    indirizzo (segmento) del primo MCB della catena.
    Restituisce: un puntatore ad un array di strutture di tipo MCB.

    COMPILABILE CON BORLAND C++ 2.0

        bcc -O -d -c -mx mcbchain.c

    dove -mx puo' essere -mt -ms -mc -mm -ml -mh

********************/
#include <stdio.h>      // per NULL
#include <alloc.h>      // per malloc() e realloc()

struct MCB * cdecl getmcbchain(unsigned basemcb)
{
    register i;
    unsigned mcbseg;
    struct MCB *mcb;

    if(!(mcb = (struct MCB *)malloc(sizeof(struct MCB))))
        return(NULL);
    mcbseg = parsemcb(mcb,basemcb);
    mcbseg += mcb->dim;    // segmento MCB + 1 + dimensione MCB = segmento
    i = 1; // del MCB successivo
    do {
        if(!(mcb = (struct MCB *)realloc(mcb,(i+1)*sizeof(struct MCB))))
            return(NULL);
        mcbseg = parsemcb(mcb+i,mcbseg);
        mcbseg += mcb[i].dim;
    } while(mcb[i++].pos != 'Z'); // i e' incrementata dopo il confronto
    return(mcb);
}

/********************

    BARNINGA_Z! - 1992

    ALCSTRAT.C - getallocstrategy()

    int cdecl getallocstrategy(void);
    Restituisce: la strategia di allocazione DOS. In caso di errore
                 restituisce -1.

    COMPILABILE CON TURBO C++ 2.0

        tcc -O -d -c -mx alcstrat.c

    dove -mx puo' essere -mt -ms -mc -mm -ml -mh

********************/
#pragma  inline
#pragma  option -k-      // maggiore efficienza

int cdecl getallocstrategy(void)
{
    _AX = 0x5800;
    asm int 21h;
    asm jnc EXITFUNC;
    _AX = -1;
EXITFUNC:
    return(_AX);
}

Upper memory 

/********************

    BARNINGA_Z! - 1991

    UMBDOS.C - testforDOS()

    unsigned cdecl testforDOS(void);
    Restituisce: l'indirizzo (segmento) del MCB corrispondente al primo
                 UMB (area di RAM sopra i 640 Kb). Restituisce NULL se
                 non riesce ad individuare la catena di UMB.

    COMPILABILE CON TURBO C++ 2.0

        tcc -O -d -c -mx umbdos.c

    dove -mx puo' essere -mt -ms -mc -mm -ml -mh

********************/
#include <stdio.h>      // per NULL
#include <string.h>     // per strncmp()

unsigned cdecl testforDOS(void)
{
    unsigned segbase, umbseg;
    struct MCB umb;        // struct MCB e parsemcb() sono gia' note

    segbase = ((*(unsigned far *)0x413)*64)-1;
    parsemcb(&umb,segbase);
    if((umb.pos == 'M') && (umb.psp == 0x0008)) {
        parsemcb(&umb,umbseg = segbase+umb.dim);
        if(((umb.pos == 'M') || (umb.pos == 'Z')) &&
                (umb.psp == umbseg+1) && (!strncmp(umb.name,"UMB     ",8)))
            return(segbase);
    }
    return(NULL);
}

/********************

    BARNINGA_Z! - 1991

    UMBQEMM.C - testforQEMM386()

    unsigned cdecl testforQEMM386(void);
    Restituisce: l'indirizzo (segmento) del MCB corrispondente al primo
                 UMB (area di RAM sopra i 640 Kb). Restituisce NULL se
                 non riesce ad individuare la catena di UMB.

    COMPILABILE CON TURBO C++ 2.0

        tcc -O -d -c -mx umbqemm.c

    dove -mx puo' essere -mt -ms -mc -mm -ml -mh

********************/
#pragma  inline
#pragma  option -k-      // non indispensabile, ma aggiunge efficienza

#include <stdio.h>      // per NULL
#include <string.h>     // per strncmp()

unsigned cdecl testforQEMM386(void)
{
    asm {
        mov ax,0D200h;
        mov bx,05144h;
        mov cx,04D45h;
        mov dx,04D30h;
        int 2Fh;
        cmp ax,0D2FFh;
        jne NOTQEMM386;
        cmp bx,04D45h;
        jne NOTQEMM386;
        cmp cx,04D44h;
        jne NOTQEMM386;
        cmp dx,05652h;
        jne NOTQEMM386;
        mov ax,0D201h;
        mov bx,04849h;
        mov cx,05241h;
        mov dx,04D30h;
        int 0x2F;
        cmp ax,0D201h;
        jne NOTQEMM386;
        cmp bx,04F4Bh;
        jne NOTQEMM386;
        jmp EXITFUNC;
    }
NOTQEMM386:
    asm xor cx,cx;
EXITFUNC:
    return(_CX);
}

Memoria espansa 

/********************

    BARNINGA_Z! - 1991

    EMMTEST.C - testEMM()

    int cdecl testEMM(void);
    Restituisce: 1 se il driver EMM e' installato
                 0 altrimenti

    COMPILABILE CON TURBO C++ 2.0

        tcc -O -d -c -mx emmtest.c

    dove -mx puo' essere -mt -ms -mc -mm -ml -mh

********************/
#pragma  warn -pia

#include <stdio.h>      // per NULL
#include <dos.h>
#include <io.h>
#include <fcntl.h>

int cdecl testEMM(void) /* uso della memoria espansa */
{
    int handle, retcode;
    struct REGPACK r;

    if((handle = open("EMMXXXX0",O_RDONLY)) == -1) // apre handle
        return(NULL);
    retcode = NULL;
    r.r_ax = 0x4400;       // e' proprio un device?
    r.r_bx = handle;
    intr(0x21,&r);
    if(!(r.r_flags & 1) && (r.r_dx & 0x80)) {
        r.r_ax = 0x4407;       // il device e' ready?
        intr(0x21,&r);
        if(!(r.r_flags & 1) && (r.r_ax & 0xFF))
            retcode = 1;
    }
    close(handle);
    return(retcode);
}

#include <dos.h>
#include <string.h>

#define  EMMNAME    "EMMXXXX0"

int cdecl testEMM2(void)
{
    struct REGPACK r;

    r.r_ax = 0x3567;       // richiede il vettore dell'int 67h
    intr(0x21,&r);
    return(!_fstrncmp((char far *)MK_FP(r.r_es,10),EMMNAME,strlen(EMMNAME)));
}

/********************

    BARNINGA_Z! - 1991

    EMMVER.C - getEMMversion()

    unsigned cdecl getEMMversion(void);
    Restituisce: la versione del driver EMM (versione nel byte meno
                 significativo, revisione nel byte piu' significativo:
                 4.0 e' restituito come 0x0004).
                 Se si e' verificato un errore restituisce un numero
                 negativo (il codice d'errore EMS cambiato di segno).

    COMPILABILE CON TURBO C++ 2.0

        tcc -O -d -c -mx -k- emmver.c

    dove -mx puo' essere -mt -ms -mc -mm -ml -mh

********************/
#pragma  inline
#pragma  option -k-

unsigned cdecl getEMMversion(void)      /* ottiene la versione LIM */
{
    asm {
        mov ah,0x46;
        int 0x67;
        cmp ah,0;
        je SETVER;
        mov al,ah;
        xor ah,ah;
        neg ax;
        jmp EXITFUNC;
    }
SETVER:
    asm {
        mov cx,4;
        mov ah,al;
        shr al,cl;
        and ax,0F0Fh;
    }
EXITFUNC:
    return(_AX);
}

/********************

    BARNINGA_Z! - 1991

    EMMFRAME.C - getEMMframeAddr()

    unsigned cdecl getEMMframeAddr(void);
    Restituisce: l'indirizzo (segmento) della Page Frame.
                 Se si e' verificato un errore restituisce un numero
                 negativo (il codice d'errore EMS cambiato di segno).

    COMPILABILE CON TURBO C++ 2.0

        tcc -O -d -c -mx -k- emmframe.c

    dove -mx puo' essere -mt -ms -mc -mm -ml -mh

********************/
#pragma  inline
#pragma  option -k-      /* non indispensabile; accresce l'efficienza */

unsigned cdecl getEMMframeAddr(void)
{
    asm {
        mov ah,0x41;
        int 0x67;
        cmp ah,0;
        je EXITFUNC;
        mov al,ah;
        xor ah,ah;
        neg ax;
        mov bx,ax;
    }
EXITFUNC:
    return(_BX);
}

/********************

    BARNINGA_Z! - 1991

    EMMTOTP.C - getEMMtotPages()

    int cdecl getEMMtotPages(void);
    Restituisce: il numero di pagine totali EMS
                 Se < 0 si e' verificato un errore; il valore cambiato di segno
                 e' il codice di errore EMS

    COMPILABILE CON TURBO C++ 2.0

        tcc -O -d -c -mx emmtotp.c

    dove -mx puo' essere -mt -ms -mc -mm -ml -mh

********************/
#include <dos.h>

int cdecl getEMMtotPages(void)
{
    struct REGPACK r;

    r.r_ax = 0x4200;
    intr(0x67,&r);
    if(!(r.r_ax & 0xFF00))
        return(r.r_dx);
    return(-((r.r_ax >> 8) & 0xFF));
}

/********************

    BARNINGA_Z! - 1991

    EMMFREEP.C - getEMMfreePages()

    int cdecl getEMMfreePages(void);
    Restituisce: il numero di pagine libere EMS
                 Se < 0 si e' verificato un errore; il valore cambiato di segno
                 e' il codice di errore EMS

    COMPILABILE CON TURBO C++ 2.0

        tcc -O -d -c -mx emmfreep.c

    dove -mx puo' essere -mt -ms -mc -mm -ml -mh

********************/
#include <dos.h>

int cdecl getEMMfreePages(void)
{
    struct REGPACK r;

    r.r_ax = 0x4200;
    intr(0x67,&r);
    if(!(r.r_ax & 0xFF00))
        return(r.r_bx);
    return(-((r.r_ax >> 8) & 0xFF));
}

/********************

    BARNINGA_Z! - 1991

    EMMOHNDL.C - getEMMopenHandles()

    int cdecl getEMMopenHandles(void);
    Restituisce: il numero di handles EMS aperti
                 Se < 0 si e' verificato un errore; il valore cambiato di segno
                 e' il codice di errore EMS

    COMPILABILE CON TURBO C++ 2.0

        tcc -O -d -c -mx emmohndl.c

    dove -mx puo' essere -mt -ms -mc -mm -ml -mh

********************/
#include <dos.h>

int cdecl getEMMopenHandles(void)
{
    struct REGPACK r;

    r.r_ax = 0x4B00;
    intr(0x67,&r);
    if(!(r.r_ax & 0xFF00))
        return(r.r_bx);
    return(-((r.r_ax >> 8) & 0xFF));
}

struct EMMhnd {        // struttura per i dati relativi agli handles
    int       handle;    // n. dello handle per Expanded Memory
    unsigned  pages;        // pagine assegnate allo handle
};

    struct EMMhnd *emmHnd;
    unsigned oHnd;
    ....
    if((oHnd = getEMMopenHandles()) < 0) {
        ....   // gestione dell'errore EMS
    }
    else
        if(!(emmHnd = (struct EMMhnd *)malloc(oHnd*sizeof(struct EMMhnd)))) {
            ....   // gestione dell'errore di allocazione
        }

/********************

    BARNINGA_Z! - 1991

    EMMPPH.C - getEMMpagesPerHandle()

    int cdecl getEMMpagesPerHandle(struct EMMhnd *emmHnd);
    struct EMMhnd *emmHnd;   puntatore ad array di strutture EMMhnd, gia' allocato
                             con tanti elementi quanti sono gli handles aperti.
    Restituisce: >= 0 se l'operazione e' stata eseguita correttamente. Il valore
                 rappresenta il numero di handles EMS attivi.
                 Se < 0 si e' verificato un errore; il valore cambiato di segno
                 e' il codice di errore EMS

    COMPILABILE CON TURBO C++ 2.0

        tcc -O -d -c -mx emmpph.c

    dove -mx puo' essere -mt -ms -mc -mm -ml -mh

********************/
#pragma  warn -pia

#include <dos.h>
#include <errno.h>

int cdecl getEMMpagesPerHandle(struct EMMhnd *emmHnd)   // uso della memoria espansa
{
    struct REGPACK r;

    r.r_ax = 0x4D00;
#if defined(__TINY__) || defined(__SMALL__) || defined(__MEDIUM__)
    r.r_es = _DS;
    r.r_di = (unsigned)emmHnd;
#else
    r.r_es = FP_SEG(emmHnd);
    r.r_di = FP_OFF(emmHnd);
#endif
    intr(0x67,&r);
    if(!(r.r_ax & 0xFF00))
        return(r.r_bx);
    return(-((r.r_ax >> 8) & 0xFF));
}

/********************

    BARNINGA_Z! - 1991

    EMMGHNAM.C - getEMMhandleName()

    int cdecl getEMMhandleName(unsigned handle,char *EMMhname);
    int EMMhandle;     handle EMM di cui si vuole conoscere il nome.
    char *EMMhname;    buffer di 9 bytes in cui memorizzare il nome.
    Restituisce: lo stato dell'operazione. Se < 0, il valore, cambiato di segno,
                 e' il codice di errore EMS.

    COMPILABILE CON TURBO C++ 2.0

        tcc -O -d -c -mx emmghnam.c

    dove -mx puo' essere -mt -ms -mc -mm -ml -mh

********************/
#pragma  inline

#include <string.h>

int cdecl getEMMhandleName(int EMMhandle,char *EMMhname)
{
#if defined(__TINY__) || defined(__SMALL__) || defined(__MEDIUM__)
    asm push ds;
    asm pop es;
    asm mov di,EMMhname;
#else
    asm les di,dword ptr EMMhname;
#endif
    asm mov dx,EMMhandle;
    asm mov ax,0x5300;
    asm int 0x67;
    asm cmp ah,00h;
    asm jne EXITERROR;
    EMMhname[8] = NULL;
    return(0);
EXITERROR:
    asm mov al,ah;
    asm xor ah,ah;
    asm neg ax;
    return(_AX);
}

/********************

    BARNINGA_Z! - 1991

    EMMSHNAM.C - setEMMhandleName()

    int cdecl setEMMhandleName(unsigned handle,char *EMMhname);
    int EMMhandle;     handle EMM a cui si vuole assegnare il nome.
    char *EMMhname;    buffer contenente il nome (stringa chiusa da NULL).
    Restituisce: lo stato dell'operazione. Se < 0, il valore, cambiato di segno,
                 e' il codice di errore EMS. Se e' 0, l'operazione e' stata
                 eseguita correttamente.

    COMPILABILE CON TURBO C++ 2.0

        tcc -O -d -c -mx emmshnam.c

    dove -mx puo' essere -mt -ms -mc -mm -ml -mh

********************/
#pragma  inline

#include <string.h>

int cdecl setEMMhandleName(int EMMhandle,char *EMMhname)
{
#if defined(__TINY__) || defined(__SMALL__) || defined(__MEDIUM__)
    asm mov si,EMMhname;
#else
    asm push ds;
    asm lds si,dword ptr EMMhname;
#endif
    asm mov dx,EMMhandle;
    asm mov ax,0x5301;
    asm int 0x67;
    asm mov al,ah;
    asm cmp ax,00h;
    asm je EXITFUNC;
    asm xor ah,ah;
    asm neg ax;
EXITFUNC:
#if defined(__COMPACT__) || defined(__LARGE__) || defined(__HUGE__)
    asm pop ds;
#endif
    return(_AX);
}

/********************

    BARNINGA_Z! - 1991

    EMMALLOC.C - allocEMMpages()

    int cdecl allocEMMpages(int pages);
    int pages;     numero di pagine da allocare.
    Restituisce:   un intero. Se e' maggiore di zero e' lo handle associato
                   alle pagine allocate. Se e' = zero si e' verificato un errore 
                   non identificato. Se < 0, il valore, cambiato di segno,
                   e' il codice di errore EMS.

    COMPILABILE CON TURBO C++ 2.0

        tcc -O -d -c -mx emmalloc.c

    dove -mx puo' essere -mt -ms -mc -mm -ml -mh

********************/
#pragma  inline

int cdecl allocEMMpages(int pages)
{
    asm mov ah,043h;
    asm mov bx,pages;
    asm int 067h;
    asm cmp ah,00h;
    asm je EXITFUNC;
    asm mov dl,ah;
    asm xor dh,dh;
    asm neg dx;
EXITFUNC:
    return(_DX);
}

/********************

    BARNINGA_Z! - 1991

    EMMPGMAP.C - mapEMMpages()

    int cdecl mapEMMpages(int physicalPage,int logicalPage,int EMMhandle);
    int physicalPage;     numero della pag. fisica su cui mappare la pag. logica
    int logicalPage;      numero della pag. logica da mappare su quella fisica
    int EMMhandle;        handle associato alla pagina logica
    Restituisce:   0 se l'operazione e' stata eseguita correttamente
                   Se < 0, il valore, cambiato di segno, e' il codice di errore EMS.

    COMPILABILE CON TURBO C++ 2.0

        tcc -O -d -c -mx emmpgmap.c

    dove -mx puo' essere -mt -ms -mc -mm -ml -mh

********************/
#pragma  inline

int cdecl mapEMMpages(int physicalPage,int logicalPage,int EMMhandle)
{
    asm mov dx,EMMhandle;
    asm mov bx,logicalPage;
    asm mov al,byte ptr physicalPage;
    asm mov ah,044h;
    asm int 067h;
    asm mov al,ah;
    asm cmp ax,00h;
    asm je EXITFUNC;
    asm xor ah,ah;
    asm neg ax;
EXITFUNC:
    return(_AX);
}

/********************

    BARNINGA_Z! - 1991

    EMMFREEH.C - freeEMMhandle()

    int cdecl freeEMMhandle(int EMMhandle);
    int EMMhandle;        handle associato alle pagine logiche da rilasciare.
    Restituisce:   0 se l'operazione e' stata eseguita correttamente
                   Se < 0, il valore, cambiato di segno, e' il codice di errore EMS.

    COMPILABILE CON TURBO C++ 2.0

        tcc -O -d -c -mx emmfreeh.c

    dove -mx puo' essere -mt -ms -mc -mm -ml -mh

********************/
#pragma  inline

int cdecl freeEMMhandle(int EMMhandle)
{
    asm mov ah,045h;
    asm mov dx,EMMhandle;
    asm int 067h;
    asm mov al,ah;
    asm cmp ax,00h;
    asm je EXITFUNC;
    asm xor ah,ah;
    asm neg ax;
EXITFUNC:
    return(_AX);
}

/*******************************************************************************

    EMS.C - Barninga Z! - 1994

    Programma di test per alcune funzioni di servizio EMS.
    Il sorgente non include i listati delle funzioni.

    Compilato con Borland C++ 3.1

    bcc ems.c

*******************************************************************************/
#pragma  warn -pia
5
#include <stdio.h>
#include <dos.h>
#include <string.h>

int      allocEMMpages(int pages);
int      freeEMMhandle(int EMMhandle);
unsigned getEMMframeAddr(void);
int      getEMMhandleName(int EMMhandle,char *EMMhname);
int      mapEMMpages(int physicalPage,int logicalPage,int EMMhandle);
int      setEMMhandleName(int EMMhandle,char *EMMhname);

void main(void)
{
    register i, j;
    int retcode;
    unsigned frameSeg;
    char far *physicalPage0;
    char strBuf[80];
    int EMMhandles[2];
    static char *EMMhandleNames[] = {"Handle_1","Handle_2"};
    
    frameSeg = getEMMframeAddr();
    physicalPage0 = (char far *)MK_FP(frameSeg,0);
    printf("Page Frame Address: %Fp\n",physicalPage0);
    for(i = 0; i < 2; i++) {
        if((EMMhandles[i] = allocEMMpages(2)) <= 0) {
            printf("Error %X allocating 2 EMM pages.\n",-EMMhandles[i]);
            break;
        }
        if(retcode = setEMMhandleName(EMMhandles[i],EMMhandleNames[i])) {
            printf("Error %X setting name of handle %d.\n",-retcode,EMMhandles[i]);
            break;
        }
    }
    if(i < 2) {
        for(j = 0; j < i; j++)
            if(retcode = freeEMMhandle(EMMhandles[j])) 
                printf("Error %X deallocating EMM pages of handle %d.\n",-retcode,
        EMMhandles[j]);
        return;
    }
    for(i = 0; i < 2; i++) 
        if(retcode = getEMMhandleName(EMMhandles[i],strBuf))
            printf("Error %X getting name of handle %d.\n",-retcode,EMMhandles[i]);
        else
            printf("Handle %d name: %s\n",EMMhandles[i],buffer);
    if(retcode = mapEMMpages(0,0,EMMhandles[0]))
        printf("Error %X mapping Log. page %d of handle %d to Phys. page %d.\n",
        -retcode,0,EMMhandles[0],0);
    _fstrcpy(physicalPage0,"@@@ A String For Logical Page 0 @@@");
    if(retcode = mapEMMpages(0,1,EMMhandles[1]))
        printf("Error %X mapping Log. page %d of handle %d to Phys. page %d.\n",
        -retcode,1,EMMhandles[1],0);
    _fstrcpy(physicalPage0,"XXXXXXXXXXXXXXXXXXXXX");
    if(retcode = mapEMMpages(0,0,EMMhandles[0]))
        printf("Error %X mapping Log. page %d of handle %d to Phys. page %d.\n",
        -retcode,0,EMMhandles[0],0);
    _fstrcpy(strBuf,physicalPage0);
    printf("Logical Page 0 content: %s\n",strBuf);
    for(i = 0; i < 2; i++)
        if(retcode = freeEMMhandle(EMMhandles[i])) 
            printf("Error %X deallocating EMM pages of handle %d.\n",-retcode,
        EMMhandles[i]);
}

/********************

    BARNINGA_Z! - 1991

    EMMGPMD.C - getEMMpageMapDim()

    int cdecl getEMMpageMapDim(void);
    Restituisce:   Se > 0 è la dimensione in bytes dell'array necessario a
                   contenere la page map
                   Se < 0, il valore, cambiato di segno, e' il codice di errore EMS.

    COMPILABILE CON TURBO C++ 2.0

        tcc -O -d -c -mx emmgpmd.c

    dove -mx puo' essere -mt -ms -mc -mm -ml -mh

********************/
#pragma  inline

int cdecl getEMMpageMapDim(void)
{
    asm mov ax,04E03h;
    asm int 067h;
    asm mov bl,al;
    asm mov al,ah;
    asm xor ah,ah;
    asm cmp ax,0;
    asm je EXITFUNC;
    asm neg ax;
    return(_AX);
EXITFUNC:
    return(_BL);
}

/********************

    BARNINGA_Z! - 1991

    EMMSPM.C - saveEMMpageMap(unsigned char *destBuf)

    int cdecl saveEMMpageMap(unsigend char *destBuf);
    unsigned char *destBuf;     buffer che conterra' la page map.
    Restituisce:   Se 0 l'operazione è stata eseguita correttamente
                   Se < 0, il valore, cambiato di segno, e' il codice di errore EMS.

    COMPILABILE CON TURBO C++ 2.0

        tcc -O -d -c -mx emmspm.c

    dove -mx puo' essere -mt -ms -mc -mm -ml -mh

********************/
#pragma  inline

int cdecl saveEMMpageMap(unsigned char *destBuf)
{
#if defined(__TINY__) || defined(__SMALL__) || defined(__MEDIUM__)
    asm push ds;
    asm pop es;
    asm mov di,destBuf;
#else
    asm les di,dword ptr destBuf;
#endif
    asm mov ax,04E00h;
    asm int 067h;
    asm mov al,ah;
    asm cmp ax,00h;
    asm je EXITFUNC;
    asm xor ah,ah;
    asm neg ax;
EXITFUNC:
    return(_AX);
}

/********************

    BARNINGA_Z! - 1991

    EMMRPM.C - restoreEMMpageMap(unsigned char *sourceBuf)

    int cdecl saveEMMpageMap(unsigned char *sourceBuf);
    unsigned char *sourceBuf;     buffer che contiene la page map da riattivare.
    Restituisce:   Se 0 l'operazione è stata eseguita correttamente
                   Se < 0, il valore, cambiato di segno, e' il codice di errore EMS.

    COMPILABILE CON TURBO C++ 2.0

        tcc -O -d -c -mx emmrpm.c

    dove -mx puo' essere -mt -ms -mc -mm -ml -mh

********************/
#pragma  inline

int cdecl restoreEMMpageMap(unsigned char *sourceBuf)
{
#if defined(__TINY__) || defined(__SMALL__) || defined(__MEDIUM__)
    asm mov si,sourceBuf;
#else
    asm push ds;
    asm lds si,dword ptr sourceBuf;
#endif
    asm mov ax,04E00h;
    asm int 067h;
    asm mov al,ah;
    asm cmp ax,00h;
    asm je EXITFUNC;
    asm xor ah,ah;
    asm neg ax;
EXITFUNC:
#if defined(__COMPACT__) || defined(__LARGE__) || defined(__HUGE__)
    asm pop ds;
#endif
    return(_AX);
}

struct EMMmove {
    unsigned long length;
    unsigned char sourceType;
    unsigned int  sourceHandle;
    unsigned int  sourceOffset;
    unsigned int  sourceSegment;
    unsigned char destType;
    unsigned int  destHandle;
    unsigned int  destOffset;
    unsigned int  destSegment;
};

#include <dos.h>
    ....
    struct REGPACK r;
    struct EMMmove EMMinfoBuf;
    ....
    EMMinfoBuf.length = 32*1024;   // 32 Kb
    EMMinfoBuf.sourceType = 0;     // sorgente: memoria convenzionale
    EMMinfoBuf.sourceHandle = 0;   // handle sempre 0 per mem. convenz.
    EMMinfoBuf.sourceOffset = 0;   // segmento:offset
    EMMinfoBuf.sourceSegment = 0xB800;     // B800:0000
    EMMinfoBuf.destType = 1;       // destinazione: memoria EMS
    EMMinfoBuf.destHandle = 0x09;  // handle (da int 67h, servizio 43h)
    EMMinfoBuf.destOffset = 256;   // offset all'interno della pag.logica
    EMMinfoBuf.destSegment = 2;    // terza pag.logica
    r.r_ax = 0x5700;
    r.r_ds = FP_SEG((struct EMMmove far *)&EMMinfoBuf);
    r.r_si = (unsigned)&EMMinfoBuf;
    intr(0x67,&r);
    if(r.r_ax & 0xFF00) {
        ....   // Gestione dell'errore (AH != 0)

/********************

    BARNINGA_Z! - 1992

    EMMMOVM.C - EMMmoveMem()

    int EMMmoveMem(struct EMMmove *EMMbuffer,int operation);
    struct EMMmove *EMMbuffer;     puntatore al buffer che descrive l'operaz.
    int             operation;     0 = sposta il contenuto della memoria
                                   1 = scambia il contenuto di due aree di
                                       memoria
    Restituisce:   0 se l'operazione e' stata eseguita correttamente.
                  -1 parametro operation errato
                 > 0 e' il codice di errore EMS.

    COMPILABILE CON TURBO C++ 2.0

        tcc -O -d -c -mx -k- emmmovm.c

    dove -mx puo' essere -mt -ms -mc -mm -ml -mh

********************/
#pragma  inline

int cdecl EMMmoveMem(struct EMMmove *EMMbuffer,int operation)
{
    if((operation < 0) || (operation > 1))
        return(-1);
    _AL = (char)operation;
    _AH = 0x57;
#if defined(__TINY__) || defined(__SMALL__) || defined(__MEDIUM__)
    asm mov si,EMMbuffer;
#else
    asm push ds;
    asm lds si,dword ptr EMMbuffer;
#endif
    asm int 067h;
#if defined(__COMAPCT__) || defined(__LARGE__) || defined(__HUGE__)
    asm pop ds;
#endif
    asm xor al,al;
    asm cmp ah,0;
    asm je EXITFUNC;
    asm xchg ah,al;
EXITFUNC:
    return(_AX);
}

#include <dos.h>
....
    struct REGPACK r;
    unsigned info[8];
    ....
    info[0] = 4;   // mappare la pag. logica 4
    info[1] = 0;   // sulla pag. fisica 0
    info[2] = 6;   // mappare la pag. logica 6
    info[3] = 3;   // sulla pag. fisica 3
    info[4] = 7;   // mappare la pag. logica 7
    info[5] = 1;   // sulla pag. fisica 1
    r.r_ax = 0x5000;       // servizio 50h, subfunzione 00h
    r.r_cx = 3;    // 3 pagine in tutto
    r.r_dx = 09h;  // handle delle pag. logiche (da serv. 43h)
    r.r_ds = FP_SEG((int far *)info);
    r.r_si = (unsigned)info;
    intr(0x67,&r);
    if(r.r_ax & 0xFF00) {
        ....   // Gestione dell'errore (AH != 0)

Memoria estesa, High Memory Area e UMB 

I servizi XMS per la memoria estesa 

/********************

    BARNINGA_Z! - 1992

    XMMADDR.C - getXMMaddress()

    void (far *cdecl getXMMaddress(void))(void);
    Restituisce: l'entry point del driver XMM. Se non è installato alcun
                 driver XMM restituisce NULL.

    COMPILABILE CON TURBO C++ 2.0

        tcc -O -d -c -mx -k- xmmaddr.c

    dove -mx puo' essere -mt -ms -mc -mm -ml -mh

********************/
#pragma  inline
#pragma  option -k-

#include <stdio.h>      /* per NULL */

void (far *cdecl getXMMaddress(void))(void)
{
    _AX = 0x4300;
    asm int 2Fh;
    if(_AL != 0x80)
        return((void(far *)(void))NULL);
    _AX = 0x4310;
    asm int 2Fh;
    return((void _es *)_BX);
}

/********************

    BARNINGA_Z! - 1992

    XMMVERS.C - getXMMversion()

    int cdecl getXMMversion(void (far *XMMdriver)(void));
    void (far *XMMdriver)(void);   puntatore all'entry point del driver.
    Restituisce: un intero il cui byte meno significativo rappresenta la versione
                 XMS supportata e quello piu' significativo la revisione;
                 Se < 0 e' il codice di errore XMS cambiato di segno.

    COMPILABILE CON TURBO C++ 2.0

        tcc -O -d -c -mx -k- xmmvers.c

    dove -mx puo' essere -mt -ms -mc -mm -ml -mh

********************/
#pragma  inline

int cdecl getXMMversion(void (far *XMMdriver)(void))
{
    _AH = 0;
    (*XMMdriver)();
    asm cmp ax,0;
    asm jne EXITFUNC;
    asm xor bh,bh;
    asm neg bx;
    return(_BX);
EXITFUNC:
    asm xchg ah,al;
    return(_AX);
}

    (*XMMdriver)();

    asm call dword ptr XMMdriver;

/********************

    BARNINGA_Z! - 1992

    XMMDVERS.C - getXMMdrvVersion()

    int cdecl getXMMdrvVersion(void (far *XMMdriver)(void));
    void (far *XMMdriver)(void);   puntatore all'entry point del driver.
    Restituisce: un intero il cui byte meno significativo rappresenta la versione
                 del driver XMM e quello piu' significativo la revisione;
                 Se < 0 e' il codice di errore XMS cambiato di segno.

    COMPILABILE CON TURBO C++ 2.0

        tcc -O -d -c -mx -k- xmmdvers.c

    dove -mx puo' essere -mt -ms -mc -mm -ml -mh

********************/
#pragma  inline

int cdecl getXMMdrvVersion(void (far *XMMdriver)(void))
{
    _AH = 0;
    (*XMMdriver)();
    asm cmp ax,0;
    asm jne EXITFUNC;
    asm xor bh,bh;
    asm neg bx;
    return(_BX);
EXITFUNC:
    asm xchg bh,bl;
    return(_BX);
}

/********************

    BARNINGA_Z! - 1992

    XMSFREEM.C - getXMSfreeMem()

    long getXMSfreeMem(void (far *XMMdriver)(void));
    void (far *XMMdriver)(void);   puntatore all'entry point del driver XMM.
    Restituisce: La quantità di memoria XMS libera, in Kilobytes.
                 Se < 0 e' il codice di errore XMS.

    COMPILABILE CON TURBO C++ 2.0

        tcc -O -d -c -mx -k- xmsfreem.c

    dove -mx puo' essere -mt -ms -mc -mm -ml -mh

********************/
#pragma  inline

long cdecl getXMSfreeMem(void (far *XMMdriver)(void))
{
    _AH = 8;
    (*XMMdriver)();
    asm cmp ax,0;
    asm jne EXITFUNC;
    asm xor bh,bh;
    asm neg bx;
    asm mov dx,bx;
EXITFUNC:
    return((long)_DX);
}
/********************

    BARNINGA_Z! - 1992

    XMSFREEB.C - getXMSfreeBlock()

    long getXMSfreeBlock(void (far *XMMdriver)(void));
    void (far *XMMdriver)(void);   puntatore all'entry point del driver XMM.
    Restituisce: la dimensione in Kb del maggiore blocco XMS disponibile;
                 Se < 0 e' il codice di errore XMS.

    COMPILABILE CON TURBO C++ 2.0

        tcc -O -d -c -mx -k- xmsfreeb.c

    dove -mx puo' essere -mt -ms -mc -mm -ml -mh

********************/
#pragma  inline

long cdecl getXMSfreeBlock(void (far *XMMdriver)(void))
{
    _AH = 8;
    (*XMMdriver)();
    asm cmp ax,0;
    asm jne EXITFUNC;
    asm xor bh,bh;
    asm neg bx;
    asm mov ax,bx;
EXITFUNC:
    return((long)_AX);
}

/********************

    BARNINGA_Z! - 1992

    EXTINST.C - getEXTinstalled()

    unsigned getEXTinstalled(void);
    Restituisce: il numero di Kb di memoria estesa fisica installati.

    COMPILABILE CON TURBO C++ 2.0

        tcc -O -d -c -mx -k- extinst.c

    dove -mx puo' essere -mt -ms -mc -mm -ml -mh

********************/
#pragma  inline

unsigned cdecl getEXTinstalled(void)
{
    asm {
        mov al,17h;
        out 70h,al;    // prepara lettura CMOS offset 17h
        jmp $+2;       // introduce ritardo
        in al,71h;     // legge CMOS, byte ad offset 17h
        mov ah,al;     // salva byte letto
        mov al,18h;    // ripete procedura per byte ad offset 18h
        out 70h,al;
        jmp $+2;
        in al,71h;
        xchg ah,al;    // ricostruisce la word (backwords)
    }
    return(_AX);
}

/********************

    BARNINGA_Z! - 1992

    EXTFREE.C - getEXTfree()

    unsigned getEXTfree(void);
    Restituisce: il numero di Kb di memoria estesa installati e attualmente
                 non sotto il controllo di un driver XMM.

    COMPILABILE CON TURBO C++ 2.0

        tcc -O -d -c -mx -k- extfree.c

    dove -mx puo' essere -mt -ms -mc -mm -ml -mh

********************/
#pragma  inline

unsigned cdecl getEXTfree(void)
{
    _AH = 0x88;
    asm int 15h;
    return(_AX);
}

/********************

    BARNINGA_Z! - 1992

    EMBALLOC.C - allocEMB()

    int allocEMB(void (far *XMMdriver)(void),unsigned EMBkb);
    void (far *XMMdriver)(void);   puntatore all'entry point del driver XMM.
    unsigned EMBkb;                dimensione in Kb del blocco richiesto.
    Restituisce: Lo handle associato al blocco allocato.
                 Se < 0 e' il codice di errore XMS.

    COMPILABILE CON TURBO C++ 2.0

        tcc -O -d -c -mx -k- emballoc.c

    dove -mx puo' essere -mt -ms -mc -mm -ml -mh

********************/
#pragma  inline

int cdecl allocEMB(void (far *XMMdriver)(void),unsigned EMBkb)
{
    _DX = EMBkb;
    _AH = 9;
    (*XMMdriver)();
    asm cmp ax,0;
    asm jne EXITFUNC;
    asm xor bh,bh;
    asm neg bx;
    asm mov dx,bx;
EXITFUNC:
    return(_DX);
}

struct EMBmove {
    unsigned long length;  // lunghezza in bytes dell'area
    unsigned srcHandle;    // handle EMB sorgente (0 se mem. convenzionale)
    long srcOffset;        // offset nell'EMB sorgente o far pointer a mem. convenzionale
    unsigned dstHandle;    // handle EMB destinaz. (0 se mem. convenzionale)
    long dstOffset;        // offset nell'EMB destinaz. o far pointer a mem. convenzionale
};

/********************

    BARNINGA_Z! - 1992

    XMSMOVM.C - XMSmoveMem()

    int XMSmoveMem(void (far *XMMdriver)(void),struct EMBmove *EMBbuffer);
    void (far *XMMdriver)(void);   puntatore all'entry point del driver XMM.
    struct EMBmove *EMBbuffer;     puntatore al buffer che descrive l'operazione.
    Restituisce: 0 se l'operazione e' stata eseguita correttamente.
                 Se < 0 e' il codice di errore XMS.

    COMPILABILE CON TURBO C++ 2.0

        tcc -O -d -c -mx -k- xmsmovm.c

    dove -mx puo' essere -mt -ms -mc -mm -ml -mh

********************/
#pragma  inline

int cdecl XMSmoveMem(void (far *XMMdriver)(void),struct EMBmove *EMBbuffer)
{
#if defined(__TINY__) || defined(__SMALL__) || defined(__MEDIUM__)
    asm mov si,EMBbuffer;
#else
    asm push ds;
    asm lds si,dword ptr EMBbuffer;
#endif
    _AH = 0x0B;
    (*XMMdriver)();
#if defined(__COMAPCT__) || defined(__LARGE__) || defined(__HUGE__)
    asm pop ds;
#endif
    asm cmp ax,0;
    asm je EXITFUNC;
    return(0);
EXITFUNC:
    asm xor bh,bh;
    asm neg bx;
    return(_BX);
}

    ....
    unsigned char far *convMemPtr;
    void (far *XMMdriver)(void);   // puntatore all'entry point del driver XMM
    struct EMBmove EMBbuffer;
    unsigned EMBhandle;
    ....
    EMBbuffer.length = 96 * 1024;  // lunghezza in bytes dell'area da copiare
    EMBbuffer.srcHandle = 0;       // sorgente memoria convenzionale
    EMBbuffer.srcOffset = (long)convMemPtr;        // indirizzo sorgente in mem. conv.
    EMBbuffer.dstHandle = EMBhandle;       // restituito da allocEMB()
    EMBbuffer.dstOffset = 0x10000; // offset nell'EMB associato a EMBhandle
    if(XMSmoveMem(XMMdriver,&EMBbuffer) < 0)
        ....   // gestione errore XMS

/********************

    BARNINGA_Z! - 1992

    EMBFREE.C - freeEMB()

    int freeEMB(void (far *XMMdriver)(void),unsigned EMBhandle);
    void (far *XMMdriver)(void);   puntatore all'entry point del driver XMM.
    unsigned EMBhandle;            handle EMB da deallocare.
    Restituisce: 0 se l'operazione è stata eseguita con successo.
                 Se < 0 e' il codice di errore XMS.

    COMPILABILE CON TURBO C++ 2.0

        tcc -O -d -c -mx -k- embfree.c

    dove -mx puo' essere -mt -ms -mc -mm -ml -mh

********************/
#pragma  inline

int cdecl freeEMB(void (far *XMMdriver)(void),unsigned EMBhandle)
{
    _DX = EMBhandle;
    _AH = 0x0A;
    (*XMMdriver)();
    asm cmp ax,0;
    asm je EXITFUNC;
    return(0);
EXITFUNC:
    asm xor bh,bh;
    asm neg bx;
    return(_BX);
}

/********************

    BARNINGA_Z! - 1992

    EMBRESIZ.C - resizeEMB()

    int resizeEMB(void (far *XMMdriver)(void),unsigned EMBhandle,unsigned newKb);
    void (far *XMMdriver)(void);   puntatore all'entry point del driver XMM.
    unsigned EMBhandle;            handle XMS associato all'EMB da modificare.
    unsigned newKb;                nuova dimensione desiderata, in Kilobytes.
    Restituisce: 0 se l'operazione è stata eseguita con successo.
                 Se < 0 e' il codice di errore XMS.

    COMPILABILE CON TURBO C++ 2.0

        tcc -O -d -c -mx -k- embresiz.c

    dove -mx puo' essere -mt -ms -mc -mm -ml -mh

********************/
#pragma  inline

int cdecl resizeEMB(void (far *XMMdriver)(void),unsigned EMBhandle,unsigned newKb)
{
    _DX = EMBhandle;
    _BX = newKb;
    _AH = 0x0F;
    (*XMMdriver)();
    asm cmp ax,0;
    asm je EXITFUNC;
    return(0);
EXITFUNC:
    asm xor bh,bh;
    asm neg bx;
    return(_BX);
}

I servizi XMS per la HMA 

/********************

    BARNINGA_Z! - 1992

    XMMISHMA.C - isHMA()

    int cdecl isHMA(void (far *XMMdriver)(void));
    void (far *XMMdriver)(void);   puntatore all'entry point del driver.
    Restituisce: 1  HMA esistente
                 0  HMA non esistente
                 Se < 0 e' il codice di errore XMS cambiato di segno.

    COMPILABILE CON TURBO C++ 2.0

        tcc -O -d -c -mx -k- xmmishma.c

    dove -mx puo' essere -mt -ms -mc -mm -ml -mh

********************/
#pragma  inline

int cdecl isHMA(void (far *XMMdriver)(void))
{
    _AH = 0;
    (*XMMdriver)();
    asm cmp ax,0;
    asm jne EXITFUNC;
    asm xor bh,bh;
    asm neg bx;
    return(_BX);
EXITFUNC:
    return(_DX);
}

/********************

    BARNINGA_Z! - 1992

    ISHMAFRE.C - isHMAfree()

    int isHMAfree(void (far *XMMdriver)(void));
    void (far *XMMdriver)(void);   puntatore all'entry point del driver XMM.
    Restituisce: 1 se la HMA e' libera;
                 0 se gia' allocata;
                 Se < 0 e' il codice di errore XMS cambiato di segno.

    COMPILABILE CON TURBO C++ 2.0

        tcc -O -d -c -mx -k- ishmafre.c

    dove -mx puo' essere -mt -ms -mc -mm -ml -mh

********************/
#pragma  inline

int cdecl isHMAfree(void (far *XMMdriver)(void))
{
    _AH = 1;
    _DX = 0xFFF0;
    (*XMMdriver)();
    asm cmp ax,0;
    asm jne DEALLOC;
    asm cmp bl,091h;
    asm jne ERROR;
    return(0);     // HMA gia' allocata
ERROR:
    asm xor bh,bh;
    asm neg bx;
    return(_BX);
DEALLOC:
    _AH = 2;
    (*XMMdriver)();
    asm cmp ax,0;
    asm jne EXITFUNC;
    asm jmp ERROR;
EXITFUNC:
    return(1);
}

/********************

    BARNINGA_Z! - 1992

    HMAALLOC.C - HMAalloc()

    int *HMAalloc(void (far *XMMdriver)(void),unsigned nBytes);
    void (far *XMMdriver)(void);   puntatore all'entry point del driver XMM.
    unsigned nBytes;               numero di bytes da allocare.
    Restituisce: 0 se l'allocazione e' stata effettuata con successo;
                 Se < 0 e' il codice di errore XMS

    COMPILABILE CON TURBO C++ 2.0

        tcc -O -d -c -mx -k- hmaalloc.c

    dove -mx puo' essere -mt -ms -mc -mm -ml -mh

********************/
#pragma  inline

int cdecl HMAalloc(void (far *XMMdriver)(void),unsigned nBytes)
{
    _DX = nBytes;
    _AH = 1;
    (*XMMdriver)();
    asm cmp ax,0;
    asm jne EXITFUNC;
    asm xor bh,bh;
    asm neg bx;
    return(_BX);   // HMA gia' allocata o errore
EXITFUNC:
    return(0);
}
/********************

    BARNINGA_Z! - 1992

    HMADEALL.C - HMAdealloc()

    int HMAdealloc(void (far *XMMdriver)(void));
    void (far *XMMdriver)(void);   puntatore all'entry point del driver XMM.
    Restituisce: 0 se la HMA e' stata deallocata con successo;
                 Se < 0 e' il codice di errore XMS cambiato di segno.

    COMPILABILE CON TURBO C++ 2.0

        tcc -O -d -c -mx -k- hmadeall.c

    dove -mx puo' essere -mt -ms -mc -mm -ml -mh

********************/
#pragma  inline

int cdecl HMAdealloc(void (far *XMMdriver)(void))
{
    _AH = 2;
    (*XMMdriver)();
    asm cmp ax,0;
    asm jne EXITFUNC;
    asm xor bh,bh;
    asm neg bx;
    return(_BX);
EXITFUNC:
    return(0);
}

/********************

    BARNINGA_Z! - 1992

    ISA20ON.C - isA20enabled()

    int cdecl isA20enabled(void (far *XMMdriver)(void));
    void (far *XMMdriver)(void);     puntatore all'entry point del driver XMM.
    Restituisce: 1 se la A20 line e' abilitata;
                 0 se la A20 line e' disabilitata;
                 Se < 0 e' il codice di errore XMS.

    COMPILABILE CON TURBO C++ 2.0

        tcc -O -d -c -mx -k- isa20on.c

    dove -mx puo' essere -mt -ms -mc -mm -ml -mh

********************/
#pragma  inline

int cdecl isA20enabled(void (far *XMMdriver)(void))
{
    _AH = 7;
    (*XMMdriver)();
    asm cmp ax,0;
    asm jne EXITFUNC;
    asm cmp bl,0;
    asm je EXITFUNC;
    asm xor bh,bh;
    asm neg bx;
    asm mov ax,bx;
EXITFUNC:
    return(_AX);
}

/********************

    BARNINGA_Z! - 1992

    A20ENABL.C - enableA20()

    int cdecl enableA20(void (far *XMMdriver)(void));
    void (far *XMMdriver)(void);     puntatore all'entry point del driver XMM.
    Restituisce: 0 se la A20 line e' stata abilitata con successo;
                 Se < 0 e' il codice di errore XMS.

    COMPILABILE CON TURBO C++ 2.0

        tcc -O -d -c -mx -k- a20enabl.c

    dove -mx puo' essere -mt -ms -mc -mm -ml -mh

********************/
#pragma  inline

int cdecl enableA20(void (far *XMMdriver)(void))
{
    _AH = 3;
    (*XMMdriver)();
    asm cmp ax,0;
    asm je EXITFUNC;
    return(0);
EXITFUNC:
    asm xor bh,bh;
    asm neg bx;
    return(_BX);
}
/********************

    BARNINGA_Z! - 1992

    A20DISAB.C - disableA20()

    int cdecl disableA20(void (far *XMMdriver)(void));
    void (far *XMMdriver)(void);     puntatore all'entry point del driver XMM.
    Restituisce: 0 se la A20 line e' stata disabilitata con successo;
                 Se < 0 e' il codice di errore XMS.

    COMPILABILE CON TURBO C++ 2.0

        tcc -O -d -c -mx -k- a20disab.c

    dove -mx puo' essere -mt -ms -mc -mm -ml -mh

********************/
#pragma  inline

int cdecl disableA20(void (far *XMMdriver)(void))
{
    _AH = 4;
    (*XMMdriver)();
    asm cmp ax,0;
    asm je EXITFUNC;
    return(0);
EXITFUNC:
    asm xor bh,bh;
    asm neg bx;
    return(_BX);
}

I servizi XMS per gli UMB 

/********************

    BARNINGA_Z! - 1992

    UMBALLOC.C - allocUMB()

    int allocUMB(void (far *XMMdriver)(void),unsigned UMBKb,unsigned *UMBseg);
    void (far *XMMdriver)(void);   puntatore all'entry point del driver XMM.
    unsigned UMBKb;                dimensione desiderata, in paragrafi.
    unsigned *UMBseg;              usata per restituire l'indirizzo di segmento
                                   dell'UMB allocato. In caso di errore contiene la
                                   dimensione del massimo UMB disponibile.
    Restituisce: 0 se l'operazione e' stata eseguita con successo. All'indirizzo
                 UMBseg e' memorizzato l'indirizzo di segmento dell'UMB allocato;
                 Se < 0 e' il codice di errore XMS; All'indirizzo UMBseg e'
                 memorizzata la dimensione del massimo UMB disponibile.

    COMPILABILE CON TURBO C++ 2.0

        tcc -O -d -c -mx -k- umballoc.c

    dove -mx puo' essere -mt -ms -mc -mm -ml -mh

********************/
#pragma  inline

int cdecl allocUMB(void (far *XMMdriver)(void),unsigned UMBkb,unsigned *UMBseg)
{
    _DX = UMBkb;
    _AH = 0x10;
    (*XMMdriver)();
#if defined(__TINY__) || defined(__SMALL__) || defined(__MEDIUM__)
    asm mov si,UMBseg;
#else
    asm push ds;
    asm lds si,dword ptr UMBseg;
#endif
    asm cmp ax,0;
    asm je EXITFUNC;
    asm mov [si],bx;
#if defined(__COMPACT__) || defined(__LARGE__) || defined(__HUGE__)
    asm pop ds;
#endif   
    return(0);
EXITFUNC:
    asm mov [si],dx;
    asm xor bh,bh;
    asm neg bx;
#if defined(__COMPACT__) || defined(__LARGE__) || defined(__HUGE__)
    asm pop ds;
#endif   
    return(_BX);
}

/********************

    BARNINGA_Z! - 1992

    UMBFREE.C - freeUMB()

    int freeUMB(void (far *XMMdriver)(void),unsigned UMBseg);
    void (far *XMMdriver)(void);   puntatore all'entry point del driver XMM.
    unsigned UMBseg;               indirizzo di segmento dell'UMB da liberare.
    Restituisce: 0 se l'operazione è stata eseguita con successo.
                 Se < 0 e' il codice di errore XMS.

    COMPILABILE CON TURBO C++ 2.0

        tcc -O -d -c -mx -k- umbfree.c

    dove -mx puo' essere -mt -ms -mc -mm -ml -mh

********************/
#pragma  inline

int cdecl freeUMB(void (far *XMMdriver)(void),unsigned UMBseg)
{
    _DX = UMBseg;
    _AH = 0x11;
    (*XMMdriver)();
    asm cmp ax,0;
    asm je EXITFUNC;
    return(0);
EXITFUNC:
    asm xor bh,bh;
    asm neg bx;
    return(_BX);
}

#include <dos.h>        // per MK_FP()
    ....
    unsigned umbSeg;
    char far *umbPtr;
    ....
    if(allocUMB(XMMdriver,10000,&umbSeg) < 0) {
        ....   // gestione errore XMS
    }
    else {
        umbPtr = (char far *)MK_FP(umbSeg,0);
        ....   // utilizzo UMB
        if(freeUMB(umbSeg) < 0) {
            ....   // gestione errore XMS
        }
    }