gvpr - Online în cloud

PROGRAM:

NUME

gvpr - limbaj de scanare și procesare a modelelor grafice

REZUMAT

gvpr [-icnqV?] [ -o outfile ] [ -a args ] [ „prog” | -f profil ] [ fișiere ]

DESCRIERE

gvpr (Cunoscut anterior ca gpr) este un editor de flux grafic inspirat de Wow. Copiază intrarea
grafice la ieșirea acestuia, transformându-și eventual structura și atributele, creând noi
grafice sau tipărirea de informații arbitrare. Modelul grafic este cel oferit de
libcgraph(3). În special, gvpr citește și scrie grafice folosind limbajul punctelor.

Pe scurt, gvpr parcurge fiecare grafic de intrare, notat cu $G, vizitând fiecare nod și margine,
potrivirea acestuia cu regulile de acțiune-predicat furnizate în programul de intrare. Regulile sunt
evaluat în ordine. Pentru fiecare predicat care se evaluează la adevărat, acțiunea corespunzătoare este
efectuat. În timpul traversării, nodul sau marginea curentă care este vizitată este notat cu $.

Pentru fiecare grafic de intrare, există un subgraf țintă, notat cu $T, inițial gol și folosit
pentru a acumula entitățile alese și un grafic de ieșire, $O, folosit pentru prelucrarea finală și apoi
scris la ieșire. În mod implicit, graficul de ieșire este graficul țintă. Graficul de ieșire
poate fi setat în program sau, într-un sens limitat, pe linia de comandă.

OPŢIUNI

Sunt acceptate următoarele opțiuni:

-a args
Șirul args este împărțit în jetoane separate prin spații albe, cu individul
jetoane disponibile ca șiruri în gvpr program ca ARGV[0],...,ARGV[ARGC-1].
Caractere cu spații albe în subșiruri ghilimele simple sau duble sau precedate de a
backslash, sunt ignorate ca separatori. În general, un caracter bară oblică inversă se dezactivează
orice semnificație specială a următorului caracter. Rețineți că jetoanele derivate din
multiplu -a steaguri sunt concatenate.

-c Utilizați graficul sursă ca grafic de ieșire.

-i Deduceți extensia subgrafului indusă de noduri a graficului de ieșire în contextul
graficul său rădăcină.

-o outfile
Face ca fluxul de ieșire să fie scris în fișierul specificat; implicit, ieșirea este
scris stdout.

-f profil
Utilizați conținutul fișierului specificat ca program de executat pe intrare. Dacă
profil conține un caracter slash, numele este luat ca cale a fișierului.
In caz contrar, gvpr va folosi directoarele specificate în variabila de mediu
GVPRPATH să caute dosarul. Dacă -f nu este dat, gvpr va folosi primul non-
argument opțiune ca program.

-q Dezactivează mesajele de avertizare.

-n Dezactivează citirea anticipată a graficului. În mod implicit, variabila $NG este setat la graficul următor
a fi procesat. Acest lucru necesită o citire a următorului grafic înainte de a procesa
graficul curent, care se poate bloca dacă următorul grafic este generat doar ca răspuns la
unele acțiuni legate de prelucrarea graficului curent.

-V Determină programul să imprime informații despre versiune și să iasă.

-? Determină programul să imprime informații de utilizare și să iasă.

OPERANDE

Următorul operand este suportat:

fișiere Numele fișierelor care conțin 1 sau mai multe grafice în limbajul punctelor. Daca nu -f opțiune
este dat, prenumele este eliminat din listă și folosit ca program de introducere.
Dacă lista de fișiere este goală, stdin va fi folosit.

PROGRAME

A gvpr programul constă dintr-o listă de clauze predicat-acțiune, având una dintre formele:

ÎNCEPE { acțiune }

BEG_G { acțiune }

N [ predicat ] { acțiune }

E [ predicat ] { acțiune }

END_G { acțiune }

Sfârşit { acțiune }

Un program poate conține cel mult unul din fiecare dintre ÎNCEPE, END_G și Sfârşit clauze. Se poate
fie orice număr de BEG_G, N și E afirmații, prima aplicată graficelor, a doua la
noduri, al treilea la margini. Acestea sunt separate în blocuri, un bloc format dintr-un
facultativ BEG_G declarație și tot N și E declarații până la următoarea BEG_G declarație, dacă
orice. Semantica de nivel superior a a gvpr programul este:

Evaluează ÎNCEPE clauză, dacă există.
Pentru fiecare grafic de intrare G {
Pentru fiecare bloc {
set G ca grafic curent și obiect curent.
Evaluează BEG_G clauză, dacă există.
Pentru fiecare nod și margine în G {
Setați nodul sau marginea ca obiect curent.
Evaluează N or E clauze, după caz.
}
}
set G ca obiect curent.
Evaluează END_G clauză, dacă există.
}
Evaluează Sfârşit clauză, dacă există.

Acțiunile lui ÎNCEPE, BEG_G, END_G și Sfârşit clauzele se execută atunci când clauzele sunt
evaluat. Pentru N or E clauze, fie predicatul, fie acțiunea pot fi omise. În cazul în care există
nu este un predicat cu o acțiune, acțiunea este efectuată pe fiecare nod sau margine, așa cum
adecvat. Dacă nu există nicio acțiune și predicatul evaluează drept adevărat, asociatul
nodul sau marginea este adăugată graficului țintă.

