Le funzioni in questa categoria si suddividono in sei classi:

• funzioni per gestire pile;
• funzioni per gestire code;
• funzioni per gestire bitmap;
• funzioni per gestire vettori;
• funzioni per gestire insiemi;
• funzioni per gestire alberi AVL.

Funzioni per gestire pile

Le funzioni per gestire pile (stack) permettono di utilizzare code LIFO in maniera molto semplice; le funzioni di questa classe sono:

STACKCREATE([el1[, el2..]])

crea una nuova pila con gli elementi indicati; corrisponde ad uno STACKNEW() seguito da PUSH(el1), PUSH(el2), ecc.; ritorna lo handle della nuova pila

STACKNEW()

crea una nuova pila e restituisce il suo handle; è necessario invocare STACKFREE sul handle non appena la pila non è più necessaria

STACKFREE(pHandle)

libera la memoria associata alla pila pHandle; ritorna 0 se l'operazione ha avuto successo, -1 se l'handle è invalido

STACKDUP(pHandle)

ritorna lo handle di una nuova pila che è la copia esatta della pila di handle pHandle; ritorna -1 se pHandle è errato

STACKHEIGHT(pHandle)

ritorna il numero di elementi nella pila, -1 se l'handle è invalido

PUSH(pHandle, exp1[, exp2..])

salva nella pila pHandle gli elementi exp1, exp2..; ritorna 0 se tutto ok, -1 se l'handle è invalido

POP(pHandle)

ritorna l'espressione in cima alla pila pHandle e rimuove l'elemento; ritorna una stringa vuota se l'handle è invalido oppure se la pila è vuota

STACKTOP(pHandle, nOffset)

restituisce l'elemento in posizione nOffset dalla cima della pila, senza rimuoverlo; se nOffset è 0, è come un POP senza rimozione; ritorna una stringa vuota se l'handle è invalido oppure se nOffset è maggiore o uguale al numero di elementi nella pila

STACKDEL(pHandle, nOffset, nNumber)

elimina nNumber elementi a partire dalla posizione nOffset dalla cima della pila; ritorna il numero di elementi rimossi se l'operazione ha avuto successo, -1 altrimenti; se nOffset è 0 ed nNumber è 1, equivale ad un POP in cui si ignora il valore ritornato

STACKINS(pHandle, nOffset, exp1[, exp2..])

inserisce exp1, exp2.. a partire dalla posizione nOffset dalla cima della pila; ritorna 0 se l'operazione ha avuto successo, -1 altrimenti; se nOffset è uguale a 0, equivale ad un PUSH

Funzioni per gestire code

Le funzioni per gestire code (queue) permettono di utilizzare code FIFO in maniera molto semplice; le funzioni di questa categoria sono:

QUEUECREATE([el1[, el2..]])

crea una nuova coda con gli elementi indicati; corrisponde ad un QUEUENEW() seguito da ENQUEUE(el1), ENQUEUE(el2), ecc.; ritorna lo handle della nuova coda

QUEUENEW()

crea una nuova coda e restituisce il suo handle; è necessario invocare QUEUEFREE sull'handle non appena la coda non è più necessaria

QUEUEDUP(qHandle)

ritorna lo handle di una nuova coda che è la copia esatta della coda di handle qHandle; ritorna -1 se qHandle è errato

QUEUEFREE(qHandle)

libera la memoria associata alla coda qHandle; ritorna 0 se l'operazione ha avuto successo, -1 se l'handle è invalido

QUEUELEN(qHandle)

ritorna la lunghezza della coda specificata, -1 se l'handle è invalido

ENQUEUE(qHandle, exp1[, exp2..])

inserisce alla fine della coda qHandle gli elementi exp1, exp2..; ritorna 0 se tutto ok, -1 se l'handle è invalido

DEQUEUE(qHandle)

ritorna l'espressione all'inizio della coda qHandle e rimuove l'elemento dalla coda; ritorna una stringa vuota se l'handle è invalido oppure se la coda è vuota

QUEUETOP(qHandle, nOffset)

