I programmi TSR

Tipi di TSR

La struttura del TSR

Installazione del TSR

    ....
    keep(errlevel,resparas);
    ....

Dati, stack e librerie

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

    BARNINGA_Z! - 1991

    RESMEM.C - resmemparas()

    unsigned cdecl resmemparas(char *progname);
    char *progname; puntatore al nome del programma
    Restituisce: il numero di paragrafi sicuramente sufficienti
                     al programma per restare residente in memoria
                 -1 in caso di errore

    COMPILABILE CON TURBO C++ 1.0

        tcc -O -d -c -mx resmem.c

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

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

#include <stdio.h>

#define ERRCODE  -1      // valore restituito in caso di errore
#define PAGEDIM  32      // dimen. (in par.) di una pagina (512 bytes)
#define PSPDIM   16       // dimensione in paragrafi del PSP
#define PARADIM  16      // dimensione in bytes di un paragrafo

struct HEADINFO {
    unsigned signature;
    unsigned remainder;
    unsigned filepages;
    unsigned relocnum;
    unsigned headparas;
    unsigned minalloc;
};

unsigned cdecl resmemparas(char *progname)
{
    FILE *in;
    struct HEADINFO hdr;
    unsigned ret = ERRCODE;

    if(in = fopen(progname,"rb")) {
        if(fread(&hdr,sizeof(hdr),1,in) == sizeof(hdr))
            ret = ((hdr.remainder) ? hdr.filepages-1 : hdr.filepages)*PAGEDIM
                  +hdr.remainder/PARADIM+1
                  +hdr.minalloc
                  -hdr.headparas
                  +PSPDIM;
        fclose(in);
    }
    return(ret);
}

    ....
    resparas = *((unsigned far *)MK_FP(_psp-1,0x03));
    ....

    ....
    keep(errlevel,*((unsigned far *)MK_FP(_psp-1,0x03)));
    ....

Ottimizzazione dell'impiego della RAM 

#define integer1    (*((int *)Jolly))
#define integer2    (*(((int *)Jolly)+1))
#define new_handler ((void (interrupt *)())(*(((long *)Jolly)+1)))

#define ASM_handler Jolly+4 

void Jolly(void);

void interrupt new_handler(void)
{
    ....
    asm {
        pushf;
        call dword ptr ASM_handler;
    }
    ....
}

....

void Jolly(void)
{
    asm dw 0;
    asm dw 1;
    asm dd 0;
}

    unsigned resparas;
    ....
    resparas = FP_SEG(Jolly)-_psp+1+
        (FP_OFF(Jolly)+2*sizeof(int)+sizeof(void far *))/16;
    ....

....
void Jolly(void)
{
    ....
}

void DopoJolly()
{
    ....
}
....

    ....
    resmemparas = FP_SEG(DopoJolly)+PF_OFF(DopoJolly)/16+1-_psp;
    ....

Allocazione dinamica della RAM

....
void Jolly(void);
....
void InstallTSRbuff(unsigned resparas,unsigned bufparas,int code)
{
    asm {
        mov ah,0x4A;
        mov bx,resparas;
        mov es,_psp;
        int 0x21;
        mov ah,0x48;
        mov bx,bufparas;
        int 0x21;
        mov Jolly,ax;
        mov ah,0x31;
        mov al,code;
        mov dx,resparas;
        int 0x21;
    }
}
....
void Jolly(void)
{
    ....
}
....

....
void Jolly(void);
....
void InstallTSRbuff(unsigned resparas,unsigned bufparas,int code)
{
    setblock(_psp,resparas);
    allocmem(bufparas,(unsigned *)(*((unsigned *)Jolly)));
    keep(code,resparas);
}

(unsigned *)(*((unsigned *)Jolly))

I TSR e la memoria EMS

    ....   // routine di ingresso del TSR
    asm push ds;
    asm mov si,seg TSRmapContext;  // DS:SI punta al buffer contenente
    asm mov ds,si; // il mapping context del TSR
    asm mov si,offset TSRmapContext;       // questo mapping context e' attivato
    asm mov di,seg InterruptedMapContext;  // ES:DI punta al buffer in cui
    asm mov es,di; // deve essere salvato il mapping context
    asm mov di,offset InterruptedMapContext;       // del processo interrotto
    asm mov ax,4E02;
    asm int 067h;
    asm pop ds;
    asm cmp ah,0;
    asm jne ERROR;
    ....   // operazioni del TSR
    asm push ds;
    asm mov si,seg InterruptedMapContext;  // DS:SI punta al mapping context del
    asm mov ds,si; // processo interrotto, salvato in precedenza
    asm mov si,offset InterruptedMapContext;       // e ora da riattivare
    asm mov di,seg TSRMapContext;  // ES:DI punta al buffer in cui deve
    asm mov es,di; // essere salvato l'attuale mapping
    asm mov di,offset TSRMapContext;       // context del TSR
    asm mov ax,4E02;
    asm int 067h;
    asm pop ds;
    asm cmp ah,0;
    asm je EXIT_TSR;
ERROR:
    ....   // gestione errori int 67h
EXIT_TSR:
    ....   // operazioni di uscita dal TSR

Rilasciare l'environment del TSR

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

    BARNINGA_Z! - 1990

    RELENV.C - releaseEnv()

    int cdecl releaseEnv(void);

    COMPILABILE CON TURBO C++ 1.0

        tcc -O -d -c -mx relenv.C

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

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

int cdecl releaseEnv(void)
{
    asm {
        mov ax,0x6200;
        int 0x21;
        mov es,bx;
        mov bx,0x2C;
        mov es,es:[bx];
        mov ax,0x49;
        int 0x21;
        mov ah,0;
    }
    return(_AX);
}

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

    BARNINGA_Z! - 1990

    RELENVC.C - releaseEnvC()

    int cdecl releaseEnv(void);

    COMPILABILE CON TURBO C++ 1.0

        tcc -O -d -c -mx relenvc.c

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

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

int cdecl releaseEnvC(void)
{
    return(freemem(*((unsigned far *)MK_FP(_psp,0x2C))));
}

#include <dos.h>

extern unsigned _envseg;

int cdecl releaseEnv2(void)
{
    return(freemem(_envseg));
}

Due parole sullo stack

#pragma  option -k-

#define  STACKSIZE    128   // 128 bytes di stack
....
void oldSS(void)        // spazio per salvare il valore di SS
{
    asm db 0;      // 1 byte basta (c'e' l'opcode di RET)
}

void oldSP(void)        // spazio per salvare il valore di SP
{
    asm db 0;      // 1 byte basta (c'e' l'opcode di RET)
}

void TSRstack(void)     // stack locale del TSR
{
    asm db STACKSIZE dup(0);
}

....
void far new1Ch(void)   // gestore timer
{
    asm mov word ptr oldSS,ss;
    asm mov word ptr oldSP,sp;
    asm mov sp,seg TSRstack;       // usa SP per non modificare altri registri
    asm mov ss,sp; // SS non puo' essere caricato direttamente
    asm mov sp,offset TSRstack;
    asm add sp,STACKSIZE;  // SS:SP punta alla FINE di TSRstack()
    ....
    asm mov sp,word ptr oldSS;
    asm mov ss,sp;  
    asm mov sp,word ptr oldSP;     // SS:SP e' ripristinato
    asm jmp dword ptr old1Ch;
}

