La lettura (implicita) delle righe dal file in input e la scrittura (con PRINT e PRINTLN) del file di output possono non essere sufficienti per risolvere alcuni problemi particolari.
Le funzioni di questa categoria permettono di operare con altri file, binari o di testo, in maniera non dissimile da quanto avviene negli altri linguaggi di programmazione, vale a dire eseguendo un'operazione di apertura, che restituisce un handle, ed utilizzando tale handle per gestire le altre operazioni sul medesimo file.
In questa stessa sezione sono contenute, inoltre, le funzioni per leggere e operare sull'ingresso standard.
Il separatore richiesto per le directory nei nomi di file dipende dalla versione dell'interprete in uso; tuttavia, utilizzando il parametro sulla linea di comando -k è possibile convertire automaticamente i nomi di file, senza mettere mano (almeno per questo aspetto) al codice sorgente del programma.

Le funzioni sono qui presentate suddivise in classi:

• funzioni con handle;
• funzioni sull'ingresso standard;
• funzioni senza handle;
• funzioni per file dizionario;
• funzioni sulle directory.

Le funzioni con handle sono:

FOPEN(cPathName, nMode)

apre il file cPathName in modalità nMode e restituisce l'handle; ritorna -1 in caso di errore; cPathName può includere un percorso; nMode è ottenuto mediante OR binario dei seguenti valori (vedi il file incluso common.prt):
 

Costante	Valore	Significato
FO_READ	1	apre per sola lettura
FO_WRITE	2	apre per sola scrittura
FO_RDWR	4	apre per lettura/scrittura
FO_CREATE	8	crea il file se non esiste
FO_TRUNC	16	tronca il file se esiste

FSEEK(h, nOffset, nFromWhere)

posiziona il puntatore del file corrispondente all'handle h alla posizione nOffset da nFromWhere; ritorna l'offset dall'inizio del file del puntatore (in caso di successo) o -1 (handle errato); i valori ammessi per nFromWhere sono (vedi il file incluso common.prt):
 

Costante	Valore	Significato
SEEK_SET	0	dall'inizio
SEEK_CUR	1	dalla posizione corrente
SEEK_END	2 (o altro)	dalla fine

FREAD(h, nBytes)

ritorna la stringa di nBytes letta dalla posizione corrente del file h; se vi sono meno di nBytes residui, restituisce una stringa più corta di nBytes; se l'handle è invalido o siamo a fine file, ritorna una stringa vuota

FCLOSE(h)

chiude il file corrispondente all'handle h e libera il suo handle; ritorna 0 in caso di successo, -1 altrimenti

FEOF(h)

ritorna 1 se il puntatore sul file di handle h è alla fine del file, 0 altrimenti; se l'handle è invalido, ritorna -1

FGETC(h)

legge e ritorna un singolo carattere dal file di handle h; equivalente a FREAD(h, 1)

FWRITE(h, exp)

scrive il valore stringa di exp alla posizione corrente sul file h; ritorna il numero di caratteri scritti o -1 in caso di errore

FWRITELN(h, exp)

scrive il valore stringa di exp, seguito dal valore di EOL, alla posizione corrente sul file h; ritorna il numero di caratteri scritti o -1 in caso di errore

FSIZE(h)

ritorna la dimensione del file di handle h, -1 se l'handle è invalido

FRESIZE(h, nBytes)

ridimensiona il file h alla dimensione nBytes specificata (maggiore o minore della dimensione attuale);
ritorna la dimensione precedente, -1 in caso di errore

FREADLN(h)

legge fino al terminatore di riga e ritorna il contenuto della riga (tranne il terminatore); funziona con file Dos, Macintosh™ e Unix™. Al termine, il puntatore sul file si trova posizionato alla prossima riga. Presume che alla chiamata il puntatore sul file si trovi all'inizio di una riga. Se l'handle è errato (o il puntatore è a fine file) ritorna una stringa vuota.

Le funzioni sull'ingresso standard sono:

STDEOF()

ritorna 1 se siamo alla fine dello standard input, 0 altrimenti

STDGETCH()

ritorna una stringa con il successivo carattere dallo standard input, una stringa vuota a fine file; equivalente a STDREAD(1)

STDUNGETCH(c)

re-inserisce il carattere c nello standard input; ritorna il suo codice ASCII se la funzione ha successo, -1 altrimenti

STDREAD(nBytes)

legge dall'ingresso standard e ritorna una stringa di lunghezza nBytes o inferiore (se fine file)

STDREADLN()

legge dall'ingresso standard e ritorna una stringa con la riga letta; ritorna una stringa vuota se si è a fine file

Le funzioni senza handle sono:

TRUENAME([@]cPathName)