restituisce l'elemento in posizione nOffset dall'inizio della coda, senza rimuoverlo; se nOffset è 0, è come un DEQUEUE senza rimozione

QUEUEDEL(qHandle, nOffset, nNumber)

elimina nNumber elementi a partire dalla posizione nOffset dall'inizio della coda; ritorna il numero di elementi rimossi se l'operazione ha avuto successo, -1 altrimenti; se nOffset è 0 ed nNumber è 1, equivale ad un DEQUEUE in cui si ignora il valore ritornato

QUEUEINS(qHandle, nOffset, exp1[, exp2..])

inserisce gli elementi exp1, exp2.. a partire dalla posizione nOffset dall'inizio della coda; ritorna 0 se l'operazione ha avuto successo, -1 altrimenti; se nOffset è uguale a 0, equivale ad un ENQUEUE

OENQUEUE(qHandle, exp1[, exp2..])

inserisce all'inizio della coda qHandle gli elementi exp1, exp2..; ritorna 0 se tutto ok, -1 se l'handle è invalido

ODEQUEUE(qHandle)

ritorna l'espressione alla fine della coda qHandle e rimuove l'elemento dalla coda; ritorna una stringa vuota se l'handle è invalido oppure se la coda è vuota

OQUEUETOP(qHandle, nOffset)

restituisce l'elemento in posizione nOffset dalla fine della coda, senza rimuoverlo; se nOffset è 0, è come un ODEQUEUE senza rimozione

OQUEUEDEL(qHandle, nOffset, nNumber)

elimina nNumber elementi a partire dalla posizione nOffset dalla fine della coda; ritorna il numero di elementi rimossi se l'operazione ha avuto successo, -1 altrimenti; se nOffset è uguale a 0 ed nNumber è uguale a 1, equivale ad un ODEQUEUE in cui si ignora il valore ritornato

OQUEUEINS(qHandle, offset, exp1[, exp2..])

inserisce exp1, exp2.. a partire dalla posizione nOffset dalla fine della coda; ritorna 0 se l'operazione ha avuto successo, -1 altrimenti; se nOffset è uguale a 0, equivale ad un OENQUEUE

Funzioni per gestire mappe di bit

Le funzioni per gestire mappe di bit (bitmap) permettono di mantenere gli stati di verità corrispondenti a molti elementi, pur utilizzando una quantità limitata di memoria (1 byte per 8 elementi, primo elemento 0); le funzioni di questa categoria sono:

BITMAPNEW()

crea una nuova mappa di bit e restituisce il suo handle; inizialmente tutti gli elementi valgono 0 (== falso); è necessario invocare BITMAPFREE sull'handle non appena la mappa non è più necessaria

BITMAPDUP(bHandle)

ritorna lo handle di una nuova mappa di bit che è la copia esatta della mappa di bit di handle bHandle; ritorna -1 se bHandle è errato

BITMAPSET(bHandle, nNumber, nBit)

imposta lo stato dell'elemento nNumber (>= 0) della mappa di bit bHandle al valore nBit (0 o non-0); ritorna -1 se bHandle è errato o nNumber è negativo, 0 altrimenti

BITMAPRSET(bHandle, nOffset, nNumber, nBit)

imposta lo stato degli elementi nOffset, nOffset+1, .., nOffset+nNumber-1 (nOffset >= 0) della mappa di bit bHandle al valore nBit (0 o non-0); ritorna -1 se bHandle è errato o nOffset è negativo, 0 altrimenti

BITMAPGET(bHandle, nOffset)

restituisce lo stato logico dell'elemento nOffset (>= 0) nella bitmap bHandle; ritorna -1 se bHandle è errato o nOffset è negativo, 0 altrimenti

BITMAPPACK(bHandle)

compatta la bitmap, liberando la memoria riservata per gli elementi nulli finali; ritorna -1 se l'handle è errato, 0 altrimenti

BITMAPRESET(bHandle)