void far new1Ch(void)   // gestore timer
{
    asm pop di;    // PUSHed da BCC
    asm pop si;    // PUSHed da BCC
    asm mov word ptr oldSS,ss;
    asm mov word ptr oldSP,sp;
    asm mov sp,seg TSRstack;       // usa SP per non modificare altri registri
    asm mov ss,sp; // SS non puo' essere caricato direttamente
    asm mov sp,offset TSRstack;
    asm add sp,STACKSIZE;  // SS:SP punta alla FINE di TSRstack()
    ....
    asm mov sp,word ptr oldSS;
    asm mov ss,sp;  
    asm mov sp,word ptr oldSP;     // SS:SP e' ripristinato
    asm jmp dword ptr old1Ch;
}

void far new1Ch(void)   // gestore timer
{
    asm mov word ptr oldSS,ss;
    asm mov word ptr oldSP,sp;
    asm mov sp,seg TSRstack;       // usa SP per non modificare altri registri
    asm mov ss,sp; // SS non puo' essere caricato direttamente
    asm mov sp,offset TSRstack;
    asm add sp,STACKSIZE;  // SS:SP punta alla FINE di TSRstack()
    ....
    asm mov sp,word ptr oldSS;
    asm mov ss,sp;  
    asm mov sp,word ptr oldSP;     // SS:SP e' ripristinato
    asm pop di;    // PUSHed da BCC
    asm pop si;    // PUSHed da BCC
    asm jmp dword ptr old1Ch;
}

Utilizzo delle funzioni di libreria

void opeIntegral16(void)
{
    int a, b, c;

    a = 2;
    b = 1818;
    c = a + b;
    c = a - b;
    c = a * b;
    c = a / b;
    c = a % b;
}

_opeIntegral16 proc near
    push bp
    mov bp,sp
    sub sp,6

    mov word ptr [bp-2],2
    mov word ptr [bp-4],1818

    mov ax,word ptr [bp-2]
    add ax,word ptr [bp-4]
    mov word ptr [bp-6],ax

    mov ax,word ptr [bp-2]
    sub ax,word ptr [bp-4]
    mov word ptr [bp-6],ax

    mov ax,word ptr [bp-2]
    imul word ptr [bp-4]
    mov word ptr [bp-6],ax

    mov ax,word ptr [bp-2]
    cwd 
    idiv word ptr [bp-4]
    mov word ptr [bp-6],ax

    mov ax,word ptr [bp-2]
    cwd 
    idiv word ptr [bp-4]
    mov word ptr [bp-6],dx

    mov sp,bp
    pop bp
    ret
_opeIntegral16 endp

void opeIntegral32(void)
{
    long a, b, c;

    a = 2;
    b = 1818;
    c = a + b;
    c = a - b;
    c = a * b;
    c = a / b;
    c = a % b;
}

_opeIntegral32 proc near
    push bp
    mov bp,sp
    sub sp,12

    mov word ptr [bp-2],0
    mov word ptr [bp-4],2
    mov word ptr [bp-6],0
    mov word ptr [bp-8],1818

    mov ax,word ptr [bp-2]
    mov dx,word ptr [bp-4]
    add dx,word ptr [bp-8]
    adc ax,word ptr [bp-6]
    mov word ptr [bp-10],ax
    mov word ptr [bp-12],dx

    mov ax,word ptr [bp-2]
    mov dx,word ptr [bp-4]
    sub dx,word ptr [bp-8]
    sbb ax,word ptr [bp-6]
    mov word ptr [bp-10],ax
    mov word ptr [bp-12],dx

    mov cx,word ptr [bp-2]
    mov bx,word ptr [bp-4]
    mov dx,word ptr [bp-6]
    mov ax,word ptr [bp-8]
    call near ptr N_LXMUL@
    mov word ptr [bp-10],dx
    mov word ptr [bp-12],ax

    push word ptr [bp-6]
    push word ptr [bp-8]
    push word ptr [bp-2]
    push word ptr [bp-4]
    call near ptr N_LDIV@
    mov word ptr [bp-10],dx
    mov word ptr [bp-12],ax

    push word ptr [bp-6]
    push word ptr [bp-8]
    push word ptr [bp-2]
    push word ptr [bp-4]
    call near ptr N_LMOD@
    mov word ptr [bp-10],dx
    mov word ptr [bp-12],ax

    mov sp,bp
    pop bp
    ret
_opeIntegral32 endp

bcc -S -3 opeint32.c

.386    // forza l'assemblatore a generare codice 80386
_opeIntegral32 proc near
    push bp
    mov bp,sp
    sub sp,12

    mov dword ptr [bp-4],large 2
    mov dword ptr [bp-8],large 1818

    mov eax,dword ptr [bp-4]
    add eax,dword ptr [bp-8]
    mov dword ptr [bp-12],eax

    mov eax,dword ptr [bp-4]
    sub eax,dword ptr [bp-8]
    mov dword ptr [bp-12],eax

    mov eax,dword ptr [bp-4]
    imul eax,dword ptr [bp-8]
    mov dword ptr [bp-12],eax

    mov eax,dword ptr [bp-4]
    cdq 
    idiv dword ptr [bp-8]
    mov dword ptr [bp-12],eax

    mov eax,dword ptr [bp-4]
    cdq 
    idiv dword ptr [bp-8]
    mov dword ptr [bp-12],edx

    leave
    ret
_opeIntegral32 endp

Gestione degli interrupt

Gestione dello I/O

Gestione del PSP

    ....
    *((long far *)MK_FP(_psp,0x0E)) = (long)new23h;
    *((long far *)MK_FP(_psp,0x12)) = (long)new24h;
    ....

Ricapitolando...

    ....
    asm {
        mov al,0x0B;   // valore per la richiesta di stato
        out 20H,al;    // interroga 8529A
        jmp $+2;       // introduce un piccolo ritardo per attendere
        in al,20H;     // legge la risposta
    }
    ....

Disattivazione e disinstallazione

keep() ed exit()

    ....
    void _restorezero(void);
    ....
    _restorezero();
    _AH = 0x31;
    _AL = retcode;
    _DX = resparas;
    geninterrupt(0x21);
}

Suggerimenti operativi

Controllo di avvenuta installazione

Richiesta dell'indirizzo dei dati

#define UNINSTALL 0x01
....
void far new2Fh(void)
{
    ....
    if(_AL == UNINSTALL) {
        asm {
            mov ax,offset Jolly;   /* AX = offset dell'ind di Jolly() */
            mov dx,seg Jolly;      /* DX = segmento dell'ind. di Jolly() */
            iret;
        }
    }
    ....
}

void unistall(void)
{
    void far *ResidentJolly;

    _AH = MULTIPLEX_ID;
    _AL = UNINSTALL;
    geninterrupt(0x2F);
    asm {
        mov word ptr ResidentJolly,ax;
        mov word ptr ResidentJolly+2,dx;
    }
    ....
}

