Total Hack Cheat
Benvenuto/a su Total hack Cheat....
non aspettate altro tempo Registratevi!!

parte 5 guida linguaggo C

Vedere l'argomento precedente Vedere l'argomento seguente Andare in basso

parte 5 guida linguaggo C

Messaggio Da RaYoZ il Gio Mag 20, 2010 12:17 pm

Interrupts DOS

Durante la trattazione precedente avevo suddiviso i vari tipi di interrupts in harware, del BIOS e del DOS.
Gli interrupts hardware sono costituiti da precise richieste che vengono fatte dalle varie periferiche affacciate sul bus di controllo.
Quelli del BIOS si incaricano invece della gestione dell' hardware mediante richieste software.
Gli interrupt che vedremo ora sono quelli del DOS.
Il primo tipo di interrupts, come abbiamo visto, possono solo essere mascherati in modo di farli ignorare al processore.
Con gli ultimi due invece possiamo modificare le routine software di servizio in modo da adattarli ai nostri scopi.
Gli interrupt del DOS sono dedicati a scopi orientati piu' alla gestione

dei file e dei programmi che verso l'hardware del sistema.
Durante la trattazione di questi interrupts vedremo anche i concetti legati agli argomenti a cui questi si interessano.
Vedremo i concetti realtivi alla FAT, al PSP, al FCB e al Dos Critical Flag, solo per portare alcuni esempi.
Nei paragrafi precedenti avevo utilizzato i vari interrupt che si interessavano a determinate periferiche per raggruppare sotto questi

anche le porte e le locazioni di memoria che svolgevano particolari compiti o che contenevano informazioni relative a queste.
Nei capitoli seguenti utilizzero' lo stesso metodo per trattare i concetti legati alle argomentazioni relative ai servizi degli interrupts stessi.
Sono da considerarsi interrupts del DOS i seguenti :

20H - Program terminate
21H - Function request
22H - Terminate address
23H - Ctrl-break exit address
24H - Critical error handler vector
25H - Absolute disk read
26H - Absolute disk write
27H - Terminate but stay resident
2FH - Printer

L'interrupt piu' importante, quello che tratteremo per primo, e' il 21H al quale sono collegati un grosso numero di servizi svolti.
Due sole parole prima di iniziare a descrivere le varie funzioni svolte da questo.
Come nel caso degli interrupts del Bios che svolgono piu' servizi anche in questo caso la selezione della funzione viene fatta mediante il registro AH.
Ricordo che le funzioni del compilatore Microsoft C che si interessano all'interrupt 21H sono esattamente bdos(), intdos() e intdosx().



Servizi interrupt 21H

00H - Program terminate

Questa call esegue la stessa funzione dell'interrupt 20H, che vedremo piu' avanti.
Fate attenzione in quanto una chiamata a questo servizio non chiude automaticamente gli eventuali files che avevate aperto durante

l'esecuzione del programma.
Il servizio non restituisce alcun valore.


01H - Keyboard input

La funzione legge un carattere in input e lo visualizza sullo standard di output.
Il codice del carattere viene restituito in AL a patto che questo sia un codice ASCII.
Nel caso che invece il valore restituito da AL sia 0 sara' necessaria una successiva chiamata al servizio per la lettura del codice secondario.
Infatti AL = 0 significa che il carattere battuto e' speciale (vedi paragrafo relativo ai codici secondari).


02H - Display output
In questo sevizio il carattere inserito in DL viene visualizzato sullo schermo.


03H - Auxiliary Input

Il servizio inputa un carattere da un dispositivo ausiliario (AUX, COM1, COM2).
I parametri relativi possono essere settati mediante alcune funzioni di interrupt che abbiamo visto precedentemente.
Il carattere e' ritornato nel registro AL.


04H - Auxiliary Ooutput

Mentre il servizio precedente inputava (termine inglese italianizzato) questo manda in uscita sulla porta ausiliaria il carattere specificato in DL.

