gvpr - Online nel cloud

PROGRAMMA:

NOME

gvpr - linguaggio di scansione ed elaborazione di pattern grafici

SINOSSI

gvpr [-icnqV?] [ -o file di uscita ] [ -a args ] [ 'prog' | -f file di programma ] [ file ]

DESCRIZIONE

gvpr (Precedentemente conosciuto come gpr) è un editor di flussi grafici ispirato a awk. Copia l'input
grafici al suo output, eventualmente trasformandone la struttura e gli attributi, creandone di nuovi
grafici o la stampa di informazioni arbitrarie. Il modello grafico è quello fornito da
libcgraph(3). In particolare, gvpr legge e scrive grafici utilizzando il linguaggio dei punti.

Fondamentalmente, gvpr attraversa ogni grafico di input, indicato da $G, visitando ogni nodo e bordo,
abbinandolo alle regole predicato-azione fornite nel programma di input. Le regole sono
valutati in ordine. Per ogni predicato che valuta vero, l'azione corrispondente è
eseguita. Durante l'attraversamento, il nodo o l'arco attualmente visitato è indicato con $.

Per ogni grafico di input, c'è un sottografo di destinazione, indicato da $T, inizialmente vuoto e usato
per accumulare entità scelte e un grafico di output, $O, utilizzato per la lavorazione finale e poi
scritto in uscita. Per impostazione predefinita, il grafico di output è il grafico di destinazione. Il grafico in uscita
può essere impostato nel programma o, in senso limitato, sulla riga di comando.

VERSIONI

Sono supportate le seguenti opzioni:

-a args
La stringa args è suddiviso in token separati da spazi, con l'individuo
token disponibili come stringhe in gvpr programma come ARGV[0],...,ARGV[ARGC-1].
Caratteri di spazio bianco all'interno di sottostringhe con virgolette singole o doppie o preceduti da a
barra rovesciata, vengono ignorati come separatori. In generale, un carattere barra rovesciata si disattiva
qualsiasi significato speciale del carattere seguente. Nota che i token derivati ​​da
multiplo -a i flag sono concatenati.

-c Usa il grafico di origine come grafico di output.

-i Derivare l'estensione del sottografo indotta dal nodo del grafo di output nel contesto di
il suo grafico radice.

-o file di uscita
Fa sì che il flusso di output venga scritto nel file specificato; per impostazione predefinita, l'output è
scritto stdout.

-f file di programma
Usa il contenuto del file specificato come programma da eseguire sull'input. Se
file di programma contiene un carattere barra, il nome viene preso come percorso del file.
Altrimenti, gvpr utilizzerà le directory specificate nella variabile d'ambiente
GVPRPATH per cercare il file. Se -f non è dato, gvpr utilizzerà il primo non
argomento opzione come programma.

-q Disattiva i messaggi di avviso.

-n Disattiva la lettura anticipata del grafico. Per impostazione predefinita, la variabile $NG è impostato sul grafico successivo
essere processato. Ciò richiede una lettura del grafico successivo prima di elaborare il
grafico corrente, che potrebbe bloccarsi se il grafico successivo viene generato solo in risposta a
alcune azioni relative all'elaborazione del grafico corrente.

-V Fa in modo che il programma stampi le informazioni sulla versione e esca.

-? Fa in modo che il programma stampi le informazioni sull'utilizzo e esca.

OPERANDI

È supportato il seguente operando:

file Nomi di file contenenti 1 o più grafici nella lingua dei punti. se no -f opzione
viene fornito, il nome viene rimosso dall'elenco e utilizzato come programma di input.
Se l'elenco dei file è vuoto, stdin verrà utilizzato.

PROGRAMMI

A gvpr programma consiste in un elenco di clausole predicato-azione, aventi una delle forme:

INIZIO { azione }

BEG_G { azione }

N [ predicato ] { azione }

E [ predicato ] { azione }

FINE_G { azione }

FINE { azione }

Un programma può contenere al massimo uno di ciascuno dei INIZIO, FINE_G ed FINE clausole. non ci può
essere un numero qualsiasi di BEG_G, N ed E affermazioni, la prima applicata ai grafici, la seconda a
nodi, il terzo ai bordi. Questi sono separati in blocchi, un blocco costituito da an
opzionale BEG_G dichiarazione e tutto N ed E dichiarazioni fino al prossimo BEG_G dichiarazione, se
qualunque. La semantica di primo livello di a gvpr i programmi sono:

Valuta il INIZIO clausola, se presente.
Per ogni grafico in ingresso G {
Per ogni blocco {
Impostato G come grafico corrente e oggetto corrente.
Valuta il BEG_G clausola, se presente.
Per ogni nodo e bordo in G {
Imposta il nodo o il bordo come oggetto corrente.
Valuta il N or E clausole, a seconda dei casi.
}
}
Impostato G come oggetto corrente.
Valuta il FINE_G clausola, se presente.
}
Valuta il FINE clausola, se presente.

Le azioni del INIZIO, BEG_G, FINE_G ed FINE le clausole vengono eseguite quando le clausole sono
valutato. Per N or E clausole, il predicato o l'azione possono essere omessi. Se ci
non è un predicato con un'azione, l'azione viene eseguita su ogni nodo o bordo, come
adeguata. Se non c'è azione e il predicato restituisce true, l'associato
nodo o bordo viene aggiunto al grafico di destinazione.

