dal 2015 - visita n. 558
TpuBase
TpuBase

 

TpuBase

Le Procedure/Funzioni TPUBASE per TurboPASCAL (4.07.0) sono delle primitive orientate alla gestione delle problematiche hardware. Le TPUBASE sono caratterizzate dalla iniziale X (eXtended).
Queste procedure vengono costruite tramite la unit TPUBASE.PAS integrata dal file interface TPUBASE.INT e dal file implementation TPUBASE.IMP.


Sezioni Esterne in PascalSezioni Esterne in Assembly
  • Nessuna

Documentazione


Function XTestCPU: Word;
Riporta, per il tipo di CPU le seguenti word Hex:
$0086 INTEL 8086 $0088 INTEL 8088
$0186 INTEL 80186 $0188 INTEL 80188
$0030 NEC V30 $0020 NEC V20
$0286 INTEL 80286
$0386 INTEL 80386
$0486 INTEL 80486
Es.: B:=XTestCPU;

Function XTestNDP: Byte;
Riporta, per il tipo di Coprocessore le seguenti word Hex:
$0000 Non Installato
$0087 8087
$0287 80287
$0387 80387
Es.: B:=XTestNDP;

Procedure XMinMem;
Minimizza la memoria allocata dal DOS per l'esecuzione del programma in
corso. Da richiamare "una tantum" prima di usare XHoldMem.
Utilizzare la direttiva di compilazione {$M}, ad esempio {$M 8192,0,0}
Es.: XMinMem;

Function XHoldMem (Parag: Word): Word;
Alloca e legge in W il Segmento in cui risultano allocati NumPar Para-
grafi di memoria. Se W=0 non stata possibile l'allocazione.
Utilizzare la direttiva di compilazione {$M}, ad esempio {$M 8192,0,0}
Es.: W:=XHoldMem(NumPar);

Procedure XFreeMem (Segm: Word; Var Err: Word);
Dealloca la memoria allocata da XHoldMem in Seg. Se Err<>0 non stata
possibile la deallocazione. Vedere XMinMem.
Utilizzare la direttiva di compilazione {$M}, ad esempio {$M 8192,0,0}
Es.: XFreeMem(Seg,Err);