Blocurile sunt evaluate în ordinea în care apar. În cadrul unui bloc, N clauzele
(E clauzele, respectiv) sunt evaluate în ordinea în care apar. Rețineți, totuși,
că într-un bloc, N or E clauzele pot fi întrețesute, în funcție de ordinea de parcurgere.

Predicatele și acțiunile sunt secvențe de enunțuri în dialectul C susținute de
expres(3) bibliotecă. Singura diferență dintre predicate și acțiuni este că prima
trebuie să aibă un tip care poate fi interpretat ca adevărat sau fals. Aici obișnuitul C
se urmează convenția, în care o valoare diferită de zero este considerată adevărată. Aceasta ar include
șiruri nevide și referințe nevide la noduri, margini etc. Cu toate acestea, dacă un șir poate
să fie convertită într-un număr întreg, se utilizează această valoare.

Pe lângă tipurile obișnuite de bază C (anula, int, car de război, pluti, lung, nesemnat și dubla),
gvpr furnizează şir ca sinonim pentru char*, și tipurile bazate pe grafice node_t, edge_t,
graph_t și obj_t. obj_t tipul poate fi privit ca un supertip al celorlalte 3 beton
tipuri; tipul de bază corect este menținut dinamic. Pe lângă aceste tipuri de bază,
numai alte expresii de tip acceptate sunt tablouri (asociative).

Constantele urmează sintaxa C, dar șirurile pot fi citate cu oricare "..." or '...'. gvpr
acceptă comentarii C++, precum și comentarii de tip cpp. Pentru acesta din urmă, dacă o linie începe cu
un caracter „#”, restul liniei este ignorat.

O instrucțiune poate fi o declarație a unei funcții, a unei variabile sau a unui tablou sau a unui executabil
afirmație. Pentru declarații, există un singur domeniu de aplicare. Declarațiile de matrice au forma:

tip mulțime [ type0 ]

Unde type0 este optional. Dacă este furnizat, parserul va impune toate matricele
indicele au tipul specificat. Dacă nu este furnizat, obiectele de toate tipurile pot fi
folosite ca indice. Ca și în C, variabilele și tablourile trebuie declarate. În special, an
variabila nedeclarată va fi interpretată ca numele unui atribut al unui nod, margine sau
grafic, în funcție de context.

Declarațiile executabile pot fi una dintre următoarele:

{ [ declaraţie ... ] }
expresie // în mod obișnuit a fost = expresie
dacă( expresie ) declaraţie [ altfel declaraţie ]
pentru( expresie ; expresie ; expresie ) declaraţie
pentru( mulțime [ a fost ]) declaraţie
pentru mulțime [ a fost ]) declaraţie
in timp ce ( expresie ) declaraţie
comutator ( expresie ) caz Declarații
rupe [ expresie ]
continua [ expresie ]
reveni [ expresie ]
Elementele dintre paranteze sunt opționale.

În a doua formă a pentru declarația și forr declarație, variabila a fost este setat la
fiecare valoare folosită ca index în matricea specificată și apoi cea asociată declaraţie is
evaluat. Pentru indici numerici și de șir, indicii sunt returnați în creștere
ordine (descrescătoare) numerică sau lexicografică pentru pentru (forr, respectiv). Acesta poate fi folosit
pentru sortare.

Definițiile funcțiilor pot apărea numai în ÎNCEPE clauză.