Rimozione della porzione residente del TSR 

    ....
    if(freemem(*((unsigned far *)ResidentJolly))
        puts("Errore: impossibile disallocare la RAM.");
    ....

Precauzioni

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

    BARNINGA_Z! - 1991

    LASTTSR.C - AreYouLast()

    unsigned *cdecl AreYouLast(long far *vecTable,unsigned ResPSP);
    long far *vecTable; puntatore alla copia della tavola dei vettori
                        creata in fase di installazione.
    unsigned ResPSP;    indirizzo di segmento del PSP della parte
                        transiente.
    Restituisce:        NULL se il TSR non e' l'ultimo programma
                        residente in RAM
                        In caso contrario restituisce il puntatore ad
                        un array che contiene gli indirizzi di tutti i
                        blocchi che devono essere liberati in quanto
                        allocati al TSR. L'ultimo elemento dell'array
                        e' sempre un NULL.

    COMPILABILE CON TURBO C++ 1.0

        tcc -O -d -c -mx lasttsr.c

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

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

#define  LASTBLOCK    'Z'

void _restorezero(void);

unsigned *cdecl AreYouLast(long far *vecTable,unsigned resPSP)
{
    register i;
    unsigned *blocks;
    struct MCB huge *mcb;
    extern unsigned _psp;  // PSP della parte transiente

    _restorezero();        // ripristina i vettori presi da startup code
    *(blocks = (unsigned *)malloc(sizeof(unsigned))) = NULL;
    for(i = 0; i < 0x22; i++)
        if(vecTable[i] != (long)getvect(i))    // il vettore 0x22 non e'
            return(NULL);  // testato in quanto appare
    for(i = 0x23; i < 256; i++)    // privo di significato
        if(vecTable[i] != (long)getvect(i))
            return(NULL);
    mcb = (struct MCB huge *)MK_FP(resPSP-1,0);    // MCB parte residente
    mcb = (struct MCB huge *)MK_FP(mcb->psp+mcb->dim,0);   // MCB successivo
    if(mcb->psp != _psp)
        return(NULL);
    mcb = (struct MCB huge *)MK_FP(getfirstmcb(),0);       // primo MCB DOS
    i = 2;
    do {
        if(mcb->psp == resPSP) {
            if(!(blocks = (unsigned *)realloc(blocks,i*sizeof(unsigned))))
                return(NULL);
            blocks[i-2] = FP_SEG(mcb)+1;   // MCB allocato alla parte resid.
            blocks[i-1] = NULL;
            ++i;
        }
    } while(mcb->pos != LASTBLOCK);
    return(blocks);
}

    ....
    _restorezero();
    _fmemcpy((long far *)startUpVectors,MK_FP(0,0),256*sizeof(void far *));
    _fmemcpy(((long far *)startUpVectors)+0x23,MK_FP(_psp,0x0E), 
                                                     2*sizeof(void far *));
    keep(code,resparas);
}

Alcuni esempi pratici

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

    PROVATSR.C - Barninga_Z! - 1991

        Esempio di TSR. "Azzoppa" il comando DIR, che, dopo la
        installazione, fornisce risultati erratici. Invocare con
        un punto esclamativo come parametro per ripristinare il
        comando DIR, lasciando il TSR in RAM. Per riattivare il
        TSR lanciarlo nuovamente, sempre con un '!' come parametro
        sulla riga di comando. Per disinstallarlo, lanciarlo con
        un asterisco come parametro.

    Compilabile con TURBO C++ 1.01

        tcc -Tm2 -mx provatsr.C

    NOTA: -mx rappresenta il modello di memoria: i modelli validi
          sono tiny (-mt) small (-ms), medium (-mm), compact (-mc)
          e large (-ml). Per il modello huge (-mh) occorre
          introdurre una istruzione inline assembly POP DS prima
          di ogni POP BP nei due gestori di interrupt, a causa
          del salvataggio automatico di DS generato dal compilatore
          in ingresso alla funzione.

********************/
#pragma  inline
#pragma  -k+     // il codice e' scritto per TURBO C++ 1.01 (vedere esempio)

#include <stdio.h>
#include <dos.h>

#define  old21h ((void(interrupt *)())(*(((long far *)ResDataPtr)+0)))
#define  old2Fh ((void(interrupt *)())(*(((long far *)ResDataPtr)+1)))
#define  Res21h ((void(interrupt *)())(*(((long far *)ResDataPtr)+2)))
#define  Res2Fh ((void(interrupt *)())(*(((long far *)ResDataPtr)+3)))
#define  ResPSP                    (*(((unsigned far *)ResDataPtr)+8))
#define  ResStatus                 (*(((unsigned far *)ResDataPtr)+9))

#define  ASMold21h      GData
#define  ASMold2Fh      GData+4
#define  ASMResStatus   GData+18

#define  FCB_FFIRST     0x11 /* servizio dell'int 21h da annullare */
#define  HEY_YOU        0xAF    /* byte di identificazione */
#define  HERE_I_AM      0xFDA3        /* risposta: installato */
#define  OFF            0
#define  ON             1
#define  HANDSHAKE      0x00  /* serv. int 2Fh: riconoscimento */
#define  UNINSTALL      0x01  /* serv. int 2Fh: disinstallazione */
#define  SW_ACTIVE      0x02  /* serv. int 2Fh: attivaz./disattivaz. */
#define  UNINST_OPT     '*'  /* opzione cmd line: disinstallazione */
#define  ACTIVE_OPT     '!'  /* opzione cmd line: attiva/disattiva */

void GData(void);       /* prototipo funzione jolly */

void far new21h(void)   /* handler int 21h */
{
    asm {
        pop bp;        /* pulisce stack - attenzione al compilatore */
        cmp ah,FCB_FFIRST;     /* se il servizio non e' 11h */
        jne CHAIN;     /* allora salta all'etichetta CHAIN */
        iret;  /* altrimenti ritorna */
    }
CHAIN:
    asm jmp dword ptr ASMold21h;   /* concatena gestore originale */
}

void far new2Fh(void)   /* handler int 2Fh */
{
    asm {
        pop bp;        /* pulisce stack */
        cmp ah,HEY_YOU;        /* se non e' PROVATSR che chiama... */
        jne CHAIN;     /* allora salta */
        cmp al,HANDSHAKE;      /* se non e' il test di installazione */
        jne NEXT1;     /* allora salta */
        mov ax,HERE_I_AM;      /* altrimenti risponde che e' presente */
        iret;
    }
NEXT1:
    asm {
        cmp al,UNINSTALL;      /* se e' richiesta la disinstallazione */
        je ANSWER;     /* allora salta */
        cmp al,SW_ACTIVE;      /* se non richiesta attivaz./disattivaz. */
        jne CHAIN;     /* allora salta */
    }
ANSWER: /* disinstallazione e switch attivazione confluiscono qui */
    asm {
        mov ax,offset GData;   /* restituisce in DX:AX l'indirizzo */
        mov dx,seg GData;      /* far di GData() */
        iret;
    }
CHAIN:
    asm jmp dword ptr ASMold2Fh;   /* concatena gestore originale */
}

void GData(void)        /* funzione jolly */
{
    asm db 15 dup(0);      /* 4+4+4+4+2+2 bytes per i dati meno 5 */
}

void releaseEnv(void)   /* libera l'environment */
{
    extern unsigned _envseg;       /* _envseg e' definita nello startup */

    if(freemem(_envseg))
        puts("Cannot release environment: memory error.");
}

long AreYouThere(char service)  /* gestisce comunicazione con TSR */
{
    long RetValue;
    union REGS regs;

    regs.h.ah = HEY_YOU;
    regs.h.al = service;
    RetValue = (long)int86(0x2F,&regs,&regs);
    RetValue |= ((long)regs.x.dx) << 16;   /* RetValue = DX:AX */
    return(RetValue);
}

void uninstall(void)    /* gestisce disinstallazione del TSR */
{
    void far *ResDataPtr;

    ResDataPtr = (void far *)AreYouThere(UNINSTALL);
    setvect(0x21,old21h);
    setvect(0x2F,old2Fh);
    if(freemem(ResPSP))
        puts("Cannot remove from memory: memory error.");
    else
        puts("Uninstalled: vectors restored and RAM freed up.");
}