ritorna il vero nome di cPathName, sostituendo eventuali '.' e '..'; sotto Windows™, trasforma i nomi corti nei corrispondenti nomi lunghi; ritorna una stringa vuota se cPathName non ha potuto essere risolto.
N.B. Questa funzione non serve per verificare l'esistenza di un file/directory (si utilizzi ISFILE per questo scopo); infatti, essa ritorna un nome qualificato anche per i file inesistenti, purché esista la directory che precede l'ultimo nome

LONGNAME([@]cPathName)

ritorna il nome lungo di cPathName, o una stringa vuota in caso di errore; questa funzione è caratteristica della versione di Proteus per Ms-Dos™/Windows™

SHORTNAME([@]cPathName)

ritorna il nome corto di cPathName, o una stringa vuota in caso di errore; questa funzione è caratteristica della versione di Proteus per Ms-Dos™/Windows™

FREMOVE(cPathName)

cancella il file cPathName; restituisce 0 se l'operazione ha avuto successo, -1 altrimenti

FRESET(cPathName)

azzera il file cPathName (ma non lo rimuove); ritorna la lunghezza precedente all'azzeramento oppure -1 (file non trovato/errore)

FINSERT(cPathName)

trascrive il file di testo cPathName nel file di output e restituisce il numero di righe ricopiate; le righe sono terminate con EOL

FAPPEND(cPathName, c)

scrive c alla fine del file cPathName e restituisce il numero di caratteri scritti (-1 in caso di errore); FAPPEND non aggiunge terminatori di riga - concatenare EOL opportunamente se si lavora con file di testo

FSAVE(cPathName, c)

scrive c su cPathName, creandolo oppure troncandolo (se esiste); ritorna il numero di bytes scritti (di norma, la lunghezza di c) o -1 in caso di errore

FLOAD(cPathName)

ritorna il contenuto di cPathName come un'unica stringa; nessuna conversione è fatta sul contenuto; ritorna una stringa vuota in caso di errore

FRENAME(cOldPathName, cNewPathName)

rinomina cOldPathName in cNewPathName; può essere utilizzato anche per spostare un file da una directory all'altra (sullo stesso disco, sotto Ms-Dos™/Windows™); ritorna -1 in caso di errore, 0 altrimenti

FCOPY(cSourcePathName, cDestPathName)

copia il file cSourcePathName nel file cDestPathName; ritorna -1 in caso di errore, 0 altrimenti

DRIVEGET()

ritorna il drive corrente, nella forma "A:"; questa funzione è caratteristica della versione di Proteus per Ms-Dos™/Windows™

DIRGET(cDrive)

ritorna la directory corrente su cDrive (nel formato "A" o "A:"); su Unix™, la funzione non ha alcun parametro: DIRGET(). In caso di errore ritorna una stringa vuota; se tutto ok, viene ritornata la directory (che comprende il drive sotto Dos/Windows™)

DIRSET(cPath)

cambia alla directory cPath; sotto Dos/Windows™, cambia anche al drive indicato; ritorna 0 se ok, -1 in caso di errore

DIRMAKE(cPath)

crea la directory cPath; ritorna 0 se tutto ok, -1 in caso di errore

DIRREMOVE(cPath)

rimuove la directory cPath; ritorna 0 se tutto ok, -1 in caso di errore

ISFILE(cPathName)

verifica se il file o la directory cPathName indicata esiste; ritorna (vedi il file incluso common.prt):
 

Costante	Valore	Significato
ISFILE_ERR	0	non esiste o cPathName è errato
ISFILE_FILE	1	esiste come file
ISFILE_DIR	2	esiste come directory
ISFILE_LINK	3	esiste come link simbolico (solo versione Unix™)

Non sono ammesse wildcard ('*' o '?') in pathname

TEMPNAME()

restituisce un nome di file temporaneo

MKTEMP([@]cMask)

restituisce un nome di file univoco determinato dalla stringa cMask, che deve essere un percorso corretto che termina con 6 caratteri X; es. "C:\TEMP\XXXXXX"

FATTRIB(cPathName)

ritorna gli attributi del file corrispondente a cPathName (può essere anche una directory o un link simbolico), -1 in caso di errore; questa funzione ritorna valori diversi a seconda della versione di Proteus.
Sotto Ms-Dos™/Windows™ il valore ritornato è rappresentato dall'OR binario dei seguenti numeri (vedi il file incluso common.prt):
 

Costante	Valore	Significato
ATTR_RDONLY	1	sola lettura
ATTR_HIDDEN	2	nascosto
ATTR_SYSTEM	4	file di sistema
ATTR_DIRECTORY	16	directory
ATTR_ARCHIVE	32	archivio

