Versione attuale delle 10:52, 13 giu 2024

La funzione write(), dichiarata nel file header /usr/include/unistd.h con la seguente sintassi:

ssize_t write (int __fd, const void *__buf, size_t __n)

scrive nel file, a cui si riferisce il descrittore di file __fd, un numero di byte definito da __n dal buffer puntato da __buf. Essa ritorna il numero di byte scritti, oppure -1 in caso di errore.

Poiché il suo nome è identico al nome della funzione Write di Gambas, è opportuno dichiararla con Extern mediante un nome fittizio, specificando con Exec il suo nome reale: ^{[nota 1]}

Private Extern write_C(__fd As Integer, __buf As Pointer, __n As Long) As Long Exec "write"

Mostriamo un esempio pratico:

Library "libc:6"

Private Enum O_RDONLY = 0, O_WRONLY, O_RDWR

' int open(const char *__file, int __oflag, ...)
' Open FILE and return a new file descriptor for it.
Private Extern open_C(__file As String, __oflag As Integer) As Integer Exec "open"

' ssize_t write (int __fd, const void *__buf, size_t __n)
' Write N bytes of BUF to FD.
Private Extern write_C(__fd As Integer, __buf As Pointer, __n As Long) As Long Exec "write"

' int close(int _fd)
' Deallocates the file descriptor indicated by fildes.
Private Extern close_C(_fd As Integer) As Integer Exec "close"


Public Sub Main()

 Dim fd, i As Integer
 Dim l As Long

' Viene aperto in scrittura un file di testo:
 fd = open_C("/percorso/del/file", O_WRONLY)

' Asegna alla variabile "i" il vaore da scrivere nel file:
 i = 1000

' Scrive nel file, utilizzando il suo "file descriptor" come handle il valore contenuto nella variabile "i", avendo però l'accortezza di passare alla funzione esterna "write()" l'indirizzo di memoria di quella variabile:
 l = write_C(fd, VarPtr(i), SizeOf(TypeOf(i)))
 If l == -1 Then Error.Raise("Impossibile scrivere nel file !")

 close_C(fd)

End

Uso della funzione esterna "write()" con la funzione nativa "Open" di Gambas

Nell'esempio precedente abbiamo visto la funzione esterna "write()" scrivere un dato in un file aperto con la funzione esterna open()" di C.
Nel presente paragrafo vedremo sostituire la funzione esterna "open()" di C con la funzione nativa di Gambas "Open", per aprire in scrittura un file. Successivamente all'apertura del file bisognerà passare al primo argomento della funzione esterna "write()" di C il file descriptor del file aperto, utilizzando la Proprietà ".Handle" della variabile di tipo File relativa al file aperto con "Open" di Gambas.

Mostriamo un semplice esempio pratico:

Library "libc:6"
 
' ssize_t write (int __fd, const void *__buf, size_t __n)
' Write N bytes of BUF to FD.
Private Extern write_C(__fd As Integer, __buf As Pointer, __n As Long) As Long Exec "write"


Public Sub Main()

 Dim fl As File
 Dim p As Pointer
 Dim i As Integer
 Dim l As Long

 fl = Open "/percorso/del/file" For Write

' Asegna alla variabile "i" il vaore da scrivere nel file:
 i = 100
 p = VarPtr(i)

 l = write_C(fl.Handle, p, SizeOf(TypeOf(i)))
 If l == 0 Then Error.Raise("Impossibile scrivere nel file !")
 
 fl.Close

End

Usare la funzione "write() di C con la funzione "fopen()" di C

Mostriamo in questo paragrafo una particolarità: l'uso di due funzioni esterne per aprire e scrivere in un file non appartenenti alla stessa famiglia delle funzioni I/O. Nello specifico si utilizzerà la funzione esterna write( ) per scrivere in un file aperto con la funzione esterna "fopen()".