void install(void)      /* installa il TSR */
{
    void far *ResDataPtr;

    ResDataPtr = (void far *)GData;
    ResPSP = _psp;
    ResStatus = ON;
    Res21h = (void(interrupt *)())new21h;
    Res2Fh = (void(interrupt *)())new2Fh;
    asm cli;
    old21h = getvect(0x21);
    old2Fh = getvect(0x2F);
    setvect(0x21,Res21h);
    setvect(0x2F,Res2Fh);
    asm sti;
    releaseEnv();
    puts("Installed: 'DIR' command not reliable. Pass * or !.");
    keep(0,FP_SEG(releaseEnv)+FP_OFF(releaseEnv)/16+1-_psp);
}

void setStatus(void)    /* gestisce switch attivazione/disattivazione */
{
    void far *ResDataPtr;

    ResDataPtr = (void far *)AreYouThere(SW_ACTIVE);
    if(ResStatus) {
        setvect(0x21,old21h);
        ResStatus = OFF;
        puts("Deactivated: still present in RAM.");
    }
    else {
        setvect(0x21,Res21h);
        ResStatus = ON;
        puts("Reactivated: already present in RAM.");
    }
}

void main(int argc,char **argv)
{
    if((unsigned)AreYouThere(HANDSHAKE) == HERE_I_AM)
        if(argc > 1)   /* TSR gia' installato */
            switch(*argv[1]) {    /* passato un parametro */
                case UNINST_OPT:       /* param = * */
                    uninstall();   /* disinstalla */
                    break;
                case ACTIVE_OPT:       /* param = ! */
                    setStatus();   /* attiva/disattiva */
                    break;
                default:       /* altro parametro */
                    puts("Unknown option.");
            }
        else   /* nessun parametro */
            puts("Not Installed: already present in RAM.");
    else   /* TSR non ancora installato (ignora parametri) */
        install();
}

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

    PROV2TSR.C - Barninga_Z! - 1991

        Esempio di TSR. "Azzoppa" il comando DIR, che, dopo la
        installazione, fornisce risultati erratici. Invocare con
        un asterisco come parametro per  disinstallarlo.

    Compilabile con TURBO C++ 1.01

        tcc -Tm2 -mx prov2tsr.C

    NOTA: -mx rappresenta il modello di memoria: i modelli validi
          sono tiny (-mt) small (-ms), medium (-mm), compact (-mc)
          e large (-ml). Per il modello huge (-mh) occorre
          introdurre una istruzione inline assembly POP DS prima
          di ogni POP BP nei due gestori di interrupt, a causa
          del salvataggio automatico di DS generato dal compilatore
          in ingresso alla funzione.

********************/
#pragma inline
#pragma  -k+     // il codice e' scritto per TURBO C++ 1.01 (vedere esempio)

#include <stdio.h>
#include <dos.h>

#define  old21h         ((void(interrupt *)())(*(((long *)GData)+0)))
#define  old2Fh         ((void(interrupt *)())(*(((long *)GData)+1)))
#define  ResPSP         (*(((unsigned *)GData)+4))

#define  ASMold21h      GData
#define  ASMold2Fh      GData+4
#define  ASMResPSP      GData+8

#define  FCB_FFIRST     0x11
#define  HEY_YOU        0xAF
#define  HERE_I_AM      0xFDA3
#define  HANDSHAKE      0x00
#define  UNINSTALL      0x01
#define  UNINST_OPT     '*'

void GData(void);

void far new21h(void)
{
    asm {
        pop bp;
        cmp ah,FCB_FFIRST;
        jne CHAIN;
        iret;
    }
CHAIN:
    asm jmp dword ptr ASMold21h;
}

void far new2Fh(void)
{
    asm {
        cmp ah,HEY_YOU;
        jne CHAIN;
        cmp al,HANDSHAKE;
        jne NEXT1;
        mov ax,HERE_I_AM;
        pop di;        /* pulisce stack: nella disinstallazione sono */
        pop si;        /* usati SI e DI, pertanto il compilatore il salva */
        pop bp;        /* automaticamente (insieme a BP) */
        iret;
    }
NEXT1:
    asm {
        cmp al,UNINSTALL;
        jne CHAIN;
        push ds;
        push es;
        cld;   /* operazioni su stringhe di bytes incrementano SI DI */
        cli;   /* stop interrupt */
        mov ax,seg GData;      /* carica AX con il segmento di GData */
        mov ds,ax;     /* e SI con l'offset */
        mov si,offset GData;   /* DS:SI punta al primo dato in GData */
        xor ax,ax;
        mov es,ax;     /* carica ES:DI per puntare al vettore */
        mov di,0x21*4; /* dell'int 21h nella tavola dei vettori */
        mov cx,2;      /* poi copia due words da GData a tavola vettori */
        rep movsw;     /* e carica DI per puntare al vettore dell'int */
        mov di,0x2F*4; /* 2Fh nella tavola dei vettori e copia */
        mov cx,2;      /* altre 2 words (SI e' stato incrementato */
        rep movsw;     /* di due grazie all'istruzione CLD) */
        mov ax,word ptr ASMResPSP;     /* carica AX con ind seg PSP TSR */
        dec ax;        /* trova l'ind. di seg. del MCB del PSP del TSR */
        mov es,ax;     /* carica ES:DI per puntare al campo "owner" del */
        mov di,1;      /* MCB (ha offset 1) */
        xor ax,ax;     /* azzera AX e lo copia nel campo "owner" del */
        stosw; /* MCB per disallocare la RAM assegnata al TSR */
        sti;   /* riabilita interrupts */
        pop es;        /* pulisce stack: vedere sopra per SI e DI */
        pop ds;
        pop di;
        pop si;
        pop bp;
        iret;
    }
CHAIN:
    asm {
        pop di;        /* pulisce stack: vedere sopra per SI e DI */
        pop si;
        pop bp;
        jmp dword ptr ASMold2Fh;       /* concatena gestore originale */
    }
}

void GData(void)
{
    asm db 5 dup(0);       /* spazio per dati (4+4+2 meno i 5 opcodes) */
}

void releaseEnv(void)
{
    extern unsigned _envseg;

    if(freemem(_envseg))
        puts("Cannot release environment: memory error.");
}

unsigned AreYouThere(char service)
{
    union REGS regs;

    regs.h.ah = HEY_YOU;
    regs.h.al = service;
    return(int86(0x2F,&regs,&regs));
}

void install(void)
{
    ResPSP = _psp;
    asm cli;
    old21h = getvect(0x21);
    old2Fh = getvect(0x2F);
    setvect(0x21,(void(interrupt *)())new21h);
    setvect(0x2F,(void(interrupt *)())new2Fh);
    asm sti;
    releaseEnv();
    puts("Installed: 'DIR' not reliable. Pass * to uninstall.");
    keep(0,FP_SEG(releaseEnv)+FP_OFF(releaseEnv)/16+1-_psp);
}

void uninstall(void)
{
    AreYouThere(UNINSTALL);
    puts("Uninstalled: vectors restored and RAM freed up.");
}

void main(int argc,char **argv)
{
    if(AreYouThere(HANDSHAKE) == HERE_I_AM)
        if(argc > 1 && argv[1][0] == UNINST_OPT)
            uninstall();
        else
            puts("Not Installed: already active in RAM.");
    else
        install();
}