I blocchi vengono valutati nell'ordine in cui si verificano. All'interno di un blocco, il N clausole
(E clausole, rispettivamente) vengono valutate nell'ordine in cui si verificano. Nota, però,
che all'interno di un blocco, N or E le clausole possono essere interlacciate, a seconda dell'ordine di attraversamento.

I predicati e le azioni sono sequenze di affermazioni in dialetto C supportate da
espr(3) biblioteca. L'unica differenza tra predicati e azioni è che il primo
deve avere un tipo che può essere interpretato come vero o falso. Qui il solito C
si segue la convenzione, in cui un valore diverso da zero è considerato vero. Questo includerebbe
stringhe non vuote e riferimenti non vuoti a nodi, archi, ecc. Tuttavia, se una stringa può
essere convertito in un numero intero, viene utilizzato questo valore.

Oltre ai soliti tipi di base C (nulla, int, serbatoio, galleggiante, lungo, unsigned ed doppio),
gvpr fornisce stringa come sinonimo di carattere*e i tipi basati su grafi nodo_t, bordo_t,
grafico_t ed oggetto_t. oggetto_t il tipo può essere visto come un supertipo degli altri 3 concreti
tipi; il tipo di base corretto viene mantenuto dinamicamente. Oltre a questi tipi di base, il
solo le altre espressioni di tipo supportate sono array (associativi).

Le costanti seguono la sintassi C, ma le stringhe possono essere citate con entrambe "..." or '...'. gvpr
accetta commenti C++ e commenti di tipo cpp. Per quest'ultimo, se una riga inizia con
un carattere '#', il resto della riga viene ignorato.

Un'istruzione può essere una dichiarazione di una funzione, una variabile o un array o un eseguibile
dichiarazione. Per le dichiarazioni esiste un unico ambito. Le dichiarazioni di array hanno la forma:

Digitare schieramento [ type0 ]

where type0 è facoltativo. Se viene fornito, il parser imporrà che tutti gli array
i pedici hanno il tipo specificato. Se non viene fornito, si possono realizzare oggetti di ogni tipo
usati come pedici. Come in C, le variabili e gli array devono essere dichiarati. In particolare, an
la variabile non dichiarata verrà interpretata come il nome di un attributo di un nodo, bordo o
grafico, a seconda del contesto.

Le istruzioni eseguibili possono essere una delle seguenti:

{ [ dichiarazione ... ] }
espressione // comunemente var = espressione
se ( espressione ) dichiarazione [ altro dichiarazione ]
per ( espressione ; espressione ; espressione ) dichiarazione
per ( schieramento [ var ]) dichiarazione
per ( schieramento [ var ]) dichiarazione
mentre( espressione ) dichiarazione
interruttore( espressione ) Custodie dichiarazioni
rompere [ espressione ]
continua [ espressione ]
ritorno [ espressione ]
Le voci tra parentesi sono facoltative.

Nella seconda forma di per dichiarazione e il per forza affermazione, la variabile var è impostato su
ogni valore utilizzato come indice nell'array specificato e quindi l'associato dichiarazione is
valutato. Per gli indici numerici e di stringa, gli indici vengono restituiti in aumento
(decrescente) ordine numerico o lessicografico per per (per forza, rispettivamente). Questo può essere usato
per l'ordinamento.

Le definizioni delle funzioni possono apparire solo nel INIZIO clausola.