Function XFirstMCB: Word;
Restituisce il Segment del primo MCB.
.----+------------+----------+---------+--------------+- - - - - -
|0 |1 |3 |5 |8 |10h
+----+------------+----------+---------+--------------+- - - - - -
|Tipo|Proprietario|Dimensioni|Non Usato|Nome Programma|Start PSP
|M/Z |(0000 = DOS)|in Paragr.| | |
`----+------------+----------+---------+--------------+- - - - - -

Function XNextMCB (PrevMCB: Word): Word;
Restituisce il Segment dell'MCB successivo.

Procedure XOffA20;
Disattiva la linea A20.
Es.: XOffA20;

Procedure XOnA20;
Attiva la linea A20 (Disponibili 64 Kb di Memoria HiMem da FFFF:0010 a
FFFF:FFFF). Incompatibile con MsDos 5.0 se viene usata la HIMEM.
Es.: XOnA20;

Function XTestA20: Boolean;
Legge lo stato di A20.
Es.: L:=XTestA20;

Procedure XHardCopy;
HardCopy dello schermo.
Es.: XHardCopy;

Function XPrinterOK (N: Byte): Boolean;
L=True se la stampante N disponibile.
Es.: L:=XPrinterOK(N);

Function XReadICA (N: Word): Word;
Legge in W la word N dell'area ICA. Vedi Nota in XWriteICA.
Es.: W:=XReadICA(N);

Procedure XWriteICA (W,N: Word);
Scrive W nell'elemento N dell'area ICA.
L'Area di Comunicazione Intra-applicazioni un'area riservata di 8
word da 0000:04F0 a 0000:04FF. E' particolarmente utile per quei pro-
grammi che vengono eseguiti separatamente dal DOS ma devono lasciare
informazioni per altri programmi della stessa famiglia. Le Word si in-
tendono numerate da 0 a 7.
Es.: XWriteICA(W,N);

Procedure XResetH;
Provoca il Reset Hardware (Pulsante).
Es.: XResetH;

Procedure XResetS;
Provoca il Reset Software (Ctrl+Alt+Del).
Es.: XResetS;

Procedure XInstallInt (NumInt: Byte; SegInt,OfsInt: Integer;
Var Blocco: Blk_I);
Istalla come gestore dell'interrupt NumInt la procedura allocata al
Segmento SegInt e Offset OfsInt. Restituisce nel record Blocco: Segmento,
Offset e Numero del precedente gestore.

Procedure XRemoveInt (Var Blocco: Blk_I);
Complementare della Install_Int: ripristina il precedente gestore di
interrupt.

Function XExec (PrgName: String): Byte;
Esegue il Programma specificato da PrgName e riporta l'eventuale byte
di ERRORLEVEL passato da PrgName al DOS. Si noti che i comandi interni
del DOS mantengono l'ERRORLEVEL dell'ultimo comando esterno.
Utilizzare la direttiva di compilazione {$M}, ad esempio {$M 8192,0,0}
Es.: B:=XExec('MASM PROVA;');
Esegue MASM PROVA; e riporta 0 se MASM si concluso corret-
tamente altrimenti il valore ERRORLEVEL passato al DOS.

Procedure XQuickExec (PrgName: String);
Versione semplificata di XExec da usare quando non interessa il valore
di ERRORLEVEL.
Utilizzare la direttiva di compilazione {$M}, ad esempio {$M 8192,0,0}
Es.: B:=XQuickExec('CHKDSK /F');

Procedure XQuickExecOvr (PrgName,SufOvr,SufExe,Param: String);
Versione particolare di XQuickExec da usare, in via eccezionale,
quando occorra lanciare un programma EXE o COM camuffato da OVR.
PrgName il Path privato dell'eventuale suffisso, SufOvr il
suffisso come si trova sul disco, SufExe il suffisso di RunTime e
pu essere 'COM' o 'EXE', Param la stringa parametri passata al
programma.
Utilizzare la direttiva di compilazione {$M}, ad esempio {$M 8192,0,0}
Es.: B:=XQuickExecOvr('PROVA','OVR'.'COM','/F');
Rinomina il file PROVA.OVR in PROVA.COM, lo manda in esecuzione
e quindi lo rinomina di nuovo in PROVA.OVR

Function XExec4B (PrgName,ComLine: String): Byte;
Esegue il Programma specificato da PrgName e ComLine (Parametri della
riga comando), e ne riporta il byte ERRORLEVEL. Per i comandi interni
del DOS utilizzare una seconda copia di COMMAND.COM come mostrato nel
secondo esempio.
I File .BAT vengono eseguiti fornendo il path completo e una copia di
COMMAND.COM.
Utilizzare la direttiva di compilazione {$M}, ad esempio {$M 8192,0,0}
Es.: B:=XExec4B('MASM.EXE','PROVA;');
Esegue MASM PROVA; e riporta 0 se MASM si concluso corret-
tamente altrimenti il valore di ERRORLEVEL.
Es.: B:=XExec4B('\COMMAND.COM','/C DIR *.PAS /W');
Esegue DIR *.PAS /W

Procedure XPasExecSwp (Prg,Cml: String): Byte;
Esegue il Programma specificato da Prg e Cml (Parametri della riga
comando), e ne riporta il risultato in DosERROR.
Per i comandi interni del DOS usare una seconda copia di COMMAND.COM
come mostrato nel secondo esempio.
I File .BAT vengono eseguiti fornendo il path completo e una copia di
COMMAND.COM.
Utilizzare la direttiva di compilazione {$M}, ad esempio {$M $4000,0,0},
come suggerito dalla Borland. La procedura contiene gi SwapVectors.
4EDa preferirsi nelle nuove applicazioni.
Es.: B:=XPasExecSwp('MASM','PROVA;');
Esegue MASM PROVA;
e riporta DOSERROR=0 se MASM si concluso correttamente.
Es.: B:=XPasExecSwp('\COMMAND.COM','/C DIR *.PAS /W');
Esegue DIR *.PAS /W

Function XSegPtr (P: Pointer): Word;
Restituisce il valore Segment del Puntatore P.
Es.: W:=XSegPtr(Ptr($4000,$58AA)); rende W=$4000
Solo a titolo esemplificativo si scelto un puntatore ottenuto
con la funzione Ptr, ma XSegPtr lavora con qualsiasi puntatore.

Function XOfsPtr (P: Pointer): Word;
Restituisce il valore Offset del Puntatore P.
Es.: W:=XOfsPtr(Ptr($4000,$58AA)); rende W=$58AA
Solo a titolo esemplificativo si scelto un puntatore ottenuto
con la funzione Ptr, ma XOfsPtr lavora con qualsiasi puntatore.

Function XAddPtr (P1,P2: Pointer): Pointer;
Somma al Puntatore P1 il Puntatore P2. Non viene effettuato alcun con-
trollo sull'eventuale overflow del risultato.
Es.: P:=XAddPtr(Ptr($4000,$58AA),Ptr($3000,$1000));
equivale a P:=Ptr($7000,$68AA);
Solo a titolo esemplificativo si sono scelti puntatori ottenuti
con la funzione Ptr, ma XAddPtr lavora con qualsiasi puntatore.

Function XSubPtr (P1,P2: Pointer): Pointer;
Sottrae dal Puntatore P2 il Puntatore P1. Non viene effettuato alcun
controllo sull'eventuale underflow del risultato.
Es.: P:=XSubPtr(Ptr($4000,$58AA),Ptr($3000,$1000));
equivale a P:=Ptr($1000,$48AA);
Solo a titolo esemplificativo si sono scelti puntatori ottenuti
con la funzione Ptr, ma XSubPtr lavora con qualsiasi puntatore.

Function XIncPtr (P: Pointer; I: Word): Pointer;
Incrementa il Puntatore P di un offset I, modificando se necessario
il segment, ma non viene effettuato alcun controllo sull'eventuale
overflow del risultato.
Es.: P:=XIncPtr(Ptr($4000,$58AA),$1000));
equivale a P:=Ptr($4000,$68AA);
Solo a titolo esemplificativo si sono scelti puntatori ottenuti
con la funzione Ptr, ma XIncPtr lavora con qualsiasi puntatore.

Function XDecPtr (P: Pointer; I: Word): Pointer;
Decrementa il Puntatore P di un offset I, modificando se necessario
il segment, ma non viene effettuato alcun controllo sull'eventuale
overflow del risultato.
Es.: P:=XIncPtr(Ptr($4000,$58AA),$1000));
equivale a P:=Ptr($4000,$48AA);
Solo a titolo esemplificativo si sono scelti puntatori ottenuti
con la funzione Ptr, ma XDecPtr lavora con qualsiasi puntatore.

Function XNormPtr (P: Pointer): Pointer;
Normalizza il Puntatore P, ossia rende massimo il valore del suo
Segment e minimo il valore del suo Offset; ci consente all'Offset
di poter spaziare per 64 Kbyte in avanti.
Es.: P:=XNormPtr(Ptr($4000,$58AA));
equivale a P:=Ptr($458A,$000A);
Solo a titolo esemplificativo si scelto un puntatore ottenuto
con la funzione Ptr, ma XNormPtr lavora con qualsiasi puntatore.

Function XIsMEM: Word;
Restituisce in KByte l'ammontare di memoria convenzionale installata.
Es.: W:=XIsMEM;

Function XIsXMS: Word;
Restituisce in KByte l'ammontare di memoria estesa installata.
Es.: W:=XIsXMS;

Function XTestAnsi: Boolean;
Restituisce TRUE se il device ANSI.SYS risulta istallato.
Es.: B:=XTestAnsi;

Procedure XCLI;
Disattiva ricezione segnali di interrupt.

Procedure XSTI;
Riattiva ricezione segnali di interrupt.

Function XTestMSCDEX: Boolean;
Restituisce TRUE se il device MSCDEX risulta istallato.
Es.: B:=XTestMSCDEX;

Function XTestDriveCD(Drive: Byte): Boolean;
Restituisce TRUE se il drive specificato un lettore di CD-ROM.
Codice Drive: 0=A 1=B ...
Es.: B:=XTestDrive(3);

Function XTestSMARTDRV(Var H,M: LongInt; Var V: Word): Boolean;
Verifica la presenza di SMARTDRV e, in caso affermativo, ne riporta
le caratteristiche: Versione in V in formato BCD, Cache Hits in H,
Cache Misses in M.
Es.: B:=XTestSMARTDRV(H,M,V);

Function XMySelf: String;
Restituisce il Path completo del programma appena avviato.
Funziona con il DOS 3.0 o superiore.
Es.: St:=XMySelf;

Procedure XFillByte(PSeg,POfs,Count: Word; B: Byte);
Riempie l'area PSeg:POfs con Count byte B. Analoga alla FillChar del
TurboPASCAL, ma con parametri diversi.
Es.: XFillByte(PSeg,POfs,K,B);

Procedure XFillByteA(PSeg,POfs,Count: Word; B: Byte);
Riempie l'area PSeg:POfs con Count byte B, ma in modo alterno un byte
si e l'altro no.
Es.: XFillWordA(PSeg,POfs,1000,$41);

Procedure XFillWord(PSeg,POfs,Count,W: Word);
Riempie l'area PSeg:POfs con Count word W. Analoga alla FillChar del
TurboPASCAL, ma gestisce word anzich char.
Es.: XFillWord(PSeg,POfs,2000,$1741);

Procedure XFillPatt(PSeg,POfs: Word; Patt: String; Count: Word);
Riempie l'area PSeg:POfs con Count Patt.
Es.: XFillPatt(PSeg,POfs,Pattern,2000);

Procedure XFillPatt(PSeg,POfs: Word; Patt: String; Count: Word);
Riempie l'area PSeg:POfs con Count Patt, ma in modo alterno un byte
si e l'altro no.
Es.: XFillPattA(PSeg,POfs,Pattern,2000);

Procedure XMoveB(SegS,OfsS,SegD,OfsD,N: Word);
Copia il blocco di N Byte da SegS:OfsS a SegD:OfsD, all'interno della
memoria convenzionale.

Procedure XMoveW(SegS,OfsS,SegD,OfsD,N: Word);
Copia il blocco di N Word da SegS:OfsS a SegD:OfsD, all'interno della
memoria convenzionale.




TpuBase
TpuBit
TpuCrono
TpuFile
TpuModeX
TpuStr



Tentando, molte cose si riesce a compiere, che i neghittosi credevano impossibili.
Tacito

Valid CSS!
pagina generata in 0.001 secondi