void far new2Fh(void)
{
    asm {
        cmp ah,HEY_YOU;
        jne CHAIN;
        cmp al,HANDSHAKE;
        jne NEXT1;
        mov ax,HERE_I_AM;
        pop bp;
        iret;
    }
NEXT1:
    asm {
        cmp al,UNINSTALL;
        jne CHAIN;
        push ds;
        push es;
        cli;
        mov ax,word ptr GData+2;       /* carica DS e DX in modo che */
        mov ds,ax;     /* DS:DX punti al vettore originale */
        mov dx,word ptr GData; /* dell'int 21h */
        mov ax,0x2521; /* serv. set interrupt vector (vettore = 21h) */
        int 0x21;
        mov ax,word ptr GData+6;       /* carica DS e DX in modo che */
        mov ds,ax;     /* DS:DX punti al vettore originale */
        mov dx,word ptr GData+4;       /* dell'int 2Fh */
        mov ax,0x252F; /* serv. set interrupt vector (vettore = 2Fh) */
        int 0x21;
        mov ax,word ptr GData+8;       /* carica in ES l'indirizzo di */
        mov es,ax;     /* segmento del PSP della parte residente */
        mov ah,0x49;   /* servizio free allocated memory */
        int 0x21;
        sti;
        pop es;        /* pulisce stack */
        pop ds;
        pop bp;
        iret;
    }
CHAIN:
    asm {
        pop bp;
        jmp dword ptr ASMold2Fh;       /* concatena gestore originale */
    }
}

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

    SSS.C - Barninga Z! 1994

    Sample Screen Saver. TSR, opera validamente in modo testo 80x25.
    La stringa passata sulla command line viene visualizzata in posizioni
    random a video; se invocato con * come parametro quando residente, si
    disinstalla. Il tempo di attesa per entrare in azione e' definito in
    ticks di clock dalla costante manifesta MAXTICKS.

    Compilato sotto Borland C++ 3.1

    bcc -k- sss.c

******************************************************************************/
#pragma  inline                // usato inline assembly!

#pragma  option -k-            // evita la standard stack frame; serve nelle
                               // f() fittizie che definiscono i dati per
                               // gestire meglio lo spazio. Ovvio bisogna
                               // tenerne conto anche nelle f() eseguibili che
                               // usano l'inline assembly

#include <stdio.h>
#include <dos.h>
#include <string.h>
#include <dir.h>
#include <time.h>              // per randomize()
#include <stdlib.h>            // per randomize() e rand()

#define  PRG            "SSS"
#define  REL            "1.0"
#define  YEAR           "94"

// costanti manifeste per la gestione del video e del timer

#define  MAXTICKS       5460        // 5 minuti, per default
#define  MAXSPEED       18          // muove banner: 1 secondo, per default
#define  MAXBANNER      40          // max. lunghezza banner; se l'utente
                                       // specifica un banner lungo MAXBANNER,
                                       // il NULL copre RET di resBanner(): OK!
#define  MAXPOS         100         // punti del percorso del banner
#define  DEFAULTBLANK   0x0720      // blank di default
#define  DEFAULTVIDEO   0xB800      // segmento video (default)
#define  DEFAULTCOLS    80          // col. video default
#define  DEFAULTROWS    25          // righe video default
#define  DEFAULTPAGE    0           // pagina video default

// costanti manifeste per i servizi dell'int 2F; 0 e' il servizio di
// riconoscimento, per evitare doppie installazioni in ram del TSR; 1 e' il
// servizio di disinstallazione del TSR dalla memoria

#define  HANDSHAKE      0x00   // servizio di scambio parola d'ordine
#define  UNINSTALL      0x01   // servizio di disinstallazione
#define  UNINST_OPT     "*"    // da passare sulla comand line per richiedere
                               // la disinstallazione del TSR
#define  HEY_YOU        0xE1   // parola d'ordine di riconoscimento
#define  HERE_I_AM      0xB105 // risposta alla parola d'ordine

typedef void DUMMY;            // tutte le f() fittizie che definiscono dati
                               // sono ovviamente void f(void); la typedef
                               // consente di evidenziare che non sono vere f()

// prototipi delle funzioni

void far new09h(void);
void far new10h(void);
void far new1Ch(void);
void far new2Fh(void);
void far new33h(void);
void _saveregs animate(void);
void _saveregs blankVideo(void);
void _saveregs restoreVideo(void);
int releaseEnv(void);
unsigned areYouThere(char service);
void initializeOffsets(void);
void install(char *banner);
void uninstall(void);
void main(int argc,char **argv);

/*---------------------------------------------------------------------------*/

// inizia qui la parte residente del TSR: dapprima si riserva spazio per i dati
// mediante alcune finte f() che devono solo "ingombrare" lo spazio necessario,
// poi sono definite tutte le funzioni che lavorano mentre il programma e'
// residente.

// Gruppo delle f() fittizie, usate come contenitori di dati. Equivalgono a
// variabili globali (il nome della funzione puo' essere usato come il nome di
// una variabile, applicando l'opportuno cast) ma si ha la garanzia che lo
// spazio e' allocato in modo statico esattamente dove si vuole: essendo esse
// definite in testa al sorgente, sappiamo che subito dopo lo startup code
// del programma ci sono i dati necessari al TSR quando e' residente in RAM.
// Grazie ad esse, le f() residenti non usano variabili globali o statiche,
// rendendo cosi' possibile limitare l'ingombro in memoria del TSR

DUMMY ticksToWait(DUMMY)       // contatore da decrementare per l'attivazione
{
    asm dw MAXTICKS;                  // max 65535, quasi 1 ora
}

DUMMY ticksForSpeed(DUMMY)     // contatore per la velocita' di animazione
{
    asm dw 0;                         // 0: 1^ banner istantaneo!
}

DUMMY resPSP(DUMMY)            // indirizzo di segmento del PSP del STR
{
    asm dw 0;
}

DUMMY old09h(DUMMY)            // vettore originale int 09h
{
    asm dd 0;
}

DUMMY old10h(DUMMY)            // vettore originale int 10h
{
    asm dd 0;
}

DUMMY old1Ch(DUMMY)            // vettore originale int 1Ch
{
    asm dd 0;
}

DUMMY old2Fh(DUMMY)            // vettore originale int 2Fh
{
    asm dd 0;
}

DUMMY old33h(DUMMY)            // vettore originale int 33h
{
    asm dd 0;
}

DUMMY videoBuf(DUMMY)          // spazio per il salvataggio del video
{
    asm dw DEFAULTCOLS*DEFAULTROWS dup(0);
}

DUMMY savedRow(DUMMY)          // riga alla quale si trovava il cursore
{
    asm db 0;
}

DUMMY savedCol(DUMMY)          // colonna alla quale si trovava il cursore
{
    asm db 0;
}

DUMMY saverActive(DUMMY)       // flag che segnala se il saver e' attivo
{
    asm db 0;
}

DUMMY restoreFlag(DUMMY)       // flag che segnala di restorare il video
{
    asm db 0;
}

DUMMY inInt10h(DUMMY)          // flag che evita ricorsione dell'int 10h
{
    asm db 0;
}

DUMMY resBanner(DUMMY)         // stringa per animazione video
{
    asm db MAXBANNER dup(0);
}

DUMMY resBannerLen(DUMMY)      // lunghezza banner: per comodita'
{
    asm dw 0;
}

DUMMY resBannerOffs(DUMMY)     // offsets per scrivere il banner
{
    asm dw MAXPOS dup(0);
}

DUMMY currBannerOff(DUMMY)     // contatore per l'array di posizioni
{
    asm dw 0;
}