Sotto Unix™, il risultato è composto dall'OR dei seguenti valori:
 

Costante	Valore	Significato
ATTR_USREXE	1	eseguibile (utente)
ATTR_USRWRITE	2	scrivibile (utente)
ATTR_USRREAD	4	leggibile (utente)
ATTR_DIRECTORY	8	directory
ATTR_LINK	16	link simbolico
ATTR_GRPEXE	32	eseguibile (gruppo)
ATTR_GRPWRITE	64	scrivibile (gruppo)
ATTR_GRPREAD	128	leggibile (gruppo)
ATTR_OTHEXE	256	eseguibile (altri)
ATTR_OTHWRITE	512	scrivibile (altri)
ATTR_OTHREAD	1024	leggibile (altri)

CHMOD(cPathName, nFlags)

imposta gli attributi di cPathName in base a nFlags: ritorna 0 in caso di successo, -1 se si è verificato un errore; sotto Unix™, nFlags è una stringa di tre numeri ottali, da "000" a "777", rappresentanti i diritti di accesso al file per il proprietario, il gruppo e gli altri, rispettivamente; ogni cifra è composta sommando i seguenti valori (vedi il file incluso common.prt):
  

Costante	Valore	Significato
RIGHT_EXE	1	per il diritto di esecuzione
RIGHT_WRITE	2	per il diritto di scrittura
RIGHT_READ	4	per il diritto di lettura

Sotto Dos/Windows™, nFlags è un numero ottenuto mediante OR binario dei seguenti valori:
 

Costante	Valore	Significato
ATTR_RDONLY	1	sola lettura
ATTR_HIDDEN	2	nascosto
ATTR_SYSTEM	4	file di sistema
ATTR_ARCHIVE	32	archivio

LINK(cPathName, cLinkPath)

crea un link simbolico da cPathname in cLinkPath; questa funzione è caratteristica della versione Unix™ di Proteus

UMASK(cNewMask)

imposta la umask per il processo al valore che le viene passato, rappresentato da una stringa di tre cifre ottali (da "000" a "777"); ritorna il valore precedente, sotto forma di una stringa di tre cifre ottali, nel medesimo formato. Per ulteriori informazioni, si veda l'identificatore FILE_MASK; questa funzione è caratteristica della versione Unix™ di Proteus

Le funzioni per file dizionario sono:

Un file dizionario è un file di testo in cui ogni riga ha la forma:

label1:stringa1
label2:stringa2
.. 

cioè ogni riga inizia con un etichetta identificativa seguita da ':' e quindi da una quantità variabile di dati (fino a fine riga).
I file dizionario sono comodi per memorizzarvi informazioni di configurazione e piccole basi di dati. Poiché non viene mantenuto alcun indice e quindi la procedura di ricerca è sequenziale, maggiore è la quantità di dati memorizzati e maggiore sarà il tempo di risposta del sistema. La label identificativa non deve superare gli 80 caratteri.

DICLOOKUP(cLabel, cPathDictionary)

ritorna la stringa associata a cLabel nel file cPathDictionary; se l'etichetta cLabel non è presente oppure il file cPathDictionary non esiste, ritorna una stringa vuota

DICUPDATE(cLabel, exp, cPathDictionary)

aggiorna la stringa associata a cLabel nel file cPathDictionary con il contenuto di exp (interpretato come stringa); se il file non esiste, viene creato; la voce è rimossa dal dizionario qualora exp sia una stringa vuota; ritorna (vedi il file incluso common.prt):
 

Costante	Valore	Significato
DIC_ERROR	0	errore
DIC_ADDED	1	id aggiunto
DIC_MODIFIED	2	id modificato
DIC_REMOVED	3	id rimosso

La stringa exp non può contenere i caratteri '\r' o '\n'; si utilizzino le funzioni CINVTRAN e CTRAN come filtro, per memorizzare stringhe sull'intero set ASCII

DICTRAVERSE(cPathDictionary, udffunction)