Non ci sono registri che riportano valori di ritorno.
Il discorso relativo al settaggio della porta e' lo stesso fatto per la funzione precedente.


05H - Printer Output

Invia il carattere specificato in DL sulla porta della stampante.


06H - Direct console I/O

In questo servizio i registri svolgono i seguenti compiti.
AH, come al solito, contiene l'identificatore del servizio e precisamente 6.
Se DL contiene 0xFF allora AL ritorna il flag di zero che se e' a 0 indica la presenza di un dato pronto in ingresso.
Nel caso che il flag di zero sia a 1 allora significa che non e' pronto nessun dato.
Se DL non e' 0xFF allora il codice sara' relativo a un dato che deve essere inviato in uscita (caratteri da 0x00 a 0xFE).
Durante l'esecuzione di questo servizio il break e' sospeso.


07H - Direct Console Input Without Echo

Attende un carattere in input e lo restituisce in AL.
Come nel caso della call 01H anche in questo servizio se il valore ritornato e' 0 significa che e' necessaria una successiva lettura per avere il codice secondario del carattere.


08H - Console Input Without Echo

AL ritorna il carattere letto dalla tastiera senza visualizzarlo
sullo schermo.


09H - Print String

Fino a questo punto non ho riportato esempi in quanto le funzioni
dei servizi erano banali.
Anche in questo caso non e' che il tutto sia piu' complicato ma e' in ogni caso meglio indicare come possano essere passati gli indirizzi delle stringhe da stampare a DS:DX.

Prima di vedere l'esempio riporto l'utilizzo che viene fatto dai registri in questo servizio.
Dicevo prima DS:DX.
DS conterra' il segmento in cui e' allocata la stringa mentre DX il suo

offset.
Un esempio simile lo avevo gia' riportato parlando delle funzioni del linguaggio C per il richiamo dell'interrupt 21H.


#include <dos.h>

union REGS inregs, outregs;

struct SREGS segregs;

char var[] = "Pippo$";

char far *var_2 = var;

main()
{
inregs.h.ah = 0x09;
segregs.ds = FP_SEG(var_2);
inregs.x.dx = FP_OFF(var_2);
intdosx(&inregs,&outregs,&segregs);
}

La stringa che deve essere stampata a video deve terminare con il
carattere '$' (codice ASCII 24H).


0AH - Buffered Keyboard Input

La call 0AH permette di eseguire un input da tastiera bufferizzato.
DS:DX in questo caso puntano al buffer.
Il primo byte del buffer indica al DOS quanti bytes dovra' accettare in input mentre il secondo verra' utilizzato per ritornare, dopo che e' stato battuto il tasto CR (ASCII 13), il numero di caratteri effettivamente letti.
In questo ultimo valore non e' incluso il carattere CR benche' questo venga collocato all'interno del buffer.


0BH - Check Standard Input Status

Questo servizio serve solo a testare se l'input da tastiera e' pronto o meno.

AL ritorna 0xFF se un carattere e' disponibile mentre 0x00 in caso

contrario.


0CH - Clear Keyboard Buffer and Invoke a Keyboard Function

La funzione svuota il buffer di tastiera e chiama una funzione.
AL contiene il numero della funzione da chiamare.
Fate attenzione in quanto i valori ammessi, relativi alle call, sono solo 01H, 06H, 07H, 08H e 0AH.



0DH - Disk Reset

Vengono chiusi tutti i buffer dei file.
Anche per questo servizio bisogna fare attenzione in quanto un eventuale file modificato e non chiuso non verrebbe salvato automaticamente.
Prima di eseguire la call e' conveniente chiudere tutti i files aperti.


0EH - Select Disk

DL contiene il numero di riferimento del drive selezionato (0=A:, 1=B:, ecc.)
AL riporta in uscita il numero dei drive presenti.


0FH - Open File