// nuovo gestore dell'int 09h; non serve dichiararlo interrupt perche' non
// usa nessun registro (eccetto AX, salvato e rispristinato da noi stessi), ma
// deve comunque terminare con una iret. Gli underscores davanti ai nomi
// servono perche' il compilatore C li aggiunge a tutti i simboli mentre
// l'assembler no. L'uso dell'inline assembly consente di ottenere una funzione
// efficientissima e molto compatta.

void far new09h(void)
{
    asm mov byte ptr _restoreFlag,1;
    asm cmp byte ptr _saverActive,1;  // se e' stato premuto un tasto e lo s.s.
    asm je EAT_KEY;                   // era attivo, la battuta deve sparire!
    asm jmp dword ptr _old09h;        // se no, lasciamo al vecchio gestore!
  EAT_KEY:
    asm push ax;                      // salva l'unico registro usato
    asm in al,0x60;                   // fingiamo che interessi lo scancode...
    asm in al,0x61;                   // legge lo stato della tastiera
    asm mov ah,al;                    // lo salva
    asm or al,0x80;                   // setta il bit "enable keyboard"
    asm out 0x61,al;                  // lo scrive sulla porta di controllo
    asm xchg ah,al;                   // riprende stato originale della tast.
    asm out 0x61,al;                  // e lo riscrive
    asm mov al,0x20;                  // manda il segnale di fine Interrupt
    asm out 0x20,al;                  // al controllore dell'8259
    asm pop ax;                       // rimettiamo le cose a posto!
    asm iret;          // e' pur sempre un gestore di interrupt! ma ATTENZIONE:
                       // la IRET puo' essere usata perche' la f() e' far e non
                       // c'e' la standard stack frame (opzione -k-).
}

// il gestore dell'int 10h e' qui per sicurezza. Dal momento che l'int 1Ch
// usa l'int 10h per pasticciare col cursore, se il timer chiede un interrupt
// proprio mentre e' servito un int 10h e proprio in quel tick di timer si
// azzera il contatore di attesa per lo screen saver e viene cosi' chiamata
// blankVideo(), si ha una ricorsione dell'int 10h. Le routines BIOS non sono
// rientranti e cio' significa un crash di sistema assicurato. Questo gestore
// dell'int 10h alza un flag in ingresso, invoca il gestore originale e al
// rientro da questo resetta il flag. Detto flag deve essere testato
// nell'int 1Ch: se e' 1 bisogna lasciar perdere tutto e rinviare.

void far new10h(void)
{
    asm mov byte ptr _inInt10h,1;
    asm pushf;
    asm call dword ptr old10h;
    asm mov byte ptr _inInt10h,0;
    asm iret;
}

// anche new1Ch() e' dichiarata far, per ottenere maggiore efficienza. Quel
// poco che fa e' implementato in inline assembly; i lavori complessi sono
// curati da alcune funzioni di servizio, che possono essere implementate in
// C grazie alla dichiarazione _saveregs. La f() e' strutturata come segue:
// Se lo screen saver e' attivo si controlla se e' premuto un tasto. In caso
// affermativo si ripristinano il video, il contatore dei ticks di attesa, il
// contatore dei ticks di permanenza del banner, il flag di richiesta di
// restore e il flag di screen saver attivo. In caso negativo si esegue la
// funzione animate(). Se invece lo screen saver non e' attivo, si controlla
// se e' stato premuto un tasto. In caso affermativo si ripristinano il flag
// di tasto premuto (richiesta restore) e il contatore dei ticks di attesa. In
// caso negativo si controlla se il tempo di attesa e' scaduto (contatore ticks
// di attesa = 0). Se lo e' si esegue blankVideo() e si setta il flag di screen
// saver attivo. Se non lo e' si decrementa il contatore dei ticks di attesa.

void far new1Ch(void)
{
    asm cmp byte ptr _inInt10h,1;
    asm jne OK_TO_WORK;
    asm jmp EXIT;
  OK_TO_WORK:
    asm cmp byte ptr _saverActive,1;
    asm jne NOT_ACTIVE;
    asm cmp byte ptr _restoreFlag,1;
    asm je RESTORE_VIDEO;
    animate();
    asm jmp EXIT;
  RESTORE_VIDEO:
    restoreVideo();
    asm mov byte ptr _saverActive,0;
    asm mov word ptr _ticksForSpeed,0;
    asm jmp RESTORE_STATUS;
  NOT_ACTIVE:
    asm cmp byte ptr _restoreFlag,1;
    asm je RESTORE_STATUS;
    asm cmp word ptr ticksToWait,0;
    asm je BLANK_VIDEO;
    asm dec word ptr _ticksToWait;
    asm jmp EXIT;
  BLANK_VIDEO:
    asm mov byte ptr _saverActive,1;
    blankVideo();
    asm jmp EXIT;
  RESTORE_STATUS:
    asm mov byte ptr _restoreFlag,0;
    asm mov word ptr _ticksToWait,MAXTICKS;
  EXIT:
    asm iret;
}

// new2Fh gestisce il dialogo con il TSR. Se AH contiene HEY_YOU, l'interrupt
// e' stato chiamato dalla porzione transiente del programma stesso, dopo che
// la parte residente e' gia' stata installata, altrimenti e' un altro
// programma e non sono fatti nostri. Se AL contiene HANDSHAKE, e' la parola
// d'ordine: bisogna rispondere HERE_I_AM, cosi' la parte transiente sa che
// il TSR e' gia' installato e non tenta di reinstallarlo. Se AL contiene
// UNINSTALL, la parte transiente sta chiedendo alla parte residente di
// disinstallarsi. L'operazione e' semplice: basta ripristinare i vettori di
// interrupt e liberare la memoria allocata al TSR.
// ATTENZIONE: new2Fh() e' dichiarata far per maggiore efficienza e per poter
// restituire valori nei registri della CPU alla routine chiamante. Percio' e'
// indispensabile salvare e ripristinare, se usati, alcuni registri importanti:
// DS, ES, SI, DI. SI e DI, se usati in righe di inline assembly, sono salvati
// automaticamente dal compilatore in testa alla funzione: ecco perche' sono
// estratti dallo stack con le POP senzxa che ci siano le PUSH corrispondenti!!