azzera la bitmap ma non libera l'handle; in questo modo, tutti gli elementi valgono 0, ma la bitmap può ancora essere riutilizzata; ritorna -1 se l'handle è errato, 0 altrimenti

BITMAPFREE(bHandle)

libera la bitmap corrispondente a bHandle; ritorna -1 se l'handle è errato, 0 altrimenti

BITMAPTOSTR(bHandle)

restituisce la stringa corrispondente alla bitmap; se bHandle è invalido, restituisce una stringa vuota

BITMAPFROMSTR(c)

restituisce l'handle di una nuova bitmap, costruita a partire dalla stringa c

TIFFPACK([@]c)

restituisce la stringa c compressa secondo TIFF 4.0

TIFFUNPACK([@]c)

decomprime la stringa c, compressa secondo TIFF 4.0

TIFFPACK e TIFFUNPACK possono essere utilizzate anche per qualsiasi altra stringa, sebbene questa compressione sia pensata soprattutto per questo tipo di utilizzo.

Funzioni per gestire i vettori

I vettori sono trattati in modo particolare in Proteus. Prima di tutto, i vettori possono essere solo monodimensionali. Inoltre, un vettore non è una variabile, ma una struttura alla quale si accede attraverso un handle. Il numero di elementi di un vettore è limitato superiormente dal massimo valore positivo di un intero lungo.

Un vettore si crea in memoria con la funzione VECNEW, alla quale viene passato il numero di elementi del vettore. Il parametro di VECNEW può essere un numero positivo o nullo (se negativo, il vettore non è creato e viene restituito -1). É possibile creare vettori senza elementi, in quanto con VECSIZE la dimensione può successivamente essere cambiata. Inizialmente, tutti gli elementi sono nulli ("" = 0 = 0.0). Per modificare il valore di un elemento si usa la funzione VECSET, mentre per ottenerne il valore si usa VECGET. Per cambiare la dimensione del vettore si utilizza la funzione VECSIZE (la dimensione può aumentare o diminuire), mentre con VECLEN si ottiene il numero attuale di elementi.

Gli indici degli elementi nei vettori vanno da 1 alla dimensione impostata con VECNEW o con l'ultima chiamata a VECSIZE. Per liberare la memoria allocata al vettore si utilizza VECFREE.

VECCREATE([exp[,exp..]])

crea in memoria un vettore contenente tutti gli elementi specificati; se nessun elemento viene indicato, il vettore creato è vuoto; restituisce l'handle del nuovo vettore

VECNEW(n)

crea in memoria un vettore di n elementi nulli; restituisce l'handle del vettore o -1 se n < 0

VECDUP(vHandle)

ritorna lo handle di un nuovo vettore che è la copia esatta del vettore di handle vHandle; ritorna -1 se vHandle è errato

VECSIZE(vHandle, nLength)

cambia ad nLength il numero di elementi del vettore vHandle; se nLength < 0 o vHandle non è un handle valido, ritorna -1, altrimenti il nuovo numero di elementi

VECLEN(vHandle)

ritorna il numero di elementi del vettore vHandle, oppure -1 se vHandle non è un handle valido

VECFREE(vHandle)

libera il vettore vHandle; ritorna 0 se l'operazione ha avuto successo, -1 se vHandle non è un handle valido

VECSET(vHandle, nOffset, exp)

imposta l'elemento nOffset (> 0) del vettore vHandle ad exp; ritorna -1 se vHandle non è un handle valido o nOffset è fuori intervallo, altrimenti 0

VECGET(vHandle, nOffset)

ritorna l'elemento nOffset (> 0) del vettore vHandle, un valore nullo se vHandle non è un handle valido o nOffset è fuori intervallo

VECDEL(vHandle, nOffset, nNumber)

elimina dal vettore vHandle nNumber elementi a partire da nOffset (incluso)

VECINS(vHandle, nOffset, nNumber)

inserisce nel vettore vHandle nNumber elementi a partire dall'elemento nOffset (incluso)

VECLAST(vHandle)

ritorna l'ultimo elemento del vettore vHandle; equivale a VECGET(h, VECLEN(h))