In questa funzione salta fuori, per la prima volta, un argomento che non avevamo trattato prima d'ora e precisamente quello relativo al FCB (File Control Block).
Il file control block e' un area di 44 bytes che il DOS utilizza per contenere le informazioni relative al file utilizzato.
Possiamo suddividere il FCB in due blocchi uno di 7 e uno di 37 bytes.
Il primo blocco, quello di 7 bytes, viene utilizzato solo in casi particolari come ad esempio in quello in cui lavoriamo su file hidden o di sistema.
Il blocco piu' lungo, quello da 37 bytes, viene invece utilizzato tutte le volte per mantenere dati quali il nome del file, le dimensioni e altri che ora vedremo mediante una schematizzazione.
Il primo blocco viene normalmente chiamato Extended File Controll Block mentre il secondo Standard File Controll Block.

Vediamo lo schema schema riportato dal Technical Reference :

+---------+----------------------------------+---------+
: FFH : Zeri :Attributi:
+--------+---------+----------------------------------+---------+
: Drive : Nome file (8 bytes) o nome device :
+--------+---------------------------------+----------+---------+
: : Estensione :Curr.block: Dimens. :
+--------+---+--------------+--------------+----------+---------+
:Dimen. low :Dimens. hight : Data : :
+------------+--------------+--------------+ :
: Riservato per uso del DOS :
+------------+--------------+----------------+------------------+
:Curr.Record :Random rec low:Random rec hight:
+------------+--------------+----------------+



Vediamo ora di descrivere ogni campo del FCB.

Spiazzamento Dimensione Note
--------------+----------------+--------------------------------
-7 1 Flag di presenza extended FCB.
E' presente se contiene FFH.
-6 5 Contiene tutti 0 (00000).
-1 1 Attributo del file
0 1 (*1*) Numero del drive
1 8 Nome del file giustificato a
sinistra o nome device.
9 3 Estensione del file giustificata
a sinistra.
12 2 Numero blocco corrente
14 2 Dimensioni record
16 4 Dimensione del file
20 2 (*2*) Data del file
22 10 Riservati al DOS
32 1 Numero del record (0-127)
33 4 Numero record casuale

Come avrete notato ho contrassegnato due campi con (*x*) per potergli aggiungere qualche nota.
A riguardo del numero del drive (*1*) e' necessaria fare una precisazione.
Il numero di riferimento al drive prima dell'apertura e'


0 - Drive di default
1 - Drive A
2 - Drive B
ecc.

Dopo l'apertura i riferimenti possono essere

1 - Drive A
2 - Drive B
ecc.

Parlando della data (*2*) bisogna specificare il formato di questa all'interno dei due bytes.

+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
:15 :14 :13 :12 :11 :10 : 9 : 8 : 7 : 6 : 5 : 4 : 3 : 2 : 1 : 0 :
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
: : : : : : : : : : : : : : : :
a a a a a a a m m m m g g g g g

dove
a = anno (1980-2099)
m = mese (1-12)
g = giorno (1-31)




Un discorso si puo' fare anche a riguardo degli attributi di un file.

00H - File normale
01H - Indica che il file e' marcato in sola lettura
02H - Indica un file hidden ovvero nascosto
04H - Indica un file di sistema
08H - Etichetta di volume
10H - E' una sub-directory
20H - Archivio. E' usato da BACKUP e RESTORE.

In linguaggio C il FCB potrebbe essere dichiarato come

char fcb[44];

Sull'argomento ritorneremo in seguito portando alcuni esempio d'uso.
Ritornando al discorso relativo alla call 0FH possiamo dire che i registri DS:DX devono puntare a un FCB non aperto.
In che modo possiamo settare questi registri ?
Una soluzione ci e' offerta dalle macro FP_OFF e FP_SEG.
La seconad soluzione e' invece quella di utilizzare la funzione del compilatore Microsoft bdos().
Se vi ricordate questa utilizzava come argomenti il numero della call, il valore del registro DX e quello del registro AL.


In questo caso AL, in ingresso, non ci serve a nulla e quindi potremo sfruttare la funzione nel seguente modo.

char fcb[44];