Le espressioni includono le solite espressioni C. Confronti di stringhe usando == ed != trattare il
operando di destra come modello ai fini della corrispondenza delle espressioni regolari. Modelli
uso ksh(1) sintassi del modello di corrispondenza file. (Per una semplice uguaglianza delle stringhe, usa il strcmp
funzione.

gvpr tenterà di utilizzare un'espressione come stringa o valore numerico a seconda dei casi. Entrambi
I cast di tipo C e i modelli di funzione causeranno l'esecuzione delle conversioni, se possibile.

Espressioni di tipo grafico (es. grafico_t, nodo_t, bordo_t, oggetto_t) può essere seguito da a
riferimento di campo sotto forma di .Nome. Il valore risultante è il valore dell'attributo
detto Nome dell'oggetto dato. Inoltre, in alcuni contesti un non dichiarato,
l'identificatore non modificato è considerato un nome di attributo. In particolare, tali identificatori
denotano gli attributi del nodo o dell'arco corrente, rispettivamente, in N ed E clausole, e il
grafico corrente in BEG_G ed FINE_G clausole.

Come al solito in libcgraph(3) modello, gli attributi sono valutati come stringa. Inoltre, gvpr
supporta alcuni pseudo-attributi di oggetti grafici, non necessariamente con valori di stringa. Queste
riflettono le proprietà intrinseche degli oggetti grafici e non possono essere impostati dall'utente.

capo : nodo_t
la testa di un bordo.

coda : nodo_t
la coda di un bordo.

Nome : stringa
il nome di un bordo, nodo o grafico. Il nome di un bordo ha la forma "<coda‐
nome>[]", dove è "->" o "--" a seconda di
se il grafico è diretto o meno. La parte della staffa [] appare solo se il
edge ha una chiave non banale.

grado : int
il grado di un nodo.

fuori grado : int
il fuori grado di un nodo.

grado : int
il grado di un nodo.

radice : grafico_t
il grafico radice di un oggetto. La radice di un grafo radice è se stessa.

genitore : grafico_t
il grafo genitore di un sottografo. Il genitore di un grafo radice è NULL

n_bordi : int
il numero di archi nel grafico

n_nodi : int
il numero di nodi nel grafico

indirizzato : int
vero (diverso da zero) se il grafico è diretto

rigoroso : int
vero (diverso da zero) se il grafico è rigoroso

INCORPORATO FUNZIONI

Le seguenti funzioni sono integrate in gvpr. Quelle funzioni che restituiscono riferimenti al grafico
gli oggetti ritornano NULL in caso di guasto.

Grafici ed sottografo
grafico(s : stringa, t : stringa): grafico_t
crea un grafico il cui nome è s e il cui tipo è specificato dalla stringa t.
Ignorando le maiuscole, i personaggi U, D, S, N avere l'interpretazione non orientata,
rispettivamente diretto, rigoroso e non rigoroso. Se t è vuoto, diretto, non
viene generato un grafico rigoroso.

sogg(g : grafico_t, s : stringa): grafico_t
crea un sottografo nel grafico g con il nome s. Se il sottografo esiste già, è
restituito.

isSubg(g : grafico_t, s : stringa): grafico_t
restituisce il sottografo nel grafico g con il nome s, se esiste, o NULL altrimenti.

fstsubg(g : grafico_t): grafico_t
restituisce il primo sottografo nel grafico g, o NULL se non esiste.

nxtsubg(sg : grafico_t): grafico_t
restituisce il sottografo successivo dopo sg, o NULL.

isDirect(g : grafico_t): int
restituisce vero se e solo se g è diretto.

è Strict(g : grafico_t): int
restituisce vero se e solo se g è rigoroso.

nNodi(g : grafico_t): int
restituisce il numero di nodi in g.

nEdge(g : grafico_t): int
restituisce il numero di archi in g.

Nodes
nodo(sg : grafico_t, s : stringa): nodo_t
crea un nodo nel grafico g di nome s. Se tale nodo esiste già, viene restituito.

sottonodo(sg : grafico_t, n : nodo_t): nodo_t
inserisce il nodo n nel sottografo g. Restituisce il nodo.

fstnode(g : grafico_t): nodo_t
restituisce il primo nodo nel grafico g, o NULL se non esiste.

nxtnode(n : nodo_t): nodo_t
restituisce il nodo successivo dopo n nel grafico radice, o NULL.

nxtnode_sg(sg : grafico_t, n : nodo_t): nodo_t
restituisce il nodo successivo dopo n in sg, o NULL.

isNode(sg : grafico_t, s : stringa): nodo_t
cerca un nodo nel (sotto)grafo sg di nome s. Se tale nodo esiste, viene restituito.
Altrimenti, NULL viene restituito.

isSubnodo(sg : grafico_t, n : nodo_t): int
restituisce un valore diverso da zero se nodo n è nel (sotto)grafico sg, o zero altrimenti.

grado di(sg : grafico_t, n : nodo_t): int
restituisce il grado del nodo n in (sotto)grafico sg.

fuori grado(sg : grafico_t, n : nodo_t): int
restituisce il grado esterno del nodo n in (sotto)grafico sg.

grado di(sg : grafico_t, n : nodo_t): int
restituisce il grado del nodo n in (sotto)grafico sg.

bordi
bordo(t : nodo_t, h : nodo_t, s : stringa): bordo_t
crea un bordo con nodo di coda t, nodo di testa h e nome s nel grafico radice. Se la
grafico non è orientato, la distinzione tra nodi di testa e di coda non è importante.
Se tale bordo esiste già, viene restituito.

bordo_sg(sg : grafico_t, t : nodo_t, h : nodo_t, s : stringa): bordo_t
crea un bordo con nodo di coda t, nodo di testa h e nome s in (sotto)grafico sg (e tutto
grafici genitori). Se il grafico non è orientato, la distinzione tra testa e coda
i nodi non sono importanti. Se tale bordo esiste già, viene restituito.

sottobordo(g : grafico_t, e : bordo_t): bordo_t
inserisce il bordo e nel sottografo g. Restituisce il bordo.

isEdge(t : nodo_t, h : nodo_t, s : stringa): bordo_t
cerca un bordo con nodo di coda t, nodo di testa h e nome s. Se il grafico è
non orientato, la distinzione tra i nodi della testa e della coda non è importante. Se un tale
edge esiste, viene restituito. Altrimenti, NULL viene restituito.

isEdge_sg(sg : grafico_t, t : nodo_t, h : nodo_t, s : stringa): bordo_t
cerca un bordo con nodo di coda t, nodo di testa h e nome s in (sotto)grafico sg. Se il
grafico non è orientato, la distinzione tra nodi di testa e di coda non è importante.
Se tale bordo esiste, viene restituito. Altrimenti, NULL viene restituito.

è Subedge(g : grafico_t, e : bordo_t): int
restituisce un valore diverso da zero se edge e è nel (sotto)grafico sg, o zero altrimenti.

fstout(n : nodo_t): bordo_t
restituisce il primo outedge di node n nel grafico radice.

fstout_sg(sg : grafico_t, n : nodo_t): bordo_t
restituisce il primo outedge di node n in (sotto)grafico sg.

nxtout(e : bordo_t): bordo_t
restituisce il prossimo outedge dopo e nel grafico radice.

nxtout_sg(sg : grafico_t, e : bordo_t): bordo_t
restituisce il prossimo outedge dopo e nel grafico sg.

fstin(n : nodo_t): bordo_t
restituisce il primo inedge del nodo n nel grafico radice.

fstin_sg(sg : grafico_t, n : nodo_t): bordo_t
restituisce il primo inedge del nodo n nel grafico sg.

nxtin(e : bordo_t): bordo_t
restituisce il prossimo inedge dopo e nel grafico radice.

nxtin_sg(sg : grafico_t, e : bordo_t): bordo_t
restituisce il prossimo inedge dopo e nel grafico sg.

Fstedge(n : nodo_t): bordo_t
restituisce il primo arco del nodo n nel grafico radice.

fstedge_sg(sg : grafico_t, n : nodo_t): bordo_t
restituisce il primo arco del nodo n nel grafico sg.

xtedge(e : bordo_t, nodo_t): bordo_t
restituisce il bordo successivo dopo e nel grafico radice.

nxtedge_sg(sg : grafico_t, e : bordo_t, nodo_t): bordo_t
restituisce il bordo successivo dopo e nel grafico sg.

opp(e : bordo_t, nodo_t): nodo_t
restituisce il nodo sul bordo e non uguale a n. Restituisce NULL se n non è un nodo di
e. Questo può essere utile quando si utilizza Fstedge ed xtedge per enumerare i vicini di
n.

Grafico I / O
scrivere(g : grafico_t): nulla
stampe g in formato punto sul flusso di output.

scriviG(g : grafico_t, fnome : stringa): nulla
stampe g in formato punto nel file fnome.

fwriteG(g : grafico_t, fd : int): nulla
stampe g in formato punto sul flusso aperto indicato dal numero intero fd.

leggiG(fnome : stringa): grafico_t
restituisce un grafico letto dal file fnome. Il grafico dovrebbe essere in formato punto. se no
grafico può essere letto, NULL viene restituito.

fread G(fd : int): grafico_t
restituisce il grafico successivo letto dal flusso aperto fd. ritorna NULL alla fine del file.

Grafico miscellanea
delete(g : grafico_t, x : oggetto_t): nulla
elimina l'oggetto x dal grafico g. Se g is NULL, la funzione utilizza il grafico radice di
x. Se x è un grafico o un sottografo, è chiuso a meno che x è bloccato.

èIn(g : grafico_t, x : oggetto_t): int
restituisce vero se x è nel sottografo g.

cloneG(g : grafico_t, s : stringa): grafico_t
crea un clone di grafico g con il nome di s. Se s è "", il grafico creato ha il
stesso nome di g.

clonare(g : grafico_t, x : oggetto_t): oggetto_t
crea un clone di oggetto x nel grafico g. In particolare, il nuovo oggetto ha lo stesso
attributi nome/valore e struttura come l'oggetto originale. Se un oggetto con il
stessa chiave di x esiste già, i suoi attributi sono sovrapposti a quelli di x e la
oggetto viene restituito. Se un bordo viene clonato, entrambi gli endpoint vengono clonati implicitamente.
Se un grafico viene clonato, tutti i nodi, i bordi e i sottografi vengono clonati implicitamente. Se x
è un grafico, g può essere NULL, nel qual caso l'oggetto clonato sarà una nuova radice
grafico. In questo caso, la chiamata equivale a cloneG(x,"").

copia(g : grafico_t, x : oggetto_t): oggetto_t
crea una copia dell'oggetto x nel grafico g, dove il nuovo oggetto ha lo stesso nome/valore
attributi come l'oggetto originale. Se un oggetto con la stessa chiave di x già
esiste, i suoi attributi sono sovrapposti a quelli di x e l'oggetto viene restituito. Nota
che questa è una copia superficiale. Se x è un grafo, nessuno dei suoi nodi, archi o sottografi
vengono copiati nel nuovo grafico. Se x è un arco, gli estremi vengono creati se
necessario, ma non vengono clonati. Se x è un grafico, g può essere NULL, nel qual caso
l'oggetto clonato sarà un nuovo grafico radice.

copiaA(src : oggetto_t, TGT : oggetto_t): int
copia gli attributi dell'oggetto src obiettare TGT, sovrascrivendo qualsiasi valore di attributo
TGT potrebbe avere inizialmente.

indurre(g : grafico_t): nulla
si estende g alla sua estensione del sottografo indotta dal nodo nel suo grafo radice.

haAttr(src : oggetto_t, Nome : stringa): int
restituisce un valore diverso da zero se oggetto src ha un attributo il cui nome è Nome. Restituisce 0
altrimenti.

è Attr(g : grafico_t, tipo : stringa, Nome : stringa): int
restituisce un valore diverso da zero se un attributo Nome è stato definito in g per gli oggetti del
dato tipo. Per nodi, archi e grafici, tipo dovrebbe essere "N", "E" e "G",
rispettivamente. Altrimenti restituisce 0.

ottenere(src : oggetto_t, Nome : stringa): stringa
restituisce il valore di attributo Nome in oggetto src. Questo è utile per quei casi
quando Nome è in conflitto con una delle parole chiave come "head" o "root". Se la
l'attributo non è stato dichiarato nel grafico, la funzione lo inizializzerà con
un valore predefinito di "". Per evitare ciò, si dovrebbe usare il haAttr or è Attr function
per verificare che l'attributo esista.

un set(src : oggetto_t, Nome : stringa, APPREZZIAMO : stringa): int
imposta il valore dell'attributo Nome in oggetto src a APPREZZIAMO. Restituisce 0 in caso di successo,
diverso da zero in caso di guasto. Vedere ottenere sopra.

getDflt(g : grafico_t, tipo : stringa, Nome : stringa): stringa
restituisce il valore predefinito di attributo Nome negli oggetti in g del dato tipo. For
nodi, archi e grafici, tipo dovrebbero essere rispettivamente "N", "E" e "G". Se la
l'attributo non è stato dichiarato nel grafico, la funzione lo inizializzerà con
un valore predefinito di "". Per evitare ciò, si dovrebbe usare il è Attr funzione da controllare
che l'attributo esiste.

setDflt(g : grafico_t, tipo : stringa, Nome : stringa, APPREZZIAMO : stringa): int
imposta il valore predefinito di attributo Nome a APPREZZIAMO negli oggetti in g del dato
tipo. Per nodi, archi e grafici, tipo dovrebbero essere rispettivamente "N", "E" e "G".
Restituisce 0 in caso di successo, diverso da zero in caso di fallimento. Vedere getDflt sopra.

fstAttr(g : grafico_t, tipo : stringa): stringa
restituisce il nome del primo attributo degli oggetti in g del dato tipo. For
nodi, archi e grafici, tipo dovrebbero essere rispettivamente "N", "E" e "G". Se ci
non ci sono attributi, viene restituita la stringa "".

nxtAttr(g : grafico_t, tipo : stringa, Nome : stringa): stringa
restituisce il nome del prossimo attributo degli oggetti in g del dato tipo dopo l'
attributo Nome. L'argomento Nome deve essere il nome di un attributo esistente; esso
sarà tipicamente il valore di ritorno di una precedente chiamata a fstAttr or nxtAttr. For
nodi, archi e grafici, tipo dovrebbero essere rispettivamente "N", "E" e "G". Se ci
non sono rimasti attributi, viene restituita la stringa "".

comp(g : grafico_t, n : nodo_t): grafico_t
restituisce la componente connessa del grafico g contenente nodo n, come sottografo di
g. Il sottografo contiene solo i nodi. Si può usare indurre per aggiungere i bordi. Il
la funzione fallisce e ritorna NULL if n non è in g. La connettività si basa sul
sottostante grafo non orientato di g.

tipo(obj : oggetto_t): stringa
restituisce l'indicazione del tipo di obj. Per nodi, archi e grafici, restituisce
"N", "E" e "G", rispettivamente.

bloccare(g : grafico_t, v : int): int
implementa il blocco dei grafici sui grafici radice. Se l'intero v è positivo, il grafico è
impostato in modo che il futuro chiami a delete non hanno effetto immediato. Se v è zero, il
grafico è sbloccato. Se c'è stata una chiamata per eliminare il grafico mentre era
bloccato, il grafico è chiuso. Se v è negativo, non si fa nulla. In tutti i casi, il
viene restituito il valore di blocco precedente.

String
sprintf(FMT : stringa, ...): stringa
restituisce la stringa risultante dalla formattazione dei valori delle espressioni
che si verifica dopo FMT secondo l' printf(3) formato FMT

gsub(str : stringa, colpetto : stringa): stringa

gsub(str : stringa, colpetto : stringa, sostitu : stringa): stringa
problemi str con tutte le sottostringhe corrispondenti colpetto cancellato o sostituito da sostitu,
rispettivamente.

sotto(str : stringa, colpetto : stringa): stringa

sotto(str : stringa, colpetto : stringa, sostitu : stringa): stringa
problemi str con la corrispondenza della sottostringa più a sinistra colpetto cancellato o sostituito da sostitu,
rispettivamente. I caratteri '^' e '$' possono essere usati all'inizio e alla fine,
rispettivamente, di colpetto per ancorare il motivo all'inizio o alla fine di str.

substr(str : stringa, idx : int): stringa

substr(str : stringa, idx : int, len : int): stringa
restituisce la sottostringa di str a partire dalla posizione idx alla fine della stringa o
di lunghezza len, rispettivamente. L'indicizzazione inizia da 0. Se idx è negativo o idx is
maggiore della lunghezza di str, si verifica un errore irreversibile. Allo stesso modo, nel secondo
caso, se len è negativo o idx + len è maggiore della lunghezza di str, un fatale
si verifica un errore.

strcmp(s1 : stringa, s2 : stringa): int
fornisce la funzione C standard strcmp(3).

lunghezza(s : stringa): int
restituisce la lunghezza della stringa s.

Index(s : stringa, t : stringa): int

indice(s : stringa, t : stringa): int
restituisce l'indice del carattere in stringa s dove la copia più a sinistra (più a destra)
di stringa t può essere trovato, o -1 se t non è una sottostringa di s.

stile(s : stringa, p : stringa): int
restituisce l'indice del carattere in stringa s dove la corrispondenza più a sinistra del modello
p può essere trovato, o -1 se nessuna sottostringa di s fiammiferi p.

tomaia(s : stringa): stringa
restituisce una versione di s con i caratteri alfabetici convertiti in maiuscolo.

ridurre(s : stringa): stringa
restituisce una versione di s con i caratteri alfabetici convertiti in minuscolo.

canone(s : stringa): stringa
restituisce una versione di s appropriato per essere utilizzato come identificatore in un file punto.

html(g : grafico_t, s : stringa): stringa
restituisce una versione ``magica'' di s come una stringa HTML. Questo sarà in genere utilizzato per
allegare un'etichetta simile a HTML a un oggetto grafico. Nota che la stringa restituita vive in
g. In particolare, sarà liberato quando g è chiuso e per agire come una stringa HTML,
deve essere usato con un oggetto di g. Inoltre, si noti che la parentesi angolare
le citazioni non dovrebbero far parte di s. Questi verranno aggiunti se g è scritto in concreto DOT
formato.

ishtml(s : stringa): int
restituisce diverso da zero se e solo se s è una stringa HTML.

xDi(s : stringa): stringa
restituisce la stringa "x" Se s ha la forma "x,y", dove entrambi x ed y sono numerici.

yDi(s : stringa): stringa
restituisce la stringa "y" Se s ha la forma "x,y", dove entrambi x ed y sono numerici.

llDi(s : stringa): stringa
restituisce la stringa "lx,lly" Se s ha la forma "lx,lly,urx,ury", dove tutti lx,
lly, urxe ury sono numerici.

urDi(s)
urDi(s : stringa): stringa restituisce la stringa "urx,ury" Se s ha la forma
"lx,lly,urx,ury", dove tutti lx, lly, urxe ury sono numerici.

scanf(s : stringa, FMT : stringa, ...): int
scansiona la stringa s, estraendo i valori secondo il scanf(3) formato FMT.
i valori sono memorizzati negli indirizzi seguenti FMT, indirizzi aventi la forma &v,
where v è una variabile dichiarata del tipo corretto. Restituisce il numero di elementi
scansionato con successo.

dividere(s : stringa, arr : schieramento, settembre : stringa): int

dividere(s : stringa, arr : schieramento): int

token(s : stringa, arr : schieramento, settembre : stringa): int

token(s : stringa, arr : schieramento): int
I dividere la funzione rompe la stringa s nei campi, mentre il token function
suddivide la stringa in token. Un campo è composto da tutti i caratteri non separatori
tra due caratteri separatori o l'inizio o la fine della stringa. Quindi, a
il campo può essere la stringa vuota. Un token è una sottostringa massimale non vuota not
contenente un carattere separatore. I caratteri separatori sono quelli indicati nella
settembre discussione. Se settembre non è fornito, il valore predefinito è " \t\n". Il
le funzioni restituiscono il numero di campi o token.

I campi ei token sono memorizzati nell'array di argomenti. L'array deve essere stringa-
valutato e, se viene specificato un tipo di indice, deve essere int. Le voci sono indicizzate
per interi consecutivi, a partire da 0. Qualsiasi valore già memorizzato nell'array lo farà
essere sovrascritto o essere ancora presente dopo il ritorno della funzione.

I / O
stampare(...): nulla
Stampa( espr, ... ) stampa una rappresentazione di stringa di ogni argomento a sua volta su
stdout, seguito da una nuova riga.

printf(FMT : stringa, ...): int

printf(fd : int, FMT : stringa, ...): int
stampa la stringa risultante dalla formattazione dei valori delle seguenti espressioni
FMT secondo l' printf(3) formato FMT. Restituisce 0 in caso di successo. Per impostazione predefinita, è
stampa su stdout. Se l'intero opzionale fd è dato, l'output è scritto su
open stream associato a fd.

scanf(FMT : stringa, ...): int

scanf(fd : int, FMT : stringa, ...): int
esegue la scansione dei valori da un flusso di input in base a scanf(3) formato FMT.
i valori sono memorizzati negli indirizzi seguenti FMT, indirizzi aventi la forma &v,
where v è una variabile dichiarata del tipo corretto. Per impostazione predefinita, legge da
stdin. Se l'intero opzionale fd viene dato, l'input viene letto dal flusso aperto
associato fd. Restituisce il numero di elementi scansionati con successo.

apriF(s : stringa, t : stringa): int
apre il file s come flusso di I/O. L'argomento della stringa t specifica come è il file
ha aperto. Gli argomenti sono gli stessi della funzione C fope(3). Ritorna e
intero che denota il flusso o -1 in caso di errore.

Come al solito, gli stream 0, 1 e 2 sono già aperti come stdin, stdoute stderr,
rispettivamente. Da gvpr può usare stdin per leggere i grafici di input, l'utente dovrebbe
evitare di utilizzare questo flusso.

chiudiF(fd : int): int
chiude il flusso aperto indicato dal numero intero fd. I flussi 0, 1 e 2 non possono essere
Chiuso. Restituisce 0 in caso di successo.

leggiL(fd : int): stringa
restituisce la riga successiva letta dal flusso di input fd. Restituisce la stringa vuota ""
alla fine del file. Nota che il carattere di nuova riga viene lasciato nella stringa restituita.

Matematica
exp(d : doppio): doppio
restituisce e al desimo potere.

ceppo(d : doppio): doppio
restituisce il log naturale di d.

sqrt(d : doppio): doppio
restituisce la radice quadrata del doppio d.

pow(d : doppio, x : doppio): doppio
problemi d elevato al xesimo potere.

cos(d : doppio): doppio
restituisce il coseno di d.

peccato(d : doppio): doppio
restituisce il seno di d.

atan2(y : doppio, x : doppio): doppio
restituisce l'arcotangente di y / x nell'intervallo da -pi a pi.

MIN(y : doppio, x : doppio): doppio
restituisce il minimo di y ed x.

MAX(y : doppio, x : doppio): doppio
restituisce il massimo di y ed x.

Associativo Array
# arr : int
restituisce il numero di elementi nell'array arr.

idx in arr : int
restituisce 1 se è stato impostato un valore per index idx nell'array arr. Restituisce 0
altrimenti.

non settato(v : schieramento, idx): int
rimuove l'elemento indicizzato da idx. Restituisce 1 se l'elemento esiste, 0 altrimenti.

non settato(v : schieramento): nulla
re-inizializza l'array.

Miscellanea
exit(v : int): nulla
cause gvpr uscire con il codice di uscita v.

sistema(cmd : stringa): int
fornisce la funzione C standard sistema(3). si esegue cmd nella shell dell'utente
ambiente e restituisce lo stato di uscita della shell.

rand() : doppio
restituisce un doppio pseudo-casuale compreso tra 0 e 1.

filo() : int

filo(v : int): int
imposta un seme per il generatore di numeri casuali. L'argomento facoltativo fornisce il seme;
se viene omesso, viene utilizzata l'ora corrente. Viene restituito il valore del seme precedente.
filo dovrebbe essere chiamato prima di qualsiasi chiamata a rand.

colorex(colore : stringa, FMT : stringa): stringa
traduce un colore da un formato all'altro. Il colore l'argomento dovrebbe essere un colore
in una delle rappresentazioni di stringa riconosciute. Il FMT il valore dovrebbe essere uno di
"RGB", "RGBA", "HSV" o "HSVA". In caso di errore viene restituita una stringa vuota.

INCORPORATO VARIABILI

gvpr fornisce alcune variabili speciali, incorporate, i cui valori sono impostati automaticamente da
gvpr a seconda del contesto. Salvo quanto indicato, l'utente non può modificare i propri valori.

$ : oggetto_t
denota l'oggetto corrente (nodo, bordo, grafico) a seconda del contesto. Non è
disponibile in INIZIO or FINE clausole.

$F : stringa
è il nome del file di input corrente.

$G : grafico_t
denota il grafico in corso di elaborazione. Non è disponibile in INIZIO or FINE
clausole.

$NG : grafico_t
denota il grafico successivo da elaborare. Se $NG è NULL, il grafico corrente $G Europe è
ultimo grafico. Nota che se l'input proviene da stdin, l'ultimo grafico non può essere
determinato fino alla chiusura del tubo di ingresso. Non è disponibile in INIZIO or FINE
clausole, o se il -n viene utilizzata la bandiera.

$O : grafico_t
denota il grafico di output. Prima dell'attraversamento del grafico, viene inizializzato sul target
grafico. Dopo l'attraversamento e qualsiasi FINE_G azioni, se si riferisce a un grafico non vuoto,
quel grafico viene stampato sul flusso di output. È valido solo in N, E ed FINE_G
clausole. Il grafico di output può essere impostato dall'utente.

$T : grafico_t
denota il grafico di destinazione corrente. È un sottografo di $G ed è disponibile solo in
N, E ed FINE_G clausole.

$tgtnome : stringa
denota il nome del grafico di destinazione. Per impostazione predefinita, è impostato su "gvpr_result". Se
utilizzato più volte durante l'esecuzione di gvpr, il nome verrà aggiunto con un
numero intero. Questa variabile può essere impostata dall'utente.

$ root tv : nodo_t
indica il nodo di partenza per un (diretto o non orientato) profondità o ampiezza
primo attraversamento del grafico (cfr. $tipo di tv sotto). Il valore predefinito è NULL per
ogni grafico di ingresso. Dopo l'attraversamento alla radice data, se il valore di $ root tv
è cambiato, un nuovo attraversamento inizierà con il nuovo valore di $ root tv. Inoltre, imposta
$tvsuccessivo qua sotto.

$tvsuccessivo : nodo_t
indica il prossimo nodo di partenza per un (diretto o non orientato) depth-first o
ampiezza-primo attraversamento del grafo (cfr. $tipo di tv sotto). Se una traversata finisce
e la $ root tv non è stato resettato ma il $tvsuccessivo è stato impostato ma non utilizzato, questo
nodo verrà utilizzato come scelta successiva per $ root tv. Il valore predefinito è NULL per
ogni grafico di ingresso.

$ tv : bordo_t
Per gli attraversamenti BFS e DFS, questo è impostato sul bordo utilizzato per arrivare alla corrente
nodo o bordo. All'inizio di un attraversamento, o per altri tipi di attraversamento, il
valore è NULL.

$tipo di tv : tvtype_t
indica come gvpr attraversa un grafico. Può assumere solo uno dei valori costanti
con il precedente "TV_" descritto di seguito. TV_piatto è l'impostazione predefinita.

Nella libreria di grafici sottostante cgrafico(3), gli archi nei grafi non orientati sono dati an
direzione arbitraria. Questo è usato per gli attraversamenti, come TV_avanti, richiedendo
bordi orientati.

ARGC : int
denota il numero di argomenti specificati da -a args argomento della riga di comando.

ARGV : stringa schieramento
denota l'array di argomenti specificato da -a args argomento della riga di comando. Il
il'argomento è dato da ARGV[i].

INCORPORATO COSTANTI

Ci sono diverse costanti simboliche definite da gvpr.

NULL : oggetto_t
un riferimento a un oggetto nullo, equivalente a 0.

TV_piatto : tvtype_t
un semplice attraversamento piatto, con oggetti grafici visitati in un ordine apparentemente arbitrario.

TV_ne : tvtype_t
un attraversamento che visita prima tutti i nodi, poi tutti i bordi.

TV_it : tvtype_t
un attraversamento che visita prima tutti gli spigoli, poi tutti i nodi.

TV_dfs : tvtype_t
TV_postdfs : tvtype_t
TV_prepostdfs : tvtype_t
un attraversamento del grafo utilizzando una ricerca in profondità sul sottostante non orientato
grafico. Per fare la traversata, gvpr controllerà il valore di $ root tv. Se questo ha il
stesso valore che aveva in precedenza (all'inizio viene inizializzato il valore precedente
a NULL)., gvpr cercherà semplicemente qualche nodo non visitato e attraverserà il suo connesso
componente. D'altra parte, se $ root tv è cambiato, il suo componente collegato sarà
essere visitato, supponendo che non sia stato precedentemente visitato o, se $ root tv is NULL, le
la traversata si fermerà. Nota che usando TV_dfs ed $ root tv, è possibile creare
un ciclo infinito.

Per impostazione predefinita, l'attraversamento viene eseguito in preordine. Cioè, un nodo viene visitato prima
tutti i suoi bordi non visitati. Per TV_postdfs, tutti gli archi non visitati di un nodo sono
visitato prima del nodo. Per TV_prepostdfs, un nodo viene visitato due volte, prima e
dopo tutti i suoi bordi non visitati.

TV_avanti : tvtype_t
TV_postfwd : tvtype_t
TV_prepostfwd : tvtype_t
Un attraversamento del grafico utilizzando una ricerca in profondità solo sul grafico che segue
archi in avanti. La scelta delle radici per l'attraversamento è la stessa descritta per
TV_dfs sopra. Il diverso ordine di visita specificato da TV_avanti, TV_postfwd
ed TV_prepostfwd sono gli stessi di quelli specificati dagli analoghi attraversamenti
TV_dfs, TV_postdfs ed TV_prepostdfs.

TV_riv : tvtype_t
TV_postrev : tvtype_t
TV_prepostrev : tvtype_t
Un attraversamento del grafico utilizzando una ricerca in profondità solo sul grafico che segue
archi inversi. La scelta delle radici per l'attraversamento è la stessa descritta per
TV_dfs sopra. Il diverso ordine di visita specificato da TV_riv, TV_postrev
ed TV_prepostrev sono gli stessi di quelli specificati dagli analoghi attraversamenti
TV_dfs, TV_postdfs ed TV_prepostdfs.

TV_bfs : tvtype_t
Un attraversamento del grafico utilizzando una ricerca in ampiezza sul grafico ignorando il bordo
indicazioni. Vedi l'articolo su TV_dfs sopra per il ruolo di $ root tv.

ESEMPI

gvpr -i 'N[colore=="blu"]' file.gv

Genera il sottografo indotto dai nodi di tutti i nodi con il colore blu.

gvpr -c 'N[colore=="blu"]{colore = "rosso"}' file.gv

Rendi tutti i nodi blu rossi.

INIZIO { int n, e; int tot_n = 0; int totalizzatore = 0; }
BEG_G {
n = nNodi($G);
e = nEdge($G);
printf ("%D nodi %d bordi %s\n", n, e, $G.nome);
tot_n += n;
totalizzatore += e;
}
FINE { printf ("%D nodi %d bordi totale\n", tot_n, totalizzatore) }

Versione del programma gc.

gvpr -c ""

Equivalente a nop.

BEG_G { grafico_t g = grafico ("unire", "S"); }
E {
nodo_t h = clone(g,$.testa);
nodo_t t = clone(g,$.coda);
bordo_t e = bordo(t,h,"");
e.peso = e.peso + 1;
}
FINE_G { $O = g; }

Produce una versione rigorosa del grafico di input, dove l'attributo peso di un arco
indica quanti bordi dal grafico di input rappresenta il bordo.

INIZIO {nodo_t n; int grado[]}
E{grado[testa]++; grado[coda]++; }
FINE_G {
per (grado[n]) {
printf ("gradi[%s] = %d\n", n.name, grado[n]);
}
}

Calcola i gradi dei nodi con bordi.

INIZIO {
int i, trattino;
int visto[stringa];
nulla stampa (int cnt) {
per (i = 0; i < cnt; io++) printf (" ");
}
}
BEG_G {

$tipo di tv = TV_prepostfwd;
$ root tv = nodo($,ARGV[0]);
}
N {
if (visto[$.nome]) rientro--;
altro {
prInd(indentazione);
stampare ($.nome);
visto[$.nome] = 1;
rientro++;
}
}

Stampa l'attraversamento in profondità del grafo, a partire dal nodo il cui nome è
ARGV[0], come elenco rientrato.

AMBIENTE

GVPRPATH
Elenco separato da due punti di directory da cercare per trovare il file specificato da
l'opzione -f. gvpr ha un elenco predefinito integrato. Se GVPRPATH non è definito, il
viene utilizzato l'elenco predefinito. Se GVPRPATH inizia con due punti, l'elenco è formato da
aggiungendo GVPRPATH all'elenco predefinito. Se GVPRPATH termina con due punti, l'elenco è
formato aggiungendo l'elenco predefinito a GVPRPATH. Altrimenti, GVPRPATH è usato per
la lista.

Sui sistemi Windows, sostituire i ``due punti'' con ``punto e virgola'' nel paragrafo precedente.

Usa gvpr online utilizzando i servizi onworks.net