Expresiile includ expresiile C obișnuite. Comparații de șiruri folosind == și != tratați
operand din dreapta ca model în scopul potrivirii expresiilor regulate. Modele
utilizare ksh(1) sintaxa modelului de potrivire a fișierelor. (Pentru egalitate simplă de șiruri, utilizați strcmp
Funcția.

gvpr va încerca să folosească o expresie ca șir sau valoare numerică, după caz. Ambii
Modelele de tip C și șabloanele de funcții vor determina efectuarea de conversii, dacă este posibil.

Expresii de tip grafic (de exemplu, graph_t, node_t, edge_t, obj_t) poate fi urmată de a
referință de câmp sub formă de .nume. Valoarea rezultată este valoarea atributului
numit nume a obiectului dat. În plus, în anumite contexte un nedeclarat,
identificatorul nemodificat este considerat un nume de atribut. Mai exact, astfel de identificatori
denotă atribute ale nodului sau marginii curente, respectiv, în N și E clauzele, iar
graficul curent în BEG_G și END_G clauze.

Ca de obicei în libcgraph(3) model, atributele sunt valorizate pe șir. În plus, gvpr
acceptă anumite pseudo-atribute ale obiectelor graf, nu neapărat cu valori de șir. Aceste
reflectă proprietățile intrinseci ale obiectelor grafic și nu pot fi setate de utilizator.

cap : node_t
capul unei margini.

coadă : node_t
coada unei margini.

nume : şir
numele unei muchii, nod sau grafic. Numele unei margini are forma „<tail‐
nume>[]", Unde este "->"Sau"--" în funcție de
indiferent dacă graficul este direcționat sau nu. Partea suportului [] apare numai dacă
edge are o cheie non-trivială.

indegree : int
indegreul unui nod.

gradul în afara : int
gradul exterior al unui nod.

grad : int
gradul unui nod.

rădăcină : graph_t
graficul rădăcinii unui obiect. Rădăcina unui grafic rădăcină este însăși.

mamă : graph_t
graficul părinte al unui subgraf. Părintele unui grafic rădăcină este NULL

n_muchii : int
numărul de muchii din grafic

n_noduri : int
numărul de noduri din grafic

dirijat : int
adevărat (diferit de zero) dacă graficul este direcționat

strict : int
adevărat (diferit de zero) dacă graficul este strict

INCORPORAT FUNCȚII

Următoarele funcții sunt încorporate gvpr. Acele funcții care returnează referințe la grafic
obiectele se întorc NULL în caz de eşec.

graficele și subgrafic
grafic(s : şir, t : şir): graph_t
creează un grafic al cărui nume este s și al cărui tip este specificat de șir t.
Ignorând majuscule și minuscule, personajele U, D, S, N au interpretarea nedirecționată,
direcționat, strict și, respectiv, non-strict. Dacă t este gol, un direcționat, non‐
este generat un grafic strict.

subg(g : graph_t, s : şir): graph_t
creează un subgraf în grafic g cu nume s. Dacă subgraful există deja, este
întors.

isSubg(g : graph_t, s : şir): graph_t
returnează subgraful în grafic g cu nume s, dacă există, sau NULL in caz contrar.

fstsubg(g : graph_t): graph_t
returnează primul subgraf din grafic g, Sau NULL dacă nu există.

nxtsubg(sg : graph_t): graph_t
returnează următorul subgraf după sg, Sau NULL.

isDirect(g : graph_t): int
returnează adevărat dacă și numai dacă g este regizat.

este Strict(g : graph_t): int
returnează adevărat dacă și numai dacă g este strict.

nNoduri(g : graph_t): int
returnează numărul de noduri în g.

nEdges(g : graph_t): int
returnează numărul de muchii în g.

Nodurile
nod(sg : graph_t, s : şir): node_t
creează un nod în grafic g de nume s. Dacă un astfel de nod există deja, acesta este returnat.

subnodul(sg : graph_t, n : node_t): node_t
inserează nodul n în subgraf g. Returnează nodul.

fstnode(g : graph_t): node_t
returnează primul nod din grafic g, Sau NULL dacă nu există.

nxtnode(n : node_t): node_t
returnează următorul nod după n în graficul rădăcină sau NULL.

nxtnode_sg(sg : graph_t, n : node_t): node_t
returnează următorul nod după n in sg, Sau NULL.

isNode(sg : graph_t, s : şir): node_t
caută un nod în (sub)graf sg de nume s. Dacă un astfel de nod există, acesta este returnat.
In caz contrar, NULL este returnat.

isSubnode(sg : graph_t, n : node_t): int
returnează diferit de zero dacă nodul n este în (sub)graf sg, sau zero altfel.

indegreeOf(sg : graph_t, n : node_t): int
returnează gradul nodului n în (sub)graf sg.

outdegreeOf(sg : graph_t, n : node_t): int
returnează gradul exterior al nodului n în (sub)graf sg.

gradul de(sg : graph_t, n : node_t): int
returnează gradul de nod n în (sub)graf sg.

Margini
margine(t : node_t, h : node_t, s : şir): edge_t
creează o margine cu nod de coadă t, nod cap h si nume s în graficul rădăcină. Dacă
graficul este nedirecționat, distincția dintre nodurile cap și coadă nu este importantă.
Dacă o astfel de margine există deja, este returnată.

edge_sg(sg : graph_t, t : node_t, h : node_t, s : şir): edge_t
creează o margine cu nod de coadă t, nod cap h si nume s în (sub)graf sg (si tot
grafice părinte). Dacă graficul este nedirecționat, distincția dintre cap și coadă
noduri nu este importantă. Dacă o astfel de margine există deja, este returnată.

sub muchie(g : graph_t, e : edge_t): edge_t
introduce marginea e în subgraf g. Returnează marginea.

isEdge(t : node_t, h : node_t, s : şir): edge_t
caută o margine cu nod de coadă t, nod cap h si nume s. Dacă graficul este
nedirecționată, distincția dintre nodurile cap și coadă este lipsită de importanță. Dacă un astfel de
edge există, este returnat. In caz contrar, NULL este returnat.

isEdge_sg(sg : graph_t, t : node_t, h : node_t, s : şir): edge_t
caută o margine cu nod de coadă t, nod cap h si nume s în (sub)graf sg. Dacă
graficul este nedirecționat, distincția dintre nodurile cap și coadă nu este importantă.
Dacă există o astfel de margine, este returnată. In caz contrar, NULL este returnat.

esteSubedge(g : graph_t, e : edge_t): int
returnează diferit de zero dacă margine e este în (sub)graf sg, sau zero altfel.

fstout(n : node_t): edge_t
returnează prima margine a nodului n în graficul rădăcină.

fstout_sg(sg : graph_t, n : node_t): edge_t
returnează prima margine a nodului n în (sub)graf sg.

nxtout(e : edge_t): edge_t
întoarce următorul outdge după e în graficul rădăcină.

nxtout_sg(sg : graph_t, e : edge_t): edge_t
întoarce următorul outdge după e în grafic sg.

fstin(n : node_t): edge_t
returnează prima margine a nodului n în graficul rădăcină.

fstin_sg(sg : graph_t, n : node_t): edge_t
returnează prima margine a nodului n în grafic sg.

nxtin(e : edge_t): edge_t
returnează următorul inedge după e în graficul rădăcină.

nxtin_sg(sg : graph_t, e : edge_t): edge_t
returnează următorul inedge după e în grafic sg.

fstedge(n : node_t): edge_t
returnează prima margine a nodului n în graficul rădăcină.

fstedge_sg(sg : graph_t, n : node_t): edge_t
returnează prima margine a nodului n în grafic sg.

nxtedge(e : edge_t, node_t): edge_t
revine următoarea margine după e în graficul rădăcină.

nxtedge_sg(sg : graph_t, e : edge_t, node_t): edge_t
revine următoarea margine după e în grafic sg.

OPP(e : edge_t, node_t): node_t
returnează nodul pe margine e nu este egal cu n. Returnează NULL dacă n nu este un nod al
e. Acest lucru poate fi util când se utilizează fstedge și nxtedge a enumera vecinii de
n.

Grafic I / O
scrie(g : graph_t): anula
printuri g în format punct în fluxul de ieșire.

scrieG(g : graph_t, fname : şir): anula
printuri g în format punct în fișier fname.

fwriteG(g : graph_t, fd : int): anula
printuri g în format punct pe fluxul deschis notat cu numărul întreg fd.

citesteG(fname : şir): graph_t
returnează un grafic citit din fișier fname. Graficul ar trebui să fie în format punct. Daca nu
graficul poate fi citit, NULL este returnat.

friadG(fd : int): graph_t
returnează următorul grafic citit din fluxul deschis fd. Se intoarce NULL la sfârşitul dosarului.

Grafic miscelaneu
șterge(g : graph_t, x : obj_t): anula
sterge obiectul x din grafic g. Dacă g is NULL, funcția folosește graficul rădăcină al
x. Dacă x este un grafic sau subgraf, este închis dacă nu x este încuiat.

este in(g : graph_t, x : obj_t): int
returnează adevărat dacă x este în subgraf g.

clonaG(g : graph_t, s : şir): graph_t
creează o clonă de grafic g cu numele de s. Dacă s este „”, graficul creat are
acelasi nume ca g.

clona(g : graph_t, x : obj_t): obj_t
creează o clonă de obiect x în grafic g. În special, noul obiect are același lucru
atribute nume/valoare și structură ca obiect original. Dacă un obiect cu
aceeași cheie ca x există deja, atributele sale sunt suprapuse de cele ale x si
obiectul este returnat. Dacă o margine este clonată, ambele puncte finale sunt clonate implicit.
Dacă un graf este clonat, toate nodurile, marginile și subgrafele sunt clonate implicit. Dacă x
este un grafic, g poate fi NULL, caz în care obiectul clonat va fi o nouă rădăcină
grafic. În acest caz, apelul este echivalent cu clonaG(x,"").

copiaţi(g : graph_t, x : obj_t): obj_t
creează o copie a obiectului x în grafic g, unde noul obiect are același nume/valoare
atribute ca obiect original. Dacă un obiect cu aceeași cheie ca x deja
există, atributele sale sunt suprapuse de cele ale x iar obiectul este returnat. Notă
că aceasta este o copie superficială. Dacă x este un grafic, niciunul dintre nodurile, muchiile sau subgrafele sale
sunt copiate în noul grafic. Dacă x este o muchie, punctele finale sunt create dacă
necesare, dar nu sunt clonate. Dacă x este un grafic, g poate fi NULL, in care caz
obiectul clonat va fi un nou grafic rădăcină.

copieA(src : obj_t, TGT : obj_t): int
copiază atributele obiectului src la obiect TGT, suprascriind orice valoare de atribut
TGT poate avea inițial.

induce(g : graph_t): anula
extinde g la extensia sa subgraf indusă de noduri în graficul său rădăcină.

areAttr(src : obj_t, nume : şir): int
returnează un obiect diferit de zero src are un atribut al cărui nume este nume. Se întoarce 0
in caz contrar.

isAttr(g : graph_t, natural : şir, nume : şir): int
returnează diferit de zero dacă un atribut nume a fost definit în g pentru obiectele din
dat natural. Pentru noduri, muchii și grafice, natural ar trebui să fie „N”, „E” și „G”,
respectiv. În caz contrar, returnează 0.

aget(src : obj_t, nume : şir): şir
returnează valoarea atributului nume în obiect src. Acest lucru este util pentru aceste cazuri
cand nume intră în conflict cu unul dintre cuvintele cheie precum „head” sau „root”. Dacă
atributul nu a fost declarat în grafic, funcția îl va inițializa cu
o valoare implicită „”. Pentru a evita acest lucru, ar trebui să utilizați areAttr or isAttr funcţie
pentru a verifica dacă atributul există.

un set(src : obj_t, nume : şir, valoare : şir): int
stabilește valoarea atributului nume în obiect src la valoare. Returnează 0 la succes,
diferit de zero la eșec. Vedea aget de mai sus.

getDflt(g : graph_t, natural : şir, nume : şir): şir
returnează valoarea implicită a atributului nume în obiecte în g a dat natural. Pentru
noduri, muchii și grafice, natural ar trebui să fie „N”, „E”, respectiv „G”. Dacă
atributul nu a fost declarat în grafic, funcția îl va inițializa cu
o valoare implicită „”. Pentru a evita acest lucru, ar trebui să utilizați isAttr funcția de verificat
că atributul există.

setDflt(g : graph_t, natural : şir, nume : şir, valoare : şir): int
setează valoarea implicită a atributului nume la valoare în obiecte în g a dat
natural. Pentru noduri, muchii și grafice, natural ar trebui să fie „N”, „E”, respectiv „G”.
Returnează 0 la succes, diferit de zero la eșec. Vedea getDflt de mai sus.

fstAttr(g : graph_t, natural : şir): şir
returnează numele primului atribut al obiectelor din g a dat natural. Pentru
noduri, muchii și grafice, natural ar trebui să fie „N”, „E”, respectiv „G”. În cazul în care există
nu există atribute, este returnat șirul „”.

nxtAttr(g : graph_t, natural : şir, nume : şir): şir
returnează numele următorului atribut al obiectelor din g a dat natural după
atribut nume. Argumentul nume trebuie să fie numele unui atribut existent; aceasta
va fi de obicei valoarea returnată a unui apel anterior către fstAttr or nxtAttr. Pentru
noduri, muchii și grafice, natural ar trebui să fie „N”, „E”, respectiv „G”. În cazul în care există
nu mai sunt atribute, este returnat șirul „”.

compOf(g : graph_t, n : node_t): graph_t
returnează componenta conexă a graficului g nodul care contine n, ca subgraf al
g. Subgraful conține doar nodurile. Se poate folosi induce pentru a adăuga marginile. The
funcția eșuează și revine NULL if n nu este în g. Conectivitatea se bazează pe
graficul nedirectat subiacent al g.

cam(obj : obj_t): şir
returnează o indicație a tipului de obj. Pentru noduri, muchii și grafice, se întoarce
„N”, „E”, respectiv „G”.

bloca(g : graph_t, v : int): int
implementează blocarea graficelor pe graficele rădăcină. Dacă numărul întreg v este pozitiv, graficul este
setați astfel încât apelurile viitoare către șterge nu au efect imediat. Dacă v este zero,
graficul este deblocat. Dacă a existat un apel pentru ștergerea graficului cât timp a fost
blocat, graficul este închis. Dacă v este negativ, nu se face nimic. În toate cazurile,
este returnată valoarea de blocare anterioară.

Corzi
sprint(fmt : şir, ...): şir
returnează șirul rezultat din formatarea valorilor expresiilor
survenind după fmt in conformitate cu printf(3) format fmt

gsub(str : şir, bătaie : şir): şir

gsub(str : şir, bătaie : şir, repl : şir): şir
Returnează str cu toate subșirurile care se potrivesc bătaie șters sau înlocuit cu repl,
respectiv.

sub(str : şir, bătaie : şir): şir

sub(str : şir, bătaie : şir, repl : şir): şir
Returnează str cu potrivirea subșirului din stânga bătaie șters sau înlocuit cu repl,
respectiv. Caracterele „^” și „$” pot fi folosite la început și la sfârșit,
respectiv, de bătaie pentru a ancora modelul la începutul sau sfârșitul str.

substr(str : şir, IDX : int): şir

substr(str : şir, IDX : int, len : int): şir
returnează subșirul de str începând de la poziție IDX până la capătul sforii sau
de lungime len, respectiv. Indexarea începe de la 0. Dacă IDX este negativ sau IDX is
mai mare decât lungimea de str, apare o eroare fatală. La fel, în al doilea
caz, dacă len este negativ sau IDX + len este mai mare decât lungimea de str, un fatal
apare o eroare.

strcmp(s1 : şir, s2 : şir): int
oferă funcția C standard strcmp(3).

lungime(s : şir): int
returnează lungimea șirului s.

index(s : şir, t : şir): int

rindex(s : şir, t : şir): int
returnează indexul caracterului din șir s unde copia cea mai din stânga (cel mai din dreapta).
de sfoară t poate fi găsit sau -1 dacă t nu este un subșir de s.

Meci(s : şir, p : şir): int
returnează indexul caracterului din șir s unde se potrivește cel mai din stânga modelului
p poate fi găsit sau -1 dacă nu există un subșir de s meciuri p.

tupper(s : şir): şir
returnează o versiune a s cu caracterele alfabetice convertite în majuscule.

pentru a reduce(s : şir): şir
returnează o versiune a s cu caracterele alfabetice convertite în litere mici.

canon(s : şir): şir
returnează o versiune a s adecvat pentru a fi folosit ca identificator într-un fișier punct.

html(g : graph_t, s : şir): şir
returnează o versiune „magic” a s ca șir HTML. Acest lucru va fi de obicei obișnuit
atașați o etichetă asemănătoare HTML unui obiect grafic. Rețineți că șirul returnat trăiește în
g. În special, va fi eliberat când g este închis și pentru a acționa ca șir HTML,
trebuie folosit cu un obiect de g. În plus, rețineți că suportul unghiular
citatele nu ar trebui să facă parte din s. Acestea vor fi adăugate dacă g este scris în DOT beton
format.

ishtml(s : şir): int
returnează diferit de zero dacă și numai dacă s este un șir HTML.

xOf(s : şir): şir
returnează șirul "x" dacă s are forma "x,y", unde ambele x și y sunt numerice.

yOf(s : şir): şir
returnează șirul "y" dacă s are forma "x,y", unde ambele x și y sunt numerice.

llOf(s : şir): şir
returnează șirul "llx,lly" dacă s are forma "llx,lly,urx,Ury", unde toate llx,
lly, urx, și Ury sunt numerice.

urOf(s)
urOf(s : şir): şir returnează șirul "urx,Ury" dacă s are forma
"llx,lly,urx,Ury", unde toate llx, lly, urx, și Ury sunt numerice.

sscanf(s : şir, fmt : şir, ...): int
scanează șirul s, extragerea valorilor conform sscanf(3) format fmt.
valorile sunt stocate în adresele de mai jos fmt, adrese având forma &v,
Unde v este o variabilă declarată de tipul corect. Returnează numărul de articole
scanat cu succes.

împărţi(s : şir, arr : mulțime, seps : şir): int

împărţi(s : şir, arr : mulțime): int

jetoane(s : şir, arr : mulțime, seps : şir): int

jetoane(s : şir, arr : mulțime): int
împărţi funcția rupe șirul s în câmpuri, în timp ce jetoane funcţie
rupe sfoara în jetoane. Un câmp este format din toate caracterele care nu sunt separatoare
între două caractere separatoare sau începutul sau sfârșitul șirului. Astfel, a
câmpul poate fi șirul gol. Un token este un subșir maxim, non-vid, nu
conţinând un caracter separator. Caracterele separatoare sunt cele date în
seps argument. Dacă seps nu este furnizată, valoarea implicită este „ \t\n”. The
funcțiile returnează numărul de câmpuri sau jetoane.

Câmpurile și tokenurile sunt stocate în matricea de argumente. Matricea trebuie să fie şir-
valorizat și, dacă este specificat un tip de index, acesta trebuie să fie int. Intrările sunt indexate
prin numere întregi consecutive, începând cu 0. Orice valori deja stocate în matrice vor
fie suprascris, fie încă prezent după revenirea funcției.

I / O
imprima(...): anula
imprimare( expres, ... ) afișează o reprezentare șir a fiecărui argument pe rând
stdout, urmată de o nouă linie.

printf(fmt : şir, ...): int

printf(fd : int, fmt : şir, ...): int
tipărește șirul rezultat din formatarea valorilor expresiilor care urmează
fmt in conformitate cu printf(3) format fmt. Returnează 0 la succes. În mod implicit, acesta
imprimă pe stdout. Dacă numărul întreg opțional fd este dat, ieșirea este scrisă pe
flux deschis asociat cu fd.

scanf(fmt : şir, ...): int

scanf(fd : int, fmt : şir, ...): int
scanează valorile dintr-un flux de intrare în conformitate cu scanf(3) format fmt.
valorile sunt stocate în adresele de mai jos fmt, adrese având forma &v,
Unde v este o variabilă declarată de tipul corect. În mod implicit, se citește din
stdin. Dacă numărul întreg opțional fd este dat, intrarea este citită din fluxul deschis
asociat cu fd. Returnează numărul de articole scanate cu succes.

deschideF(s : şir, t : şir): int
deschide fișierul s ca flux I/O. Argumentul șir t specifică cum este fișierul
deschis. Argumentele sunt aceleași ca pentru funcția C deschis(3). Se întoarce un
întreg care denotă fluxul sau -1 în caz de eroare.

Ca de obicei, fluxurile 0, 1 și 2 sunt deja deschise ca stdin, stdout, și stderr,
respectiv. De cand gvpr poate folosi stdin pentru a citi graficele de intrare, utilizatorul ar trebui
evitați utilizarea acestui flux.

aproapeF(fd : int): int
închide fluxul deschis notat cu numărul întreg fd. Fluxurile 0, 1 și 2 nu pot fi
închis. Returnează 0 la succes.

citesteL(fd : int): şir
returnează următoarea linie citită din fluxul de intrare fd. Returnează șirul gol „”
la sfârşitul dosarului. Rețineți că caracterul newline este lăsat în șirul returnat.

matematica
exp(d : dubla): dubla
întoarce e la dputerea.

log(d : dubla): dubla
returnează jurnalul natural al d.

sqrt(d : dubla): dubla
returnează rădăcina pătrată a dublului d.

pow(d : dubla, x : dubla): dubla
Returnează d ridicat la xputerea.

cos(d : dubla): dubla
returnează cosinusul lui d.

păcat(d : dubla): dubla
returnează sinusul lui d.

atan2(y : dubla, x : dubla): dubla
returnează arctangenta lui a / x în intervalul -pi la pi.

MIN(y : dubla, x : dubla): dubla
returnează minimul de y și x.

MAX(y : dubla, x : dubla): dubla
returnează maximul de y și x.

Asociativ Arrays
# arr : int
returnează numărul de elemente din matrice arr.

IDX in arr : int
returnează 1 dacă a fost setată o valoare pentru index IDX în matrice arr. Se întoarce 0
in caz contrar.

dezactivat(v : mulțime, IDX): int
elimină elementul indexat de IDX. Returnează 1 dacă elementul a existat, 0 în caz contrar.

dezactivat(v : mulțime): anula
reinițializează matricea.

Diverse
ieşire(v : int): anula
cauze gvpr pentru a ieși cu codul de ieșire v.

sistem(cmd : şir): int
oferă funcția C standard sistem(3). Se execută cmd în shell-ul utilizatorului
mediu și returnează starea de ieșire a shell-ului.

rand(): dubla
returnează un dublu pseudo-aleatoriu între 0 și 1.

srand(): int

srand(v : int): int
setează o sămânță pentru generatorul de numere aleatoare. Argumentul opțional dă sămânța;
dacă este omis, se utilizează ora curentă. Valoarea anterioară de semințe este returnată.
srand ar trebui sunat înainte de orice apel către rand.

colorx(culoare : şir, fmt : şir): şir
traduce o culoare dintr-un format în altul. The culoare argumentul ar trebui să fie o culoare
într-una dintre reprezentările de șir recunoscute. The fmt valoarea ar trebui să fie una dintre
„RGB”, „RGBA”, „HSV” sau „HSVA”. Un șir gol este returnat în caz de eroare.

INCORPORAT VARIABILE

gvpr furnizează anumite variabile speciale, încorporate, ale căror valori sunt setate automat de
gvpr in functie de context. Cu excepția cazurilor menționate, utilizatorul nu își poate modifica valorile.

$ : obj_t
denotă obiectul curent (nod, muchie, grafic) în funcție de context. Nu este
disponibil in ÎNCEPE or Sfârşit clauze.

$F : şir
este numele fișierului de intrare curent.

$G : graph_t
indică graficul curent procesat. Nu este disponibil în ÎNCEPE or Sfârşit
clauze.

$NG : graph_t
indică următorul grafic care trebuie procesat. Dacă $NG este NULL, graficul curent $G este
ultimul grafic. Rețineți că dacă intrarea vine de la stdin, ultimul grafic nu poate fi
determinată până când conducta de intrare este închisă. Nu este disponibil în ÎNCEPE or Sfârşit
clauze, sau dacă -n este folosit steag.

$O : graph_t
denotă graficul de ieșire. Înainte de parcurgerea graficului, acesta este inițializat la țintă
grafic. După traversare și orice END_G acțiuni, dacă se referă la un grafic nevid,
acel grafic este imprimat pe fluxul de ieșire. Este valabil doar în N, E și END_G
clauze. Graficul de ieșire poate fi setat de utilizator.

$T : graph_t
denotă graficul țintă curent. Este un subgraf al $G și este disponibil doar în
N, E și END_G clauze.

$tgtname : şir
denotă numele graficului țintă. În mod implicit, este setat la „gvpr_result”. Dacă
utilizat de mai multe ori în timpul execuției gvpr, numele va fi adăugat cu un
întreg. Această variabilă poate fi setată de utilizator.

$tvroot : node_t
indică nodul de pornire pentru un (direcționat sau nedirecționat) adâncime-în primul rând sau lățime-
prima parcurgere a graficului (cf. $tvtype de mai jos). Valoarea implicită este NULL pentru
fiecare grafic de intrare. După parcurgerea la rădăcina dată, dacă valoarea lui $tvroot
s-a schimbat, o nouă traversare va începe cu noua valoare a $tvroot. De asemenea, setați
$tvnext de mai jos.

$tvnext : node_t
indică următorul nod de pornire pentru o adâncime (direcționată sau nedirecționată) mai întâi sau
parcurgerea graficului pe lățimea întâi (cf. $tvtype de mai jos). Dacă se termină o traversare
si $tvroot nu a fost resetat, dar $tvnext a fost setat, dar nu a fost folosit, aceasta
nodul va fi folosit ca următoarea alegere pentru $tvroot. Valoarea implicită este NULL pentru
fiecare grafic de intrare.

$tvedge : edge_t
Pentru traversările BFS și DFS, aceasta este setată la marginea folosită pentru a ajunge la curent
nod sau margine. La începutul unei traversări sau pentru alte tipuri de traversări,
valoarea este NULL.

$tvtype : tvtype_t
indică cum gvpr parcurge un grafic. Poate lua doar una dintre valorile constante
cu prefixul „TV_” descris mai jos. TV_flat este implicit.

În biblioteca de grafice de bază cgraf(3), muchiile din graficele nedirecționate sunt date an
direcție arbitrară. Acesta este folosit pentru traversări, cum ar fi TV_fwd, necesită
marginile dirijate.

ARGC : int
denotă numărul de argumente specificat de -a args argument din linia de comandă.

ARGV : şir mulțime
denotă matricea de argumente specificată de -a args argument din linia de comandă. The
iargumentul este dat de ARGV[i].

INCORPORAT CONSTANTE

Există mai multe constante simbolice definite de gvpr.

NULL : obj_t
o referință de obiect nulă, echivalentă cu 0.

TV_flat : tvtype_t
o traversare simplă, plată, cu obiecte grafic vizitate în ordine aparent arbitrară.

TV_ne : tvtype_t
o traversare care vizitează mai întâi toate nodurile, apoi toate marginile.

TV_en : tvtype_t
o traversare care vizitează mai întâi toate marginile, apoi toate nodurile.

TV_dfs : tvtype_t
TV_postdfs : tvtype_t
TV_prepostdfs : tvtype_t
o parcurgere a graficului folosind o căutare în profunzime pe baza nedirecționată
grafic. Pentru a face traversarea, gvpr va verifica valoarea lui $tvroot. Dacă aceasta are
aceeași valoare pe care a avut-o anterior (la început, valoarea anterioară este inițializată
la NULL.), gvpr va căuta pur și simplu un nod nevizitat și va traversa conectat
componenta. Pe de altă parte, dacă $tvroot s-a schimbat, componenta sa conectată se va schimba
să fie vizitat, presupunând că nu a fost vizitat anterior sau, dacă $tvroot is NULL,
traversarea se va opri. Rețineți că folosind TV_dfs și $tvroot, este posibil să se creeze
o buclă infinită.

În mod implicit, traversarea se face în precomanda. Adică un nod este vizitat înainte
toate marginile sale nevizitate. Pentru TV_postdfs, toate marginile nevizitate ale unui nod sunt
vizitat înaintea nodului. Pentru TV_prepostdfs, un nod este vizitat de două ori, înainte și
după toate marginile sale nevizitate.

TV_fwd : tvtype_t
TV_postfwd : tvtype_t
TV_prepostfwd : tvtype_t
O parcurgere a graficului folosind o căutare în profunzime numai pe graficul care urmează
arcuri înainte. Alegerea rădăcinilor pentru traversare este aceeași cu cea descrisă pentru
TV_dfs de mai sus. Ordinea diferită de vizitare specificată de TV_fwd, TV_postfwd
și TV_prepostfwd sunt aceleaşi cu cele specificate de traversările analoge
TV_dfs, TV_postdfs și TV_prepostdfs.

TV_rev : tvtype_t
TV_postrev : tvtype_t
TV_prepostrev : tvtype_t
O parcurgere a graficului folosind o căutare în profunzime numai pe graficul care urmează
arcuri inverse. Alegerea rădăcinilor pentru traversare este aceeași cu cea descrisă pentru
TV_dfs de mai sus. Ordinea diferită de vizitare specificată de TV_rev, TV_postrev
și TV_prepostrev sunt aceleaşi cu cele specificate de traversările analoge
TV_dfs, TV_postdfs și TV_prepostdfs.

TV_bfs : tvtype_t
O parcurgere a graficului folosind o căutare pe lățimea întâi pe grafic ignorând muchia
directii. Vezi articolul de pe TV_dfs mai sus pentru rolul de $tvroot.

EXEMPLE

gvpr -i „N[color=="albastru"]” fişier.gv

Generați subgraful indus de noduri pentru toate nodurile cu culoarea albastră.

gvpr -c 'N[color=="albastru"]{culoare = "roșu"}' fişier.gv

Faceți toate nodurile albastre roșii.

ÎNCEPE { int n, e; int tot_n = 0; int tot_e = 0; }
BEG_G {
n = nNoduri($G);
e = nEdges($G);
printf ("%d noduri %d margini %s\n", n, e, $G.nume);
tot_n += n;
tot_e += e;
}
Sfârşit { printf ("%d noduri %d margini total\n", tot_n, tot_e) }

Versiunea programului gc.

gvpr -c ""

Echivalentă cu NOP.

BEG_G { graph_t g = grafic ("combina", „S”); }
E {
node_t h = clona(g,$.head);
node_t t = clona(g,$.tail);
edge_t e = marginea (t,h,"");
e.greutate = e.greutate + 1;
}
END_G { $O = g; }

Produce o versiune strictă a graficului de intrare, unde atributul de greutate al unei muchii
indică câte muchii din graficul de intrare reprezintă muchia.

ÎNCEPE {node_t n; int grade[]}
E{grad[cap]++; deg[coada]++; }
END_G {
pentru (grad[n]) {
printf ("grad[%s] = %d\n", n.nume, deg[n]);
}
}

Calculează gradele nodurilor cu muchii.

ÎNCEPE {
int i, indentare;
int văzut[șir];
anula prInd (int cnt) {
pentru (i = 0; i < cnt; i++) printf (" ");
}
}
BEG_G {

$tvtype = TV_prepostfwd;
$tvroot = nod($,ARGV[0]);
}
N {
if (văzut[$.name]) indentare--;
altfel {
prInd(indent);
imprima ($.nume);
văzut[$.name] = 1;
indent++;
}
}

Imprimă parcurgerea în adâncime a graficului, începând cu nodul al cărui nume este
ARGV[0], ca o listă indentată.

MEDIUL

GVPRPATH
Listă de directoare separate prin două puncte de căutat pentru a găsi fișierul specificat de
opțiunea -f. gvpr are o listă implicită încorporată. Dacă GVPRPATH nu este definit, cel
este folosită lista implicită. Dacă GVPRPATH începe cu două puncte, lista este formată din
alăturarea GVPRPATH la lista implicită. Dacă GVPRPATH se termină cu două puncte, lista este
format prin adăugarea listei implicite la GVPRPATH. In caz contrar, GVPRPATH este folosit pentru
lista.

Pe sistemele Windows, înlocuiți „colon” ​​cu „punct și virgulă” în paragraful anterior.

Utilizați gvpr online folosind serviciile onworks.net