VECSHRINK(vHandle)

diminuisce di uno la dimensione del vettore vHandle; equivale a VECSIZE(h, DEC(VECLEN(h)))

VECAPPEND(vHandle, exp1[, exp2..])

corrisponde all'opportuna espansione del vettore vHandle e alla successiva impostazione dei nuovi elementi con i valori exp1, exp2..

VECJOIN(vHandle, cSeparator)

ritorna una stringa costituita dagli elementi nel vettore vHandle separati dal primo carattere di cSeparator, una stringa vuota se vHandle è errato

VECSPLIT(c, cSeparators)

crea un vettore contenente le stringhe in c separate da caratteri in cSeparators; restituisce l'handle del nuovo vettore (che è vuoto solo se c o cSeparators sono vuote).
ATTENZIONE! Al contrario delle funzioni di tokenizzazione, in questa funzione ogni separatore introduce un elemento (che può quindi essere anche vuoto).
Es. VECSPLIT("1,2,,4,5", ",") determina il vettore {[1] [2] [] [4] [5]}, con 5 elementi, mentre NUMTOKEN("1,2,,4,5", ",") = 4

VECREXSPLIT(c, xExp)

crea un vettore contenente le stringhe in c separate da caratteri che corrispondono all'espressione regolare estesa xExp; restituisce l'handle del nuovo vettore (che è vuoto solo se c è vuota). Valgono le stesse considerazioni esposte per VECSPLIT

VECREXISPLIT(c, xExp)

crea un vettore contenente le stringhe in c separate da caratteri che corrispondono all'espressione regolare estesa xExp (confronto insensibile alle maiuscole); restituisce l'handle del nuovo vettore (che è vuoto solo se c è vuota). Valgono le stesse considerazioni esposte per VECSPLIT

VECREXMATCH(c, xExp)

ritorna lo handle di un vettore contenente le sottostringhe di c che soddisfano l'espressione regolare estesa xExp

VECREXIMATCH(c, xExp)

ritorna lo handle di un vettore contenente le sottostringhe di c che soddisfano l'espressione regolare estesa xExp (confronto insensibile alle maiuscole)

VECTOSET(vHandle)

ritorna lo handle di un nuovo insieme creato dal vettore vHandle considerando gli elementi dispari come etichette e gli elementi pari come valori; ritorna -1 se vHandle è invalido

VECTOAVL(vHandle)

ritorna lo handle di un nuovo albero AVL creato dal vettore vHandle considerando gli elementi dispari come etichette e gli elementi pari come valori; ritorna -1 se vHandle è invalido

Sui vettori si possono effettuare ricerche ed ordinamenti veloci attraverso le seguenti funzioni:

SORT(vHandle, nSortType, nDirection)

ordina il vettore vHandle in base a nSortType ed nDirection (due interi); nSortType determina il tipo dell'ordinamento, in questo modo (vedi il file incluso common.prt):

Costante	Valore	Significato
SORT_STRING	0	stringa (sensibile alle maiuscole)
SORT_INTEGER	1	intero
SORT_FLOAT	2	virgola mobile
SORT_DATE	3	data
SORT_ISTRING	4	stringa (insensibile alle maiuscole)
	altro	come 0

nDirection determina la direzione di ordinamento:

Costante	Valore	Significato
SORT_DESCENDING	0	discendente
SORT_ASCENDING	1	ascendente

La funzione ritorna -1 se l'handle è invalido, 0 altrimenti

SCAN(vHandle, nSearchType, exp)

scandisce linearmente il vettore vHandle alla ricerca del valore exp utilizzando il confronto determinato in base ad nSearchType (vedi il file incluso common.prt):

Costante	Valore	Significato
SORT_STRING	0	stringa (sensibile alle maiuscole)
SORT_INTEGER	1	intero
SORT_FLOAT	2	virgola mobile
SORT_DATE	3	data
SORT_ISTRING	4	stringa (insensibile alle maiuscole)
SORT_MATCH	5	stringa (MATCH)
SORT_IMATCH	6	stringa (IMATCH)
SORT_REXMATCH	7	stringa (REXMATCH)
SORT_REXIMATCH	8	stringa (REXIMATCH)
	altro	come 0