questa funzione permette di scandire il file cPathDictionary, invocando udffunction per ogni voce incontrata; la UDF deve accettare due soli parametri (label, dati associati) e ritorna 0 (continua con il prossimo elemento) oppure 1 (termina l'attraversamento del dizionario); DICTRAVERSE ritorna -1 se il file dizionario non esiste, 0 se è stato attraversato completamente, 1 se la UDF ha richiesto la terminazione anticipata

DICTOAVL(cPathDictionary)

crea un albero AVL e, attraversando il dizionario cPathDictionary, aggiunge ogni elemento trovato all'albero; ritorna:

• -2 file dizionario non trovato
• -1 file dizionario vuoto
• aHandle (handle dell'albero Avl creato)

DICFROMAVL(cPathDictionary, aHandle)

scrive sul file cPathDictionary il contenuto dell'albero AVL corrispondente ad aHandle, mediante un attraversamento in-ordine; se il file esiste, viene sovrascritto. Ritorna:

• -1 handle errato
• 0 impossibile creare il file dizionario/errore di scrittura
• 1 operazione completata con successo

Il terminatore di riga utilizzato corrisponde ad EOL. Tutte le label di lunghezza superiore a 80 caratteri sono troncate

DICMATCH2AVL(cPathDictionary, rExp)

crea un albero AVL contenente tutte le voci di cPathDictionary la cui label soddisfa l'espressione regolare semplice rExp; il confronto è sensibile alle maiuscole. Ritorna:

• -2 file non trovato
• -1 nessuna voce del dizionario soddisfa l'espressione
• aHandle (handle dell'albero AVL creato).

DICIMATCH2AVL(cPathDictionary, rExp)

crea un albero AVL contenente tutte le voci di cPathDictionary la cui label soddisfa l'espressione regolare semplice rExp; il confronto è insensibile alle maiuscole. Ritorna:

• -2 file non trovato
• -1 nessuna voce del dizionario soddisfa l'espressione
• aHandle (handle dell'albero AVL creato).

DICREXMATCH2AVL(cPathDictionary, xExp)

crea un albero AVL contenente tutte le voci di cPathDictionary la cui label soddisfa l'espressione regolare estesa xExp; il confronto è sensibile alle maiuscole. Ritorna:

• -3 espressione regolare estesa non corretta
• -2 file non trovato
• -1 nessuna voce del dizionario soddisfa l'espressione
• aHandle (handle dell'albero AVL creato).

DICREXIMATCH2AVL(cPathDictionary, xExp)

crea un albero AVL contenente tutte le voci di cPathDictionary la cui label soddisfa l'espressione regolare estesa xExp; il confronto è insensibile alle maiuscole. Ritorna:

• -3 espressione regolare estesa non corretta
• -2 file non trovato
• -1 nessuna voce del dizionario soddisfa l'espressione
• aHandle (handle dell'albero AVL creato).

Le funzioni sulle directory sono:

DIROPEN(cPathSpec, nFlags)

alloca una struttura di ricerca; ritorna l'handle di questa struttura, o -1 in caso di errore (cPathSpec errato o nessun file trovato); è necessario invocare DIRCLOSE sull'handle ottenuto non appena si sono concluse le operazioni di ricerca; flags è rappresentato dall'OR binario di uno o più dei seguenti valori (vedi il file incluso common.prt):
 

Costante	Valore	Significato
DO_FILE	1	include file
DO_DIRECTORY	2	include directory
DO_DOT	4	include la directory speciale "." (implica 2)
DO_DDOT	8	include la directory speciale ".." (implica 2)
DO_LINK	16	include links simbolici (solo versione Unix™, implica 1 e 2)

DIRNEXT(yHandle)

trova il successivo file che soddisfa la specifica; dopo una DIROPEN che ritorna un handle diverso da -1, un valore è già caricato ed accessibile con DIRLAST; DIRNEXT va usato solo dopo aver utilizzato questo valore; ritorna:

• 0 nessun altro file soddisfa la specifica;
• 1 trovato un altro file che soddisfa la specifica;
• -1 yHandle errato

DIRLAST(yHandle, nField)

ritorna il campo nField ottenuto con l'ultima chiamata a DIRNEXT o DIROPEN; se viene specificato un handle invalido o un campo invalido, ritorna una stringa vuota ("" = 0 = 0.0). Campi ammessi (vedi il file incluso common.prt):
 

Costante	Valore	Significato
DL_NAME	1	nome
DL_SIZE	2	dimensione (bytes)
DL_MDATE	3	data ultima modifica
DL_MTIME	4	ora ultima modifica
DL_ATTRIB	5	attributi (vedi FATTRIB)
DL_CDATE	6	data creazione
DL_CTIME	7	ora creazione
DL_ADATE	8	data ultimo accesso
DL_ATIME	9	ora ultimo accesso

I campi 6-9 sono accessibili solo sotto Windows™ (o Unix™). L'ora segue il formato di TIME_TYPE; i separatori utilizzati sono ':'; la data segue il formato di DATE_TYPE, con separatori '/' - in base ad EPOCH, cerca di impiegare il minor numero possibile di caratteri per rappresentare le date

DIRCLOSE(yHandle)

chiude l'handle di ricerca directory, liberando le informazioni mantenute per DIRLAST; da richiamare sempre quando l'elaborazione della directory è terminata; ritorna 0 se ok, -1 se l'handle è errato