funz()
{
.......
.......
bdos(call,fcb);
}

Il registro AL conterra' di ritorno 00H se il file e' stato aperto con successo mentre FFH se il tentativo di apertura e' fallito.

10H - Close File

Mentre la funzione precedente apriva un file questa funzione lo chiude.
DS:DX in questo caso puntano a un FCB aperto.
Il registro AL ritorna dopo la chiamata della funzione 00H se il file e' stato trovato mentre FFH in caso contrario.


11H - Search for First Entry

La funzione cerca nella directory la prima corrispondenza al file specificato.
La funzione se trova il file corrispondente restituisce in AL 00H e piazza i dati relativi al file all'interno del FCB.
L'esempio che ora riportero' utilizza anche la funzione 12H (Search for Next Entry) che vedremo tra poco.
Il programma e' una combinazione di varie funzioni che abbiamo visto fino ad ora nei capitoli precedenti.
BYTEDIR2.C e' un piccolo file che provvede a mostrare in una finestra il contenuto delle dir specificate.
Oltre a cio' calcola il numero dei files presenti e la loro dimensione in bytes.
E' possibile quindi sapere sempre le dimensioni di ogni directory presente sul disco di deafult.

Sintassi : bytearea \path [opzione]

Opzioni : nessuna, A

Nessuna > Il risultato e' mostrato solo a video.
Viene segnalato errore se il path specificato non esiste.

Se si desidera operare sulla dir presente non e' necessario specificare il percorso.


A > Il risultato oltre che su video viene scritto su un file denominato AREA.STA.
Nel file AREA.STA verra' aggiunto alla fine il risultato.

Esempio : Path \bin : 1 files per un totale di 2 bytes

#include <stdio.h>
#include <dos.h>
#include <types.h>
#include <stat.h>
#include <direct.h>
#include <time.h>

#define SCREEN 0x10
#define BELL putchar('\007')

#define ??? /* ??? = CGA o HER */

#ifdef HER
char far *screen = 0xB0000000;
#endif

#ifdef CGA
char far *screen = 0xB8000000;
#endif

char matrix[25][80];
char attrib[25][80];

union REGS inregs, outregs;
struct stat files;