ritorna -1 se l'handle è invalido, 0 se l'espressione non è stata trovata, la posizione dell'elemento nel vettore altrimenti

BSEARCH(vHandle, nSearchType, exp)

effettua una ricerca binaria sul vettore vHandle, assumendo che questo sia ordinato; la tipologia di confronto è stabilita da nSearchType, per il quale valgono gli stessi valori utilizzati dalla funzione SCAN ad eccezione di 5..8 (MATCH, IMATCH, REXMATCH e REXIMATCH non stabiliscono un ordinamento relativo):

Costante	Valore	Significato
SORT_STRING	0	stringa (sensibile alle maiuscole)
SORT_INTEGER	1	intero
SORT_FLOAT	2	virgola mobile
SORT_DATE	3	data
SORT_ISTRING	4	stringa (insensibile alle maiuscole)

Ritorna -1 se l'handle è invalido, 0 se l'espressione non è stata trovata, la posizione dell'elemento nel vettore altrimenti

SORTUDF(vHandle, FUNC)

ordina il vettore vHandle utilizzando la funzione UDF FUNC; questa funzione deve prendere due parametri, corrispondenti ai due elementi da confrontare, e deve ritornare:

• 0 gli elementi sono uguali per l'ordinamento
• <0 l'elemento 1 precede l'elemento 2 nell'ordinamento
• >0 l'elemento 2 precede l'elemento 1 nell'ordinamento

SCANUDF(vHandle, exp, FUNC)

scansione lineare di vHandle alla ricerca di exp attraverso la UDF FUNC; FUNC prende due parametri e ritorna 0 se e solo se l'elemento del vettore valutato in quel momento coincide con il valore di exp; ritorna -1 se l'handle è invalido, 0 se l'espressione non è stata trovata, la posizione dell'elemento nel vettore altrimenti

BSEARCHUDF(vHandle, exp, FUNC)

effettua una ricerca binaria di exp sul vettore vHandle, assumendo che questo sia ordinato in modo ascendente in base all'ordinamento determinato dall'UDF FUNC; questa funzione deve prendere due parametri, corrispondenti ai due elementi da confrontare, e deve ritornare:

• 0 gli elementi sono uguali per l'ordinamento
• <0 l'elemento 1 precede l'elemento 2 nell'ordinamento
• >0 l'elemento 2 precede l'elemento 1 nell'ordinamento

Ritorna -1 se l'handle è invalido, 0 se l'espressione non è stata trovata, la posizione dell'elemento nel vettore altrimenti

Tutte le funzioni con UDF (SORTUDF, SCANUDF, BSEARCHUDF) richiedono come parametro FUNC un nome di funzione, senza parentesi o parametri; questo nome non può essere contenuto in una stringa, ma deve essere specificato in modo letterale. La funzione deve essere successivamente (o precedentemente) definita, con due parametri.

Funzioni per gestire insiemi

Le funzioni per gestire insiemi (set) permettono di inserire e ritrovare elementi attraverso l'impiego di una chiave, che può essere una stringa, un numero intero o in virgola mobile. La nozione di insieme in Proteus è assimilabile a quella di vettore associativo in Perl™. Le funzioni di questa classe sono:

SETNEW()

crea un nuovo insieme vuoto di valori; ritorna lo handle dell'insieme

SETCREATE([lab,exp[lab2,exp2..]])

crea un nuovo insieme con gli elementi indicati; se vengono passati un numero dispari di parametri, l'ultimo elemento ha un valore nullo associato; ritorna lo handle del nuovo insieme

SETDUP(sHandle)

ritorna lo handle di un nuovo insieme che è la copia esatta dell'insieme corrispondente ad sHandle; ritorna -1 se sHandle è errato

SETFREE(sHandle)

libera la memoria associata all'insieme corrispondente ad sHandle; ritorna 0 in caso di successo, -1 in caso di errore