Per aprire in lettura e/o scrittura un file, si utilizzano in modo esclusivo le funzioni "open()", "read()" e "write()", oppure le funzioni "fopen()", "fread()" e "fwrite()". La funzione di apertura del file "open()" ritorna un valore di tipo Intero che è il file descriptor del file aperto e che rappresenta così l'handle per gestire la lettura e/o la scrittura del file medesimo. Se invece si utilizza per l'apertura del file la funzione "fopen()", questa ritorna un Puntatore al file aperto. Tale Puntatore sarà l'handle per gestire la lettura e/o la scrittura di quel file. Da ciò si può facilmente notare che il file potrà essere letto e/o scritto solo mediante le funzioni appartenenti alla medesima famiglia della funzione con la quale il file è stato aperto. Così, ad esempio, se si apre il file con la funzione "fopen()" non si potranno usare le funzioni "read()" e "write()".
Esiste, però, la possibilità di utilizzare la funzione "fopen()" congiuntamente ed in sinergia con le due funzioni di lettura e di scrittura, rispettivamente "read()" e "write()", che di norma - come abbiamo sopra detto - non sono utilizzabili con la funzione di apertura "fopen()". Sappiamo che la funzione "fopen()" restituisce un Puntatore ad una Struttura, il cui identificatore MACRO è "FILE ", ed è il "typedef " della Struttura _IO_FILE dichiarata nel file header "/usr/include/libio.h ".
Non tutti i membri di detta Struttura sono accessibili in un codice scritto inlinguaggio C, in quanto essa viene richiamata nel file header "stdio.h " con la MACRO "FILE " come un tipo "opaco ". Fa eccezione il membro chiamato "_fileno", e lì dichiarato come "int " (Intero), contenente il numero del descrittore del file aperto, al quale si riferisce. Essendo, dunque, tale membro accessibile, sarà possibile leggere il valore ivi contenuto, e che - come già detto - rappresenta il numero identificatore del file descriptor del file aperto con la funzione "fopen()". Tutto ciò permetterà di utilizzare le funzioni "read()" e "write()" anche su un file aperto con la funzione "fopen()".

Usando tali funzioni in Gambas, poiché nell'area di memoria riservata di detta Struttura il membro in questione, __fileno, è posto al byte di indice 112, si passerà il Puntatore, ritornato dalla funzione esterna "fopen()", al primo argomento della funzione "read()" e/o della funzione "write()", avendo cura di piazzare l'offset nell'area riservata all'indice 112.

Mostriamo un semplice esempio, di un file aperto in "scrittura" mediante la funzione "fopen()", nel quale si scriverà un valore Intero però - con gli accorgimenti sopra descritti - mediante la funzione "write()".

Library "libc:6"

' FILE *fopen (const char *__restrict __filename, const char *__restrict __modes)
' Open a file and create a new stream for it.
Private Extern fopen(__filename As String, __modes As String) As Pointer

' ssize_t write (int __fd, const void *__buf, size_t __n)
' Write N bytes of BUF to FD.
Private Extern write_C(__fd As Integer, __buf As Pointer, __n As Long) As Long Exec "write"

' int fclose (FILE *__stream)
' Close STREAM.
Private Extern fclose(__stream As Pointer) As Integer


Public Sub Main()

 Dim p1, p2 As Pointer
 Dim i As Integer

' Apriamo un file di testo in scrittura:
 p1 = fopen("/percorso/del/file", "w")

' Asegna alla variabile "i" il vaore da scrivere nel file:
 i = 100
 p2 = VarPtr(i)
 Print Int@(p2)
 
' Scrive nel file descriptor del file due volte il valore presente nella variabile "i" puntata dal Puntatore "p2":
 write_C(Int@(p1 + 112), p2, SizeOf(gb.Integer))
 write_C(Int@(p1 + 112), p2, SizeOf(gb.Integer))

' Chiude il file precedentemente aperto:
 fclose(p1)
 
End

Note

[1] Si è visto, però, che se nel corpo del codice la funzione esterna di C, avente un nome simile ad una funzione nativa di Gambas, viene utilizzata con il suo esatto nome, ossia con la lettera iniziale minuscola, essa funziona regolarmente, senza necessità quindi di usare un nome fittizio.

Riferimenti

• http://man7.org/linux/man-pages/man2/write.2.html
• https://linux.die.net/man/2/write
• https://www.gnu.org/software/libc/manual/html_node/I_002fO-Primitives.html