void far new2Fh(void)
{
    asm cmp ah,HEY_YOU;     // riconoscimento: HEY_YOU?
    asm je SSS_CALLING;
  CHAIN:                    // no, la chiamata non viene da SSS: lasciamo stare
    asm pop di;              // pulisce stack: nella disinstallazione sono
    asm pop si;              // usati SI e DI, pertanto il compilatore il salva
    asm jmp dword ptr old2Fh;    // concatena gestore originale
  SSS_CALLING:
    asm cmp al,HANDSHAKE;      // vediamo cosa vuole SSS transiente
    asm jne NEXT1;                // SSS vuole sapere se siamo qui
    asm mov ax,HERE_I_AM;
    asm jmp EXIT;
  NEXT1:
    asm cmp al,UNINSTALL;         // o forse SSS vuole la disinstallazione
    asm jne CHAIN;
    asm push ds;          // qui si salvano solo DS e ES anche se sono usati
    asm push es;          // pure SI e DI perche' a loro pensa il compilatore
    asm cld;              // operazioni su stringhe di bytes incrementano SI DI
    asm cli;              // stop interrupts

// Disinstallazione, fase 1: ripristino dei vettori. Per ogni interrupt gestito
// dal TSR occorre caricare in DS:SI l'indirizzo della f() fittizia che ne
// contiene il vettore originale e in ES:DI l'indirizzo del vettore originale
// (che si trova nella tavola dei vettori). Poi si copiano 4 bytes dalla f()
// fittizia alla tavola dei vettori

    asm mov ax,seg old09h;
    asm mov ds,ax;
    asm mov si,offset old09h;   // DS:SI punta a old09h, cioe' al vettore orig.
    asm xor ax,ax;
    asm mov es,ax;
    asm mov di,0x09*4;          // ES:DI punta al vettore 09 nella tavola vett.
    asm mov cx,2;
    asm rep movsw;              // copia 2 words da DS:SI a ED:DI
    asm mov ax,seg old10h;
    asm mov ds,ax;
    asm mov si,offset old10h;
    asm xor ax,ax;
    asm mov es,ax;
    asm mov di,0x10*4;
    asm mov cx,2;
    asm rep movsw;
    asm mov ax,seg old1Ch;
    asm mov ds,ax;
    asm mov si,offset old1Ch;
    asm xor ax,ax;
    asm mov es,ax;
    asm mov di,0x1C*4;
    asm mov cx,2;
    asm rep movsw;
    asm mov ax,seg old2Fh;
    asm mov ds,ax;
    asm mov si,offset old2Fh;
    asm xor ax,ax;
    asm mov es,ax;
    asm mov di,0x2F*4;
    asm mov cx,2;
    asm rep movsw;
    asm mov ax,seg old33h;
    asm mov ds,ax;
    asm mov si,offset old33h;
    asm xor ax,ax;
    asm mov es,ax;
    asm mov di,0x33*4;
    asm mov cx,2;
    asm rep movsw;

// Disinstallazione, fase 2: restituzione al DOS della memoria allocata al TSR.
// Si carica in ES l'indirizzo di sgmento del Memory Control Block che il DOS
// ha costruito per il TSR. Il MCB si trova nei 16 bytes che precedeono il PSP
// del TSR, percio' il suo indirizzo e' (PSP-1):0000. Ad offset 1 nel MCB c'e'
// una word che contiene l'indirizzo di segmento del PSP del programma che
// possiede il blocco di ram: se contiene 0 il blocco e' libero. Quindi basta
// caricare 1 in DI e scrivere 0 nella word all'indirizzo ES:DI.

    asm mov ax,word ptr resPSP;
    asm dec ax;
    asm mov es,ax;
    asm mov di,1;               // ES:DI punta al campo owner del MCB del TSR
    asm xor ax,ax;
    asm stosw;                  // azzera il campo: la ram e' restituita al DOS
    asm sti;              // riabilita interrupts
    asm mov ax,HERE_I_AM;
    asm pop es;           // pulisce stack: vedere sopra per SI e DI
    asm pop ds;
  EXIT:
    asm pop di;             // pulisce stack: nella disinstallazione sono
    asm pop si;             // usati SI e DI, pertanto il compilatore il salva
    asm iret;                  // fine operazioni per SSS transiente
}

// nuovo gestore dell'int 33h; non serve dichiararlo interrupt perche' non
// usa nessun registro. E' analogo al gestore dell'int 09h, ma, invece di
// sentire la tastiera, sente il mouse.

void far new33h(void)
{
    asm mov byte ptr _restoreFlag,1;
    asm cmp byte ptr _saverActive,1;
    asm je EAT_MOUSE;
    asm jmp dword ptr _old33h;    // se SSS e' inattivo lasciamo fare al driver
  EAT_MOUSE:
    asm iret;             // se bisogna annullare il mouse rientra direttamente
}

// animate() effettua le operazioni di animazione del video mentre lo screen
// saver e' attivo. E' opportuno che NON utilizzi f() di libreria C, onde
// poter lasciare residente solo le f() appositamente definite nel sorgente.
// La dichiarazione _saveregs mette new1Ch() al riparo da brutte sorprese.

void _saveregs animate(void)
{
    register i, offset;
    int far *vPtr;

// se il contatore di permanenza del banner a video e' zero, viene riportato
// al valore inziale e si entra nell'algoritmo di gestione del banner

    if(!*(int _cs *)ticksForSpeed) {
        *(int _cs *)ticksForSpeed = MAXSPEED;

// viene utilizzato l'offset a cui e' stato scritto il banner l'ultima volta
// per settare il puntatore al video e cancellarlo. Gli offsets sono nell'array
// appositamente definito con una f() fittizia e sono referenziati con un
// indice anch'esso definito in una f() fittizia.

        offset = ((int _cs *)resBannerOffs)[*(int _cs *)currBannerOff];
        vPtr = (int far *)MK_FP(DEFAULTVIDEO,offset);
        for(i = 0; i < *(int _cs *)resBannerLen; i++)
            vPtr[i] = DEFAULTBLANK;

// se l'offset utilizzato l'ultima volta e' l'ultimo nell'array si riparte dal
// primo, altrimenti si usa il successivo.

        if(*(int _cs *)currBannerOff == MAXPOS)
            *(int _cs *)currBannerOff = 0;
        else
            ++(*(int _cs *)currBannerOff);

// l'uso delle variabili register rende piu' leggibile il codice. Il nuovo
// offset e' memroizzato nella variabile omonima

        offset = ((int _cs *)resBannerOffs)[*(int _cs *)currBannerOff];

// in i e' memorizzato lo stesso offset, aumentato della lunghezza del banner
// moltiplicata per 2. In pratica, i contiene l'offset al quale dovrebbe
// essere scritto l'ultimo carattere del banner

        i = offset+(*(int _cs *)resBannerLen)*2;

// dividendo un offset video per il numero di colonne video (raddoppiato, per
// tenere conto del byte attributo) si ottiene la riga video in cui cade
// l'offset stesso. Se le righe risultanti applicando il calcolo all'offset
// del primo e dell'ultimo carattere del banner, significa che questo verrebbe
// scritto "a cavallo" tra due righe. Per evitare l'inconveniente si
// decrementa l'offset di inizio della lunghezza del banner (per 2), ottenendo
// cosi' un offset approssimato per difetto che consente sicuramente di
// scrivere tutto il banner su una sola riga.

        if((offset/(DEFAULTCOLS*2)) != (i/(DEFAULTCOLS*2))) {
            offset -= (*(int _cs *)resBannerLen)*2;

// gia' che siamo, modifichiamo anche il valore presente nell'array, in modo
// tale che quando saranno stati utilizzati tutti gli offsets almeno una
// volta, non ci sara' piu' necessario applicare alcuna correzione.

            ((int _cs *)resBannerOffs)[*(int _cs *)currBannerOff] = offset;
        }

// si inizializza il puntatore con l'offset eventualmente corretto e si
// scrive il banner.

        vPtr = (int far *)MK_FP(DEFAULTVIDEO,offset);
        for(i = 0; i < *(int _cs *)resBannerLen; i++)
            ((char far *)vPtr)[i*2] = ((char _cs *)resBanner)[i];
    }
    else

// se il contatore non e' zero lo si decrementa, prima o poi si azzerera'...

        --(*(int _cs *)ticksForSpeed);
}

// blankVideo() copia nel buffer aaposito la videata presente sul display al
// momento dell'attivazione delloscreen saver e, contemporaneamente, scrive a
// video il carattere e l'attributo definiti come DEFAULTBLANK. La
// dichiarazione _saveregs mette new1Ch() al riparo da brutte sorprese.