SETSET(sHandle, key, value)

aggiunge all'insieme di handle sHandle la coppia (key, value); ritorna -1 se sHandle è invalido, 0 altrimenti; se esisteva già un elemento associato a key nell'insieme, aggiorna il valore con value

SETGET(sHandle, key)

ritorna il valore associato a key nell'insieme sHandle, una stringa vuota in caso di errore

SETBELONG(sHandle, key)

ritorna 1 se key appartiene all'insieme sHandle, 0 se non appartiene, -1 se sHandle è errato

SETDEL(sHandle, key)

rimuove l'elemento associato a key nell'insieme corrispondente ad sHandle; ritorna 1 se l'elemento è stato rimosso con successo, 0 se l'elemento non è stato trovato, -1 se sHandle è errato

SETLENGTH(sHandle)

ritorna il numero di elementi nell'insieme sHandle (-1 in caso di errore)

SETFIRST(sHandle)

posiziona il puntatore al primo elemento dell'insieme; ritorna 0 se non c'è nessun elemento, -1 se sHandle è errato, un valore maggiore di 0 altrimenti; il primo elemento non coincide necessariamente con il primo elemento introdotto

SETNEXT(sHandle)

sposta il puntatore al successivo elemento dell'insieme; si utilizza con SETCURKEY e SETCURVAL. Gli elementi restituiti non sono nell'ordine di introduzione. Le funzioni SETDUP, SETFREE, SETSET, SETGET, SETBELONG, SETDEL, SETFIRST, SETVALUES, SETTOVEC possono cambiare la posizione corrente; ritorna 0 se si è verificato un wrap (siamo tornati all'inizio dell'insieme), -1 se sHandle è errato, un numero diverso da 0 altrimenti

SETCURKEY(sHandle)

ritorna la chiave dell'elemento corrente nell'insieme specificato, una stringa vuota se sHandle è errato oppure se l'insieme è vuoto

SETCURVAL(sHandle)

ritorna il valore associato all'elemento corrente nell'insieme specificato, una stringa vuota se sHandle è errato oppure se l'insieme è vuoto

SETKEYS(sHandle)

ritorna lo handle di un vettore contenente tutte le chiavi nell'insieme corrispondente ad sHandle; ritorna -1 se sHandle non è valido

SETVALUES(sHandle)

ritorna lo handle di un vettore contenente tutte le chiavi nell'insieme corrispondente ad sHandle; ritorna -1 se sHandle non è valido

SETTOVEC(sHandle)

ritorna lo handle di un vettore creato dall'insieme corrispondente ad sHandle, -1 se sHandle è invalido; il vettore creato ha le etichette come elementi dispari, i valori come elementi pari

Per scandire sequenzialmente tutti gli elementi in un insieme si può utilizzare il seguente codice:

; S è lo handle di un insieme
IF SETFIRST(S)
  REPEAT
    CONSOLELN "(" SETCURKEY(S) ", " SETCURVAL(S) ")"
  UNTIL NOT(SETNEXT(S))
FI

Funzioni per gestire alberi AVL