FILE *stream;
long total, k_byte;
int tot;
char dir_c[80];
char dir[300][14];
char bfr[135];
char fcb[44];
char buffer[64],buf_ret[64];
main(argc,argv)
int argc;
char *argv[];
{
int i, ch_d;
int risp;
tot=1;
total=0;
set_cur();
getcwd(buf_ret,64);
if(argc>1)
ch_d=chdir(argv[1]);
wind();
cur_mv(1,0);
printf("BYTEDIR by F. Bernardotti\n");
printf("(C) Copyright 1987 Opus AL\n\n\n");
if(ch_d== -1)
{
BELL;
printf("\n\n\n\n\n\n\n ERRORE : Path errato\33[1A");
goto end_pr;
}
getcwd(buffer,64);
printf("Path : %s",buffer);
cur_mv(9,0);
puts("------[DIRECTORY]------");
cur_mv(24,0);
puts("-----------------------\33[1A");
while(fi(dir[tot++],0,"????????","???",16) != NULL);
--tot;
for(i=1;i!=tot;i++)
{
clear(11,1,22,25,0,1);
cur_mv(6,0);
stat(dir[i],&files);
total += files.st_size;
printf("Files : %3d \nBytes : %ld", i, total);
cur_mv(22,0);
printf(" %s >%8ld",dir[i],files.st_size);
}
if(argc>2)
{
switch(*argv[2])
{
case 'A':
case 'a':
chdir(buf_ret);
sta();
stream=fopen("area.sta","a");
fprintf(stream,"\nPath %-48s : %03d files %08ld
bytes",buffer,tot,total);
break;
default:
BELL;
break;
}
}
end_pr:
cur_mv(24,Cool;
puts("[PREMI]\33[1A");
chdir(buf_ret);
risp=getc(stdin);
scrivi();
}

fi(b,drive,name,ext,tipo)
char *b;
char drive;
char *name;
char *ext;
char tipo;

{
int y;
register unsigned int regax;
register int i;
static int first_entry = 0;
y=0;
fcb[0] = 255;
strncpy(&fcb[1], "\0\0\0\0\0", 5);
fcb[6] = tipo;
fcb[7] = drive;
strncpy(&fcb[8], name, Cool;
strncpy(&fcb[16], ext, 3);
if (first_entry == 0)
{
first_entry = 1;
bdos(0x1A, bfr);
regax = bdos(0x11, fcb);
}
else
regax = bdos(0x12, fcb);
if ((regax & 0x00FF) == 0xff)
{
first_entry = 0;
return(NULL);
}
if(bfr[19] == 16)
{
b[13] = 1;
y=1;
}
else
b[13] = 0;
for(i = 0; i < 12;++i) b[i] = ' ';
for(i = 0; i < 8;++i) b[i] = bfr[i+8];
b[8] = '.';
if(y==0)for(i = 0;i < 3;++i) b[i+9] = bfr[i+16];
else
{
strcpy(&b[9],"<D>",3);
y=0;
}
}

clear(y_u,x_u,y_d,x_d,att,n_r)

int y_u,x_u,y_d,x_d,att,n_r;
{
inregs.h.ah=0x06;
inregs.h.ch=y_u;
inregs.h.cl=x_u;
inregs.h.dh=y_d;
inregs.h.dl=x_d;
inregs.h.al=n_r;
inregs.h.bh=att;
int86(SCREEN,&inregs,&outregs);
}

sta()
{
long ltime;
time(&ltime);
if((stream=fopen("area.sta","r")) == NULL)
{
fcloseall();
stream=fopen("area.sta","w");
fprintf(stream,"\nFile(s) e bytes nelle dir al %s\n\n",
ctime(&ltime));
fclose(stream);
}
}

set_cur()
{
inregs.h.ah=0x01;
inregs.h.cl=0x13;
inregs.h.ch=0x13;
int86(SCREEN,&inregs,&outregs);
}
cur_mv(x,y)
int x,y;
{
inregs.h.dh=x;
inregs.h.dl=y;
inregs.h.ah=0x02;
int86(SCREEN,&inregs,&outregs);
}

wind()
{
register riga, colonna;
for(riga=0;riga != 25;riga++)
for(colonna=0;colonna != 80;colonna++) {
matrix[riga][colonna] = *screen;
++screen;
attrib[riga][colonna] = *screen;
++screen;
}
clear(0,0,25,26,0,0);
}

scrivi()
{
register riga, colonna;
screen -= 4000;
for(riga=0;riga != 25;riga++)
for(colonna=0;colonna != 80;colonna++) {
*screen = matrix[riga][colonna];
++screen;
*screen = attrib[riga][colonna];
++screen;
}
cur_mv(23,1);
}


Come avrete notato al programma vengono applicate alcune funzioni, ad esempio per gestire la finestra video, che avevamo visto precedentemente.
La funzione con maggior importanza al fine delle call 11H e 12H e' in ogni caso fi().
Vediamo, a discapito dello spazio di questo file, di commentarlo.
Come compariva dal remark del programma precedente la chiamata alla funzione che cerca la corrispondenza del file nella directory era :

while(fi(dir[tot++],0,"????????","???",16);

dove dir[tot] e' l'elemento della matrice che conterra' i dati di un certo file.
0 indica il drive (0 = default).

"????????","???" sono un utilizzo dei caratteri jolly per dire che il file cercato corrisponde al primo, al secondo ecc. senza fare riferimento ad un nome di file specifico.
16 corrisponde all'attributo.

fi(b,drive,name,ext,tipo)
char *b; /* Indirizzo di DIR[TOT] */
char drive; /* Drive */
char *name; /* "????????" */
char *ext; /* "???" */
char tipo; /* Tipo */

{
int y;
register unsigned int regax;
register int i;
static int first_entry = 0;
y=0;

Tutte le seguenti operazioni di assegnazione settano le specifiche del file che deve essere cercato nella directory.

fcb[0] = 255; /* FFH 1 byte Extended FCB */
strncpy(&fcb[1], "\0\0\0\0\0", 5); /* 5 zeri */
fcb[6] = tipo;
fcb[7] = drive;
strncpy(&fcb[8], name, Cool;
strncpy(&fcb[16], ext, 3);

La prima ricerca di file deve essere fatta mediante la call 11H (Search For First Entry) e quindi la condizione if testa se effettivamente e' la prima volta che la funzione e' stata chiamata.
Nel caso che first_entry sia uguale a 0 potrete notare l'utilizzo di una call di cui non abbiamo ancora accennato nulla.
Si tratta della 1AH (Set Disk Transfer Address).
Per ora datela per scontata.
Ne parleremo tra un po'.

if (first_entry == 0)
{
first_entry = 1;
bdos(0x1A, bfr);
regax = bdos(0x11, fcb);
}
else

Nel caso che non sia la prima chiamata alla funzione allora la call da utilizzare e' la 12H (Search for Next Entry).

regax = bdos(0x12, fcb);


Se la funzione restituisce FFH allora significa che la ricerca ha avuto un esito negativo.
Restituendo NULL il ciclo while che chiamava fi() si interrompe.

if ((regax & 0x00FF) == 0xff)
{
first_entry = 0;
return(NULL);
}

Se il valore e' 16 allora significa che il file trovato e' una directory.
In questo caso setta y=1 che viene utilizzato come flag per delle funzioni puramente estetiche che seguono.

if(bfr[19] == 16)
{
b[13] = 1;
y=1;
}
else
b[13] = 0;

Il nome del file viene copiato all' indirizzo di dir[tot].

for(i = 0; i < 12;++i) b[i] = ' ';
for(i = 0; i < 8;++i) b[i] = bfr[i+8];

Se il flag e' uguale a uno allora e' una directory.
Nel caso che si tratti di un file nella posizione tra il nome e l'estensione viene messo un punto.

if(y==0) b[8] = '.';
else

Nel caso invece che sia una directory viene messo il segno '>'.

b[8] = '>';
if(y==0)for(i = 0;i < 3;++i) b[i+9] = bfr[i+16];
else

Anche in questo caso, se si tratta di una dir, al posto dell'estensione viene copiata la stringa "DIR".

{
strcpy(&b[9],"DIR",3);
y=0;
}
}


Il metodo applicato per la memorizzazione del contenuto del video allo scopo di gestire una finestra sul video e' quello relativo alla lettura diretta della memoria screen.
Questo porta all'incompatibilita' del programma compilato per scheda Hercules con quello per scheda CGA.
La compilazione in funzione di una o dell'altra si esegue mediante la sostituzione nella direttiva #define ??? dei ??? con le iniziali della scheda voluta.
Come avrete potuto notare negli esempi compaiono funzioni gia' viste molte volte precedentemente.
Questo conferma una delle notevoli potenzialita' del linguaggio C e cioe' quella di poter creare e gestire librerie contenenti le routine di cui facciamo sovente uso senza bisogno di doverle riscrivere continuamente.


12H - Search for Next Entry

DS:DX, come nel caso del servizio precedente, puntano al FCB.
L'uso della call e' stato gia' discusso in parte durante l'esempio precedente.
AL ritorna 00H se il file cercato e' stato reperito mentre FFH in caso contrario.
La funzione 12H puo' essere utilizzata dopo che una chiamata al 11H ha dato frutti positivi.
La modalita' d'uso e' in pratica la stessa del 11H.


13H - Delete File

I registri DS:DX puntano al FCB del file che si vuole cancellare.
AL restituisce 00H se il file e' stato cancellato mentre FFH se non e' stato reperito.


14H - Sequential Read

Il servizio legge un record indicato dal FCB nella memoria del DTA (Disk Transfer Area).
DS:DX puntano al FCB mentre AL restituisce il risultato dell'operazione e precisamente :

00H - Lettura eseguita positivamente
01H - Nessun data letto (EOF)
02H - DTA troppo piccolo
03H - EOF con lettura parziale

Del DTA parleremo con la funzione 1AH (Set Disk Transfer Address).


15H - Sequential Write

DS:DX puntano come al solito al FCB.
In questo caso la funzione si interessa della scrittura di un record sequenziale su disco.
I valori riportati da AL sono :

00H - Scrittura eseguita positivamente
01H - Dischetto pieno
02H - DTA troppo piccolo


16H - Create File

La funzione crea un file sul disco.
DS:DX puntano al FCB.
I valori restituiti in AL sono :

00H - Operazione eseguita correttamente
01H - Dischetto pieno
02H - DTA troppo piccolo


17H - Rename File

In questa funzione il FCB e' modificato in un modo strano.
Il nome del file occupa la solita posizione all'interno di questo mentre il nome del nuovo file e' all' indirizzo 16 del FCB (DS:DX
+ 11).
Come avrete capito DS:DX puntano al FCB.
L'utilizzo di caratteri jolly all'interno del nuovo nome indica che quella parte indicata e' uguale alla precedente situata nel nome da convertire.
Es.

Originale Nuovo nome Risultato
--------------------------------------------------------
OPUSCTL.EXE ????VCR.EXE OPUSVCR.EXE

Noterete in seguito (fino ad ora non e' capitato) che ci saranno degli intervalli numerici nei servizi del DOS.
Questi mancanti sono contrassegnati sul Technical Reference come
"Used Internally by DOS".
Di molte sono riuscito a trovare, faticosamente, la
documentazione non messa in circolazione dalla Microsoft.
Sinceramente non capisco come mai possano capitare queste cose.
Si dice che alcune funzioni non sono state documentate in quanto non viene garantito il mantenimento di queste nelle varie relase del Dos.


Sara' anche cosi ma sinceramente ho notato che alcune sono presenti in tutte le edizioni apparse fino ad ora.


19H - Current Disk

AL ritorna il numero del lettore in uso e cioe' 0 = A:, 1 = B: ecc.


1AH - Set Disk Transfer Address

Eccoci finalmente giunti alla funzione che setta l'indirizzo di trasferimento del disco.
Di default questo si trova al offset 80H del prefisso del segmento del programma ed e' lungo 128 byte.
Questa area di memoria viene utilizzata dal DOS per l' I/O dei file.
DS:DX si interessano di puntare a quest'area nel caso di settaggio mediante la call 1AH.
Questa funzione e' stata utilizzata precedentemente nella routine che leggeva la directory del disco mediante le funzioni Search for First Entry e Search for Next Entry.



1BH - Allocation Table Information

Con questo servizio diventa necessaria un' estensione del discorso relativo a quella definita FAT (File Allocation Table).
Il servizio riporta infatti informazioni riguardanti questa ultima.
Che cosa e' la FAT ?
La FAT viene utilizzata dal Dos per allocare lo spazio su disco per un file, un cluster alla volta.
Trattando dischetti floppy e hard disk possiamo ritrovarci di fronte a due formati diversi di questa.
Nel caso dei floppy ogni voce relativa ad un cluster e' di 12 bit ovvero 1.5 byte.
I clusters possono essere, in questo caso, 4086.
Nel caso di un disco fisso con piu' di 10 Mbytes ogni voce della FAT e' di 16 bit (2 bytes).
Vediamo i significati delle voci di questa.

RaYoZ
Admin
Admin

Messaggi : 1040
Punti : 2245
Data d'iscrizione : 03.04.10
Età : 22
Località : immerso nei pensieri

Tornare in alto Andare in basso

Vedere l'argomento precedente Vedere l'argomento seguente Tornare in alto

- Argomenti simili

 
Permesso di questo forum:
Non puoi rispondere agli argomenti in questo forum