void _saveregs blankVideo(void)
{
    register counter;
    int far *vPtr;

// inizializzazione del puntatore alla memoria video

    vPtr = (int far *)MK_FP(DEFAULTVIDEO,0);

// effettuazione della copia della memoria video nel buffer apposito e
// contemporanea cancellazione del video

    for(counter = 0; counter < DEFAULTCOLS*DEFAULTROWS; counter++) {
        ((int _cs *)videoBuf)[counter] = vPtr[counter];
        vPtr[counter] = DEFAULTBLANK;
    }

// e adesso facciamo sparire il cursore, salvando le sue coordinate attuali e
// spostandolo fuori dal video. E' ok metterlo sulla riga DEFAULTROWS perche'
// la numerazione BIOS delle righe va da 0 a DEFAULTROWS-1.

    _AH = 3;
    _BH = DEFAULTPAGE;
    geninterrupt(0x10);
    *(char _cs *)savedRow = _DH;
    *(char _cs *)savedCol = _DL;
    _DH = DEFAULTROWS;
    _AH = 2;
    geninterrupt(0x10);
}

// restoreVideo() ripristina la videata presente sul display al momento della
// attivazione dello screen saver. La dichiarazione _saveregs mette new1Ch() al
// riparo da brutte sorprese.

void _saveregs restoreVideo(void)
{
    register counter;
    int far *vPtr;

    vPtr = (int far *)MK_FP(DEFAULTVIDEO,0);
    for(counter = 0; counter < DEFAULTCOLS*DEFAULTROWS; counter++)
        vPtr[counter] = ((int _cs *)videoBuf)[counter];

// rimettiamo a posto il cursore, utilizzando le coordinate salvate in
// precedenza

    _DH = *(char _cs *)savedRow;
    _DL = *(char _cs *)savedCol;
    _BH = DEFAULTPAGE;
    _AH = 2;
    geninterrupt(0x10);
}

// fine della parte residente del TSR. Tutto quello che serve al TSR per
// lavorare, a patto che animate() e sue eventuali subroutines non utilizzino
// funzioni di libreria, sta al di sopra di queste righe di commento. Cio'
// consente di limitare al massimo la quantita' di memoria allocata in modo
// permanente al TSR.

/*---------------------------------------------------------------------------*/

// inizia qui la parte transiente del TSR. Tutte le f() definite a partire
// da questo punto vengono buttate via quando il programma si installa in
// memoria. Queste f() possono fare tutto quello che vogliono, usare f() di
// libreria, variabili globali e statiche, etc.

// releaseEnv() butta alle ortiche l'environment del TSR: dal momento che
// questo non lo utilizza per le proprie attivita' e' inutile lasciarlo li' a
// occupare memoria. Inoltre, dal momento che releaseEnv() e' la prima delle
// funzioni definita fuori dalla parte residente, il suo indirizzo puo' essere
// utilizzato per calcolare quanta ram lasciare residente (secondo parametro)
// della keep()). Restituisce 0 se tutto ok.

int releaseEnv(void)
{
    extern unsigned _envseg;        // variabile non documentata in Borland C++

    return(freemem(_envseg));
}

// areYouThere() e' l'interfaccia di comunicazione con l'int 2Fh, che viene
// invocato passando HEY_YOU in AH e il numero del servizio richiesto in AL.
// L'int 2Fh risponde sempre HERE_I_AM in AX per segnalare che il servizio e'
// stato espletato.

unsigned areYouThere(char service)
{
    union REGS regs;

    regs.h.ah = HEY_YOU;
    regs.h.al = service;
    return(int86(0x2F,&regs,&regs));
}

// per evitare di utilizzare funzioni di libreria nelle routines residenti, si
// inizializza un array di offsets video ai quali scrivere in sequenza il
// banner. Gli offsets sono generati in modo pseudocasuale. La divisione e
// successiva moltiplicazione applicate al valore restituito da random()
// assicurano che l'offset cosi' ottenuto sia sempre pari.

void initializeOffsets(void)
{
    register i;

    randomize();
    for(i = 0; i < MAXPOS; i++)
        ((int _cs *)resBannerOffs)[i] = (random(DEFAULTROWS*DEFAULTCOLS*2)/2)*2;
}

// install() effettua l'installazione in memoria del TSR, attivando i nuovi
// vettori di interrupt e chiedendo al DOS di riservare al programma la
// memoria necessaria. Questa e' calcolata come differenza tra l'indirizzo
// di releaseEnv() (prima f() transiente) trasformato in indirizzo di segmento
// (cioe' seg+(off/16) arrotondato per eccesso (+1) per sicurezza) e
// l'indirizzo al quale e' caricato (quello del suo PSP). L'indirizzo di
// segmento del PSP (_psp, definita in DOS.H) e' salvato nello spazio riservato
// dalla f() fittizia opportunamente definita: serve al gestore dell'int 2Fh
// per la disinstallazione del programma.

void install(char *banner)
{
    register len;

    if((len = strlen(banner)) > MAXBANNER)
        printf("%s: Could not install. Banner too long (max. %d chr.)\n",PRG,
                                                                    MAXBANNER);
    else
        if(releaseEnv())
            printf("%s: Could not install. Error releasing environment.\n",PRG);
        else {
            *(int _cs *)resPSP = _psp;
            *(int _cs *)resBannerLen = len;
            _fstrcpy((char _cs *)resBanner,(char far *)banner);
            initializeOffsets();
            asm cli;
            *(long _cs *)old09h = (long)getvect(0x09);
            *(long _cs *)old10h = (long)getvect(0x10);
            *(long _cs *)old1Ch = (long)getvect(0x1C);
            *(long _cs *)old2Fh = (long)getvect(0x2F);
            *(long _cs *)old33h = (long)getvect(0x33);
            setvect(0x09,(void(interrupt *)())new09h);
            setvect(0x10,(void(interrupt *)())new10h);
            setvect(0x1C,(void(interrupt *)())new1Ch);
            setvect(0x2F,(void(interrupt *)())new2Fh);
            setvect(0x33,(void(interrupt *)())new33h);
            asm sti;
            printf("%s: Installed. Invoke with %s to uninstall.\n",PRG,UNINST_OPT);
            keep(0,FP_SEG(releaseEnv)+FP_OFF(releaseEnv)/16+1-_psp);
        }
}

// uninstall() richiede all'int 2Fh la disinstallazione del programma. Se
// areYouThere() non risponde HERE_I_AM e' accaduto qualcosa di strano: in
// teoria cio' dovrebbe avvenire solo se il TSR non e' residente, ma dato che
// prima main() effettua questo controllo prima di invocare uninstall(), la
// probabile causa dell'errore e' che tra le due fasi (controllo e richiesta)
// qualche altro TSR abbia incasinato la memoria disattivando il nostro
// gestore di int 2Fh.

void uninstall(void)
{
    if(areYouThere(UNINSTALL) == HERE_I_AM)
        printf("%s: Uninstalled. Vectors restored and RAM freed up.\n",PRG);
    else
        printf("%s: Unidentified error.\n",PRG);
}

// main() controlla se il TSR e' residente: in tal caso l'unica azione
// possibile e' la disinstallazione. In caso contrario si puo' tentare
// l'installazione

void main(int argc,char **argv)
{
    printf("%s %s - Sample Screen Saver - Barninga Z! '%s.\n",PRG,REL,YEAR);
    if(argc != 2)
        printf("%s: Syntax error. Usage: %s bannerString | *\n",PRG,PRG);
    else
        if(areYouThere(HANDSHAKE) == HERE_I_AM)
            if(!strcmp(argv[1],UNINST_OPT))
                uninstall();
            else
                printf("%s: Could not install. Already active in RAM.\n",PRG);
        else
            install(argv[1]);
}