Le funzioni per gestire alberi AVL permettono di inserire e ritrovare elementi in modo rapido attraverso l'impiego di una chiave, che può essere una stringa, un numero intero o in virgola mobile. Un albero AVL è un albero binario bilanciato, in cui le altezze dei sottoalberi sinistro e destro di ogni nodo possono al più differire di uno; gli alberi AVL sono così chiamati dai nomi dei loro ideatori, Adelson, Velskii e Landis. La particolarità di queste strutture dati è che il più lungo cammino dalla radice a ciascun nodo è al più 2 log n, cioé la verifica dell'appartenenza, l'inserzione e la rimozione di un elemento hanno complessità O(log n), dove n è il numero di elementi nell'albero. Gli alberi AVL permettono ricerche e sostituzioni molto rapide, ma hanno un costo più alto rispetto agli insiemi hash per inserimento e cancellazione (qualora ciò comporti un ribilanciamento dell'albero); sono preferibili se l'applicazione effettua molte più ricerche/sostituzioni rispetto ad inserimenti/cancellazioni. Gli alberi AVL permettono, inoltre, di ottenere immediatamente la lista ordinata per chiave degli elementi introdotti (attraversamento in-ordine). Per ulteriori informazioni su questo tipo di struttura dati si vedano i testi di Wirth e altri.
Gli alberi AVL sono estremamente utili, potenti e facili da utilizzare: permettono con poco sforzo di ordinare elementi ed effettuare ricerche rapide.

Le funzioni di questa classe sono:

AVLNEW()

crea un albero vuoto e restituisce il suo handle

AVLCREATE([lab,exp[lab2,exp2..]])

ritorna lo handle di un nuovo albero AVL contenente gli elementi indicati; se il loro numero è dispari, l'ultimo elemento avrà una stringa nulla (= 0 = 0.0) come informazione

AVLDUP(aHandle)

crea una copia dell'albero indicato; ritorna un nuovo handle, o -1 se aHandle è errato

AVLFREE(aHandle)

rimuove il contenuto dell'albero e libera lo handle; ritorna 0 in caso di successo, -1 se lo handle è errato

AVLSET(aHandle, lab, exp)

inserisce un elemento nell'albero; ritorna -1 se aHandle è invalido, 0 se l'elemento è stato inserito, 1 se è stato aggiornato

AVLGET(aHandle, lab)

ritorna il valore associato a lab nell'albero aHandle, una stringa vuota (= 0 = 0.0) in caso di errore (aHandle invalido o elemento non trovato)

AVLBELONG(aHandle, lab)

determina se l'elemento appartiene (1) o meno (0) all'albero; ritorna -1 se aHandle è errato

AVLDEL(aHandle, lab)

cancella un elemento dall'albero; ritorna -1 se aHandle è invalido, 0 se l'elemento non è stato trovato, 1 se è stato rimosso

AVLLENGTH(aHandle)

ritorna il numero di elementi nell'albero, o -1 se aHandle è errato

AVLKEYS(aHandle)

ritorna lo handle di un nuovo vettore contenente le chiavi degli elementi nell'albero; ritorna -1 se aHandle è errato

AVLVALUES(aHandle)

ritorna lo handle di un nuovo vettore contenente i valori degli elementi nell'albero; ritorna -1 se aHandle è errato

AVLTOVEC(aHandle)

ritorna lo handle di un vettore creato dall'albero corrispondente ad aHandle, -1 se aHandle è invalido; il vettore creato ha le etichette come elementi dispari, i valori come elementi pari

AVLTRAVERSE(aHandle, udffunction)

questa funzione permette di attraversare tutto l'albero aHandle, richiamando udffunction sulla coppia (etichetta, informazione) di ciascun elemento nell'albero; la UDF deve accettare due soli parametri (etichetta, informazione) e ritornare 0 (continua con il prossimo elemento) oppure 1 (termina l'attraversamento dell'albero); AVLTRAVERSE ritorna -1 se aHandle è invalido, 0 se è stato attraversato tutto l'albero, 1 se la UDF ha richiesto la terminazione anticipata. Con questa funzione, si ottengono i dati introdotti ordinati in modo crescente (attraversamento in pre-ordine); vedi anche AVLRTRAVERSE

AVLRTRAVERSE(aHandle, udffunction)

questa funzione permette di attraversare tutto l'albero aHandle, richiamando udffunction sulla coppia (etichetta, informazione) di ciascun elemento nell'albero; la UDF deve accettare due soli parametri (etichetta, informazione) e ritornare 0 (continua con il prossimo elemento) oppure 1 (termina l'attraversamento dell'albero); AVLRTRAVERSE ritorna -1 se aHandle è invalido, 0 se è stato attraversato tutto l'albero, 1 se la UDF ha richiesto la terminazione anticipata. Con questa funzione, si ottengono i dati introdotti ordinati in modo decrescente (attraversamento in post-ordine); vedi anche AVLTRAVERSE