gvpr - En ligne dans le Cloud

PROGRAMME:

Nom

gvpr - langage d'analyse et de traitement des modèles de graphe

SYNOPSIS

gvpr [-icnqV ?] [ -o fichier de sortie ] [ -a args ] [ 'programme' | -f profil ] [ fichiers ]

DESCRIPTION

gvpr (Anciennement connu sous le nom gpr) est un éditeur de flux de graphes inspiré de awk. Il copie l'entrée
graphiques à sa sortie, en transformant éventuellement leur structure et leurs attributs, en créant de nouveaux
graphiques, ou l'impression d'informations arbitraires. Le modèle de graphe est celui fourni par
libcgraphe(3). En particulier, gvpr lit et écrit des graphiques en utilisant le langage à points.

En gros, gvpr parcourt chaque graphique d'entrée, noté par $G, visitant chaque nœud et arête,
en le faisant correspondre avec les règles de prédicat-action fournies dans le programme d'entrée. Les règles sont
évalués dans l'ordre. Pour chaque prédicat évalué à vrai, l'action correspondante est
effectué. Au cours de la traversée, le nœud ou l'arête actuellement visité est indiqué par $.

Pour chaque graphe d'entrée, il existe un sous-graphe cible, désigné par $T, initialement vide et utilisé
pour cumuler les entités choisies, et un graphe de sortie, $O, utilisé pour le traitement final, puis
écrit en sortie. Par défaut, le graphe de sortie est le graphe cible. Le graphique de sortie
peut être défini dans le programme ou, dans un sens limité, sur la ligne de commande.

OPTIONS

Les options suivantes sont prises en charge :

-a args
La corde args est divisé en jetons séparés par des espaces, avec l'individu
jetons disponibles sous forme de chaînes dans le gvpr programme comme ARGV[0],...,ARGV[ARGC-1].
Caractères d'espacement dans des sous-chaînes entre guillemets simples ou doubles, ou précédés d'un
barre oblique inverse, sont ignorés en tant que séparateurs. En général, une barre oblique inverse s'éteint
toute signification particulière du caractère suivant. Notez que les jetons dérivés de
plusieurs -a les drapeaux sont concaténés.

-c Utilisez le graphique source comme graphique de sortie.

-i Dériver l'extension de sous-graphe induite par les nœuds du graphe de sortie dans le contexte de
son graphe racine.

-o fichier de sortie
Provoque l'écriture du flux de sortie dans le fichier spécifié ; par défaut, la sortie est
écrite à Stdout.

-f profil
Utilisez le contenu du fichier spécifié comme programme à exécuter sur l'entrée. Si
profil contient une barre oblique, le nom est pris comme chemin d'accès du fichier.
Dans le cas contraire, gvpr utilisera les répertoires spécifiés dans la variable d'environnement
GVPRPATH pour rechercher le fichier. Si -f n'est pas donné, gvpr utilisera le premier non‐
argument d'option en tant que programme.

-q Désactive les messages d'avertissement.

-n Désactive la lecture anticipée du graphique. Par défaut, la variable $NG est réglé sur le graphique suivant
à traiter. Cela nécessite une lecture du graphique suivant avant de traiter le
graphique actuel, qui peut se bloquer si le graphique suivant n'est généré qu'en réponse à
une action relative au traitement du graphe courant.

-V Le programme imprime les informations de version et se ferme.

-? Le programme imprime les informations d'utilisation et se ferme.

OPÉRANDES

L'opérande suivant est pris en charge :

fichiers Noms des fichiers contenant 1 ou plusieurs graphiques en langage à points. Sinon -f option
est donné, le prénom est supprimé de la liste et utilisé comme programme d'entrée.
Si la liste des fichiers est vide, Stdin sera utilisé.

PROGRAMMES

A gvpr programme se compose d'une liste de clauses prédicat-action, ayant l'une des formes :

COMMENCER { action }

BEG_G { action }

N [ prédicat ] { action }

E [ prédicat ] { action }

FIN_G { action }

FIN { action }

Un programme peut contenir au plus un de chacun des COMMENCER, FIN_G et FIN clauses. Il peut
être un nombre quelconque de BEG_G, N et E énoncés, le premier appliqué aux graphiques, le second aux
nœuds, le troisième aux bords. Ceux-ci sont séparés en blocs, un bloc constitué d'un
optionnel BEG_G déclaration et tout N et E déclarations jusqu'à la prochaine BEG_G déclaration, si
tout. La sémantique de haut niveau d'un gvpr programme sont:

Évaluer le COMMENCER clause, le cas échéant.
Pour chaque graphique d'entrée G {
Pour chaque bloc {
Ensemble G comme le graphe courant et l'objet courant.
Évaluer le BEG_G clause, le cas échéant.
Pour chaque nœud et arête dans G {
Définissez le nœud ou l'arête comme objet courant.
Évaluer le N or E clauses, le cas échéant.
}
}
Ensemble G comme objet courant.
Évaluer le FIN_G clause, le cas échéant.
}
Évaluer le FIN clause, le cas échéant.

Les actes de la COMMENCER, BEG_G, FIN_G et FIN les clauses sont exécutées lorsque les clauses sont
évalué. Pour N or E clauses, le prédicat ou l'action peuvent être omis. S'il y a
n'est pas un prédicat avec une action, l'action est effectuée sur chaque nœud ou bord, comme
approprié. S'il n'y a pas d'action et que le prédicat est évalué à vrai, le
un nœud ou une arête est ajouté au graphe cible.

Les blocs sont évalués dans l'ordre dans lequel ils apparaissent. Dans un bloc, le N clauses
(E clauses, respectivement) sont évalués dans l'ordre dans lequel se produisent. Notez, cependant,
que dans un bloc, N or E Les clauses peuvent être entrelacées, selon l'ordre de parcours.

Les prédicats et les actions sont des séquences d'instructions dans le dialecte C pris en charge par le
expr(3) bibliothèque. La seule différence entre les prédicats et les actions est que les premiers
doit avoir un type qui peut être interprété comme vrai ou faux. Ici le C habituel
convention est suivie, dans laquelle une valeur non nulle est considérée comme vraie. Cela comprendrait
des chaînes non vides et des références non vides à des nœuds, des arêtes, etc. Cependant, si une chaîne peut
être converti en un entier, cette valeur est utilisée.

En plus des types de base C habituels (annuler, int, carboniser, flotter, Long, non signé et double),
gvpr fournit un magnifique comme synonyme de carboniser*, et les types basés sur les graphes nœud_t, bord_t,
graph_t et obj_tL’ obj_t type peut être considéré comme un supertype des 3 autres béton
les types; le type de base correct est maintenu dynamiquement. Outre ces types de base, le
seules les autres expressions de type prises en charge sont des tableaux (associatifs).

Les constantes suivent la syntaxe C, mais les chaînes peuvent être entre guillemets "..." or '...'. gvpr
accepte les commentaires C++ ainsi que les commentaires de type cpp. Pour ce dernier, si une ligne commence par
un caractère '#', le reste de la ligne est ignoré.

Une instruction peut être la déclaration d'une fonction, d'une variable ou d'un tableau, ou d'un exécutable
déclaration. Pour les déclarations, il existe une seule portée. Les déclarations de tableau ont la forme :

type tableau [ type0 ]

De type0 est facultatif. S'il est fourni, l'analyseur fera en sorte que tous les tableaux
les indices ont le type spécifié. S'il n'est pas fourni, des objets de tous types peuvent être
utilisés comme indices. Comme en C, les variables et les tableaux doivent être déclarés. En particulier, un
variable non déclarée sera interprétée comme le nom d'un attribut d'un nœud, d'une arête ou
graphique, selon le contexte.

Les instructions exécutables peuvent être l'une des suivantes :

{ [ déclaration ] }
expression // communément var = expression
si ( expression ) déclaration [ d'autre déclaration ]
pour ( expression ; expression ; expression ) déclaration
pour ( tableau [ var ]) déclaration
pour( tableau [ var ]) déclaration
tandis que ( expression ) déclaration
commutateur ( expression ) maisons déclarations
pause [ expression ]
continuer [ expression ]
retourner [ expression ]
Les éléments entre parenthèses sont facultatifs.

Dans la deuxième forme du en déclaration et le pour instruction, la variable var est fixé à
chaque valeur utilisée comme index dans le tableau spécifié, puis la valeur associée déclaration is
évalué. Pour les indices numériques et de chaîne, les indices sont renvoyés par ordre croissant
ordre numérique ou lexicographique (décroissant) pour en (pour, respectivement). Cela peut être utilisé
pour le tri.

Les définitions de fonction ne peuvent apparaître que dans le COMMENCER clause.

Les expressions incluent les expressions C habituelles. Comparaisons de chaînes à l'aide == et != traiter le
opérande de droite comme modèle dans le but de faire correspondre les expressions régulières. Motifs
utilisé ksh(1) syntaxe du modèle de correspondance de fichier. (Pour une égalité de chaîne simple, utilisez le strcmp
la fonction.

gvpr tentera d'utiliser une expression en tant que chaîne ou valeur numérique, selon le cas. Les deux
Les conversions de type C et les modèles de fonctions entraîneront l'exécution de conversions, si possible.

Expressions de type graphique (c'est-à-dire, graph_t, nœud_t, bord_t, obj_t) peut être suivi d'un
référence de terrain sous la forme de .prénom. La valeur résultante est la valeur de l'attribut
nommé prénom de l'objet donné. De plus, dans certains contextes, un non-déclaré,
l'identifiant non modifié est considéré comme un nom d'attribut. Plus précisément, de tels identifiants
désignent les attributs du nœud ou de l'arête actuel, respectivement, dans N et E clauses, et le
graphique actuel dans BEG_G et FIN_G clauses.

Comme d'habitude dans le libcgraphe(3) modèle, les attributs sont des valeurs de chaîne. En outre, gvpr
prend en charge certains pseudo-attributs d'objets graphiques, pas nécessairement une valeur de chaîne. Ces
reflètent les propriétés intrinsèques des objets graphiques et ne peuvent pas être définis par l'utilisateur.

front : nœud_t
la tête d'un bord.

queue : nœud_t
la queue d'un bord.

prénom : un magnifique
le nom d'une arête, d'un nœud ou d'un graphe. Le nom d'une arête a la forme "<tail‐
nom>[]", où est "->"Ou"--" cela dépend de
que le graphe soit orienté ou non. La partie support [] n'apparaît que si le
edge a une clé non triviale.

degré : int
le degré d'un nœud.

degré supérieur : int
le degré extérieur d'un nœud.

intensité : int
le degré d'un nœud.

racine : graph_t
le graphe racine d'un objet. La racine d'un graphe racine est elle-même.

mère : graph_t
le graphe parent d'un sous-graphe. Le parent d'un graphe racine est NULL

n_bords : int
le nombre d'arêtes du graphique

n_nœuds : int
le nombre de nœuds dans le graphe

dirigé : int
vrai (non nul) si le graphe est orienté

strict : int
vrai (non nul) si le graphe est strict

INTÉGRÉ FONCTIONS

Les fonctions suivantes sont intégrées dans gvpr. Ces fonctions renvoyant des références au graphe
les objets retournent NULL en cas de défaillance.

Graphiques et sous-graphique
graphique(s : un magnifique, t : un magnifique): graph_t
crée un graphique dont le nom est s et dont le type est spécifié par la chaîne t.
Ignorant la casse, les personnages U, D, S, N avoir l'interprétation non dirigée,
respectivement dirigé, strict et non strict. Si t est vide, un orienté, non‐
graphe strict est généré.

sous-g(g : graph_t, s : un magnifique): graph_t
crée un sous-graphe dans le graphique g avec nom s. Si le sous-graphe existe déjà, il est
revenu.

estSubg(g : graph_t, s : un magnifique): graph_t
renvoie le sous-graphe dans le graphique g avec nom s, s'il existe, ou NULL autrement.

fstsubg(g : graph_t): graph_t
renvoie le premier sous-graphe du graphique gou NULL si aucun n'existe.

nxtsubg(sg : graph_t): graph_t
renvoie le sous-graphe suivant après sgou NULL.

estDirect(g : graph_t): int
renvoie vrai si et seulement si g est dirigé.

estStrict(g : graph_t): int
renvoie vrai si et seulement si g est strict.

nNoeuds(g : graph_t): int
renvoie le nombre de nœuds dans g.

bords(g : graph_t): int
renvoie le nombre d'arêtes dans g.

Nodes
nœud(sg : graph_t, s : un magnifique): nœud_t
crée un nœud dans le graphe g de nom s. Si un tel nœud existe déjà, il est renvoyé.

sous-nœud(sg : graph_t, n : nœud_t): nœud_t
insère le nœud n dans le sous-graphe g. Renvoie le nœud.

noeud fst(g : graph_t): nœud_t
renvoie le premier nœud du graphe gou NULL si aucun n'existe.

nœud nxt(n : nœud_t): nœud_t
renvoie le nœud suivant après n dans le graphe racine, ou NULL.

nxtnode_sg(sg : graph_t, n : nœud_t): nœud_t
renvoie le nœud suivant après n in sgou NULL.

estNoeud(sg : graph_t, s : un magnifique): nœud_t
recherche un nœud dans le (sous-)graphe sg de nom s. Si un tel nœud existe, il est renvoyé.
Dans le cas contraire, NULL Est retourné.

estSous-noeud(sg : graph_t, n : nœud_t): int
renvoie non nul si nœud n est dans le (sous-)graphe sg, ou zéro sinon.

degréDe(sg : graph_t, n : nœud_t): int
renvoie le degré du nœud n dans (sous)graphique sg.

degrédehors(sg : graph_t, n : nœud_t): int
renvoie le degré extérieur du nœud n dans (sous)graphique sg.

diplôme de(sg : graph_t, n : nœud_t): int
renvoie le degré du nœud n dans (sous)graphique sg.

Bords
bord(t : nœud_t, h : nœud_t, s : un magnifique): bord_t
crée une arête avec un nœud de queue t, nœud principal h et nom s dans le graphe racine. Si la
graphique n'est pas orienté, la distinction entre les nœuds de tête et de queue est sans importance.
Si une telle arête existe déjà, elle est renvoyée.

bord_sg(sg : graph_t, t : nœud_t, h : nœud_t, s : un magnifique): bord_t
crée une arête avec un nœud de queue t, nœud principal h et nom s dans (sous)graphique sg (et tout
graphiques parents). Si le graphe n'est pas orienté, la distinction entre la tête et la queue
nœuds est sans importance. Si une telle arête existe déjà, elle est renvoyée.

submerger(g : graph_t, e : bord_t): bord_t
insère le bord e dans le sous-graphe g. Renvoie le bord.

estBord(t : nœud_t, h : nœud_t, s : un magnifique): bord_t
cherche une arête avec un nœud de queue t, nœud principal h et nom s. Si le graphique est
non dirigée, la distinction entre les nœuds de tête et de queue est sans importance. Si un tel
edge existe, il est renvoyé. Autrement, NULL Est retourné.

isEdge_sg(sg : graph_t, t : nœud_t, h : nœud_t, s : un magnifique): bord_t
cherche une arête avec un nœud de queue t, nœud principal h et nom s dans (sous)graphique sg. Si l'
graphique n'est pas orienté, la distinction entre les nœuds de tête et de queue est sans importance.
Si une telle arête existe, elle est renvoyée. Autrement, NULL Est retourné.

estSubedge(g : graph_t, e : bord_t): int
renvoie non nul si bord e est dans le (sous-)graphe sg, ou zéro sinon.

fstout(n : nœud_t): bord_t
renvoie le premier bord du nœud n dans le graphe racine.

fstout_sg(sg : graph_t, n : nœud_t): bord_t
renvoie le premier bord du nœud n dans (sous)graphique sg.

nxtout(e : bord_t): bord_t
renvoie le prochain outedge après e dans le graphe racine.

nxtout_sg(sg : graph_t, e : bord_t): bord_t
renvoie le prochain outedge après e dans le graphique sg.

fstin(n : nœud_t): bord_t
renvoie le premier bord du nœud n dans le graphe racine.

fstin_sg(sg : graph_t, n : nœud_t): bord_t
renvoie le premier bord du nœud n dans le graphique sg.

nxtine(e : bord_t): bord_t
renvoie le prochain inedge après e dans le graphe racine.

nxtin_sg(sg : graph_t, e : bord_t): bord_t
renvoie le prochain inedge après e dans le graphique sg.

fstedge(n : nœud_t): bord_t
renvoie le premier bord du nœud n dans le graphe racine.

fstedge_sg(sg : graph_t, n : nœud_t): bord_t
renvoie le premier bord du nœud n dans le graphique sg.

nxtedge(e : bord_t, nœud_t): bord_t
renvoie l'arête suivante après e dans le graphe racine.

nxtedge_sg(sg : graph_t, e : bord_t, nœud_t): bord_t
renvoie l'arête suivante après e dans le graphique sg.

sup(e : bord_t, nœud_t): nœud_t
renvoie le nœud sur le bord e pas égal à n. Renvoie NULL si n n'est pas un nœud de
e. Cela peut être utile lors de l'utilisation fstedge et nxtedge énumérer les voisins de
n.

Graphique I / O
écrire(g : graph_t): annuler
impressions g au format point sur le flux de sortie.

écrireG(g : graph_t, fnom : un magnifique): annuler
impressions g au format point dans le fichier fnom.

fécrireG(g : graph_t, fd : int): annuler
impressions g au format point sur le flux ouvert désigné par l'entier fd.

lireG(fnom : un magnifique): graph_t
renvoie un graphe lu à partir du fichier fnom. Le graphique doit être au format point. Sinon
le graphique peut être lu, NULL Est retourné.

freadG(fd : int): graph_t
renvoie le prochain graphique lu à partir du flux ouvert fd. Retour NULL à la fin du fichier.

Graphique recueil
effacer(g : graph_t, x : obj_t): annuler
supprime l'objet x du graphique g. Si g is NULL, la fonction utilise le graphe racine de
x. Si x est un graphe ou un sous-graphe, il est fermé à moins que x est verrouillé.

est dans(g : graph_t, x : obj_t): int
renvoie vrai si x est dans le sous-graphe g.

cloneG(g : graph_t, s : un magnifique): graph_t
crée un clone de graphe g avec le nom de s. Si s est "", le graphe créé a le
même nom que g.

cloner(g : graph_t, x : obj_t): obj_t
crée un clone d'objet x dans le graphique g. En particulier, le nouvel objet a le même
attributs nom/valeur et structure en tant qu'objet d'origine. Si un objet avec le
même clé que x existe déjà, ses attributs se superposent à ceux de x et par
l'objet est renvoyé. Si une arête est clonée, les deux points de terminaison sont implicitement clonés.
Si un graphe est cloné, tous les nœuds, arêtes et sous-graphes sont implicitement clonés. Si x
est un graphique, g peut être NULL, auquel cas l'objet cloné sera une nouvelle racine
graphique. Dans ce cas, l'appel équivaut à cloneG(x,"").

copier(g : graph_t, x : obj_t): obj_t
crée une copie de l'objet x dans le graphique g, où le nouvel objet a le même nom/valeur
attributs comme l'objet d'origine. Si un objet avec la même clé que x déjà
existe, ses attributs sont superposés à ceux de x et l'objet est renvoyé. Noter
qu'il s'agit d'une copie superficielle. Si x est un graphe, aucun de ses nœuds, arêtes ou sous-graphes
sont copiés dans le nouveau graphique. Si x est une arête, les extrémités sont créées si
nécessaire, mais ils ne sont pas clonés. Si x est un graphique, g peut être NULL, dans quel cas
l'objet cloné sera un nouveau graphe racine.

copieA(src : obj_t, tgt : obj_t): int
copie les attributs de l'objet src s'opposer tgt, en écrasant toutes les valeurs d'attribut
tgt peut avoir initialement.

induire(g : graph_t): annuler
S'étend g à son extension de sous-graphe induite par les nœuds dans son graphe racine.

aAttr(src : obj_t, prénom : un magnifique): int
renvoie non nul si objet src a un attribut dont le nom est prénom. Il renvoie 0
autrement.

estAttr(g : graph_t, genre : un magnifique, prénom : un magnifique): int
renvoie non nul si un attribut prénom a été défini dans g pour les objets de la
donné genre. Pour les nœuds, les arêtes et les graphiques, genre devrait être "N", "E" et "G",
respectivement. Il renvoie 0 sinon.

âge(src : obj_t, prénom : un magnifique): un magnifique
renvoie la valeur de l'attribut prénom dans l'objet src. Ceci est utile pour ces cas
quand prénom entre en conflit avec l'un des mots-clés tels que "head" ou "root". Si la
attribut n'a pas été déclaré dans le graphe, la fonction l'initialisera avec
une valeur par défaut de "". Pour éviter cela, il faut utiliser le aAttr or estAttr fonction
pour vérifier que l'attribut existe.

ASET(src : obj_t, prénom : un magnifique, Plus-value : un magnifique): int
définit la valeur de l'attribut prénom dans l'objet src à Plus-value. Renvoie 0 en cas de succès,
non nul en cas d'échec. Voir âge au dessus.

obtenirDflt(g : graph_t, genre : un magnifique, prénom : un magnifique): un magnifique
renvoie la valeur par défaut de l'attribut prénom dans les objets dans g du donné genre. For
nœuds, arêtes et graphes, genre devrait être "N", "E" et "G", respectivement. Si la
attribut n'a pas été déclaré dans le graphe, la fonction l'initialisera avec
une valeur par défaut de "". Pour éviter cela, il faut utiliser le estAttr fonction à vérifier
que l'attribut existe.

setDflt(g : graph_t, genre : un magnifique, prénom : un magnifique, Plus-value : un magnifique): int
définit la valeur par défaut de l'attribut prénom à Plus-value dans les objets dans g du donné
genre. Pour les nœuds, les arêtes et les graphiques, genre devrait être "N", "E" et "G", respectivement.
Renvoie 0 en cas de succès, différent de zéro en cas d'échec. Voir obtenirDflt au dessus.

fstAttr(g : graph_t, genre : un magnifique): un magnifique
renvoie le nom du premier attribut des objets dans g du donné genre. For
nœuds, arêtes et graphes, genre devrait être "N", "E" et "G", respectivement. S'il y a
n'y a pas d'attributs, la chaîne "" est renvoyée.

nxtAttr(g : graph_t, genre : un magnifique, prénom : un magnifique): un magnifique
renvoie le nom du prochain attribut des objets dans g du donné genre après le
attribuer prénom. L'argument prénom doit être le nom d'un attribut existant ; ce
sera généralement la valeur de retour d'un appel précédent à fstAttr or nxtAttr. For
nœuds, arêtes et graphes, genre devrait être "N", "E" et "G", respectivement. S'il y a
n'y a plus d'attributs, la chaîne "" est renvoyée.

composition(g : graph_t, n : nœud_t): graph_t
renvoie la composante connexe du graphe g nœud contenant n, en tant que sous-graphe de
g. Le sous-graphe ne contient que les nœuds. On peut utiliser induire pour ajouter les bords. Les
la fonction échoue et retourne NULL if n n'est pas dans g. La connectivité est basée sur le
graphe non orienté sous-jacent de g.

type de(obj : obj_t): un magnifique
renvoie une indication du type de obj. Pour les nœuds, les arêtes et les graphiques, il renvoie
"N", "E" et "G", respectivement.

bloquer(g : graph_t, v : int): int
implémente le verrouillage de graphe sur les graphes racines. Si l'entier v est positif, le graphique est
réglé de manière à ce que les futurs appels vers effacer n'ont pas d'effet immédiat. Si v est nul, le
le graphique est déverrouillé. S'il y a eu un appel pour supprimer le graphique alors qu'il était
verrouillé, le graphe est fermé. Si v est négatif, rien n'est fait. Dans tous les cas, le
la valeur de verrouillage précédente est renvoyée.

String
sprintf(fmt : un magnifique, ): un magnifique
renvoie la chaîne résultant du formatage des valeurs des expressions
survenant après fmt selon l' printf(3) mise en forme fmt

gsub(str : un magnifique, caresse : un magnifique): un magnifique

gsub(str : un magnifique, caresse : un magnifique, remplacer : un magnifique): un magnifique
Retours str avec toutes les sous-chaînes correspondant caresse supprimé ou remplacé par remplacer,
respectivement.

dessous(str : un magnifique, caresse : un magnifique): un magnifique

dessous(str : un magnifique, caresse : un magnifique, remplacer : un magnifique): un magnifique
Retours str avec la sous-chaîne la plus à gauche correspondant caresse supprimé ou remplacé par remplacer,
respectivement. Les caractères '^' et '$' peuvent être utilisés au début et à la fin,
respectivement, de caresse pour ancrer le motif au début ou à la fin de str.

substr(str : un magnifique, idx : int): un magnifique

substr(str : un magnifique, idx : int, len : int): un magnifique
renvoie la sous-chaîne de str à partir de la position idx à la fin de la chaîne ou
de longueur len, respectivement. L'indexation commence à 0. Si idx est négatif ou idx is
supérieure à la longueur de str, une erreur fatale se produit. De même, dans le deuxième
cas, si len est négatif ou idx + len est supérieure à la longueur de str, un fatal
erreur se produit.

strcmp(s1 : un magnifique, s2 : un magnifique): int
fournit la fonction C standard strcmp (3).

longueur(s : un magnifique): int
renvoie la longueur de la chaîne s.

indice(s : un magnifique, t : un magnifique): int

réindexer(s : un magnifique, t : un magnifique): int
renvoie l'index du caractère dans la chaîne s où la copie la plus à gauche (la plus à droite)
de ficelle t peut être trouvé, ou -1 si t n'est pas une sous-chaîne de s.

rencontre(s : un magnifique, p : un magnifique): int
renvoie l'index du caractère dans la chaîne s où la correspondance la plus à gauche du motif
p peut être trouvé, ou -1 si aucune sous-chaîne de s allumettes p.

toupie(s : un magnifique): un magnifique
renvoie une version de s avec les caractères alphabétiques convertis en majuscules.

baisser(s : un magnifique): un magnifique
renvoie une version de s avec les caractères alphabétiques convertis en minuscules.

canon(s : un magnifique): un magnifique
renvoie une version de s approprié pour être utilisé comme identifiant dans un fichier de points.

html(g : graph_t, s : un magnifique): un magnifique
renvoie une version « magique » de s sous forme de chaîne HTML. Cela sera généralement utilisé pour
attachez une étiquette de type HTML à un objet graphique. Notez que la chaîne renvoyée réside dans
g. En particulier, il sera libéré lorsque g est fermé, et pour agir comme une chaîne HTML,
il doit être utilisé avec un objet de g. De plus, notez que l'équerre
les citations ne doivent pas faire partie de s. Ceux-ci seront ajoutés si g est écrit en DOT concret
le format.

ishtml(s : un magnifique): int
renvoie non nul si et seulement si s est une chaîne HTML.

xDe(s : un magnifique): un magnifique
renvoie la chaîne "x" si s a la forme "x,y", où les deux x et y sont numériques.

yDe(s : un magnifique): un magnifique
renvoie la chaîne "y" si s a la forme "x,y", où les deux x et y sont numériques.

lOf(s : un magnifique): un magnifique
renvoie la chaîne "llx,lly" si s a la forme "llx,lly,urx,ury", où tout llx,
lly, urxet ury sont numériques.

urDe(s)
urDe(s : un magnifique): un magnifique renvoie la chaîne "urx,ury" si s A le formulaire
"llx,lly,urx,ury", où tout llx, lly, urxet ury sont numériques.

scanf(s : un magnifique, fmt : un magnifique, ): int
scanne la chaîne s, extraire des valeurs en fonction de la scanf(3) mise en forme fmtL’
les valeurs sont stockées dans les adresses suivantes fmt, adresses ayant la forme &v,
De v est une variable déclarée du type correct. Renvoie le nombre d'éléments
scanné avec succès.

scission(s : un magnifique, arr : tableau, sep : un magnifique): int

scission(s : un magnifique, arr : tableau): int

tokens(s : un magnifique, arr : tableau, sep : un magnifique): int

tokens(s : un magnifique, arr : tableau): int
La scission la fonction casse la chaîne s dans les champs, tandis que le tokens fonction
divise la chaîne en jetons. Un champ se compose de tous les caractères non séparateurs
entre deux caractères de séparation ou le début ou la fin de la chaîne. Ainsi, un
champ peut être la chaîne vide. Un jeton est une sous-chaîne maximale non vide non
contenant un caractère de séparation. Les caractères de séparation sont ceux donnés dans le
sep argument. Si sep n'est pas fourni, la valeur par défaut est " \t\n". Les
les fonctions renvoient le nombre de champs ou de jetons.

Les champs et les jetons sont stockés dans le tableau d'arguments. Le tableau doit être un magnifique-
valeur et, si un type d'index est spécifié, il doit être int. Les entrées sont indexées
par des entiers consécutifs, en commençant à 0. Toutes les valeurs déjà stockées dans le tableau seront
soit écrasé, soit toujours présent après le retour de la fonction.

I / O
impression( ): annuler
impression( expr, ) imprime une représentation sous forme de chaîne de chaque argument à son tour sur
Stdout, suivi d'une nouvelle ligne.

printf(fmt : un magnifique, ): int

printf(fd : int, fmt : un magnifique, ): int
imprime la chaîne résultant du formatage des valeurs des expressions suivantes
fmt selon l' printf(3) mise en forme fmt. Renvoie 0 en cas de succès. Par défaut, il
imprime sur Stdout. Si l'entier facultatif fd est donné, la sortie est écrite sur le
flux ouvert associé à fd.

scanf(fmt : un magnifique, ): int

scanf(fd : int, fmt : un magnifique, ): int
scanne les valeurs d'un flux d'entrée en fonction de la scanf(3) mise en forme fmtL’
les valeurs sont stockées dans les adresses suivantes fmt, adresses ayant la forme &v,
De v est une variable déclarée du type correct. Par défaut, il lit à partir de
Stdin. Si l'entier facultatif fd est donné, l'entrée est lue à partir du flux ouvert
associé à fd. Renvoie le nombre d'éléments analysés avec succès.

ouvrirF(s : un magnifique, t : un magnifique): int
ouvre le fichier s en tant que flux d'E/S. L'argument chaîne t spécifie comment le fichier est
ouvert. Les arguments sont les mêmes que pour la fonction C ouvrir(3). Il renvoie un
entier désignant le flux, ou -1 en cas d'erreur.

Comme d'habitude, les flux 0, 1 et 2 sont déjà ouverts comme Stdin, Stdoutet stderr,
respectivement. Depuis gvpr peut utiliser Stdin pour lire les graphiques d'entrée, l'utilisateur doit
évitez d'utiliser ce flux.

fermerF(fd : int): int
ferme le flux ouvert désigné par l'entier fd. Les flux 0, 1 et 2 ne peuvent pas être
fermé. Renvoie 0 en cas de succès.

lireL(fd : int): un magnifique
renvoie la ligne suivante lue à partir du flux d'entrée fd. Il renvoie la chaîne vide ""
à la fin du fichier. Notez que le caractère de nouvelle ligne est laissé dans la chaîne renvoyée.

Mathématique
exp(d : double): double
renvoie e au dème puissance.

enregistrer(d : double): double
renvoie le logarithme naturel de d.

sqrt(d : double): double
renvoie la racine carrée du double d.

pow(d : double, x : double): double
Retours d élevé à la xème puissance.

cos(d : double): double
renvoie le cosinus de d.

sans(d : double): double
renvoie le sinus de d.

atan2(y : double, x : double): double
renvoie l'arc tangente de y / x dans la plage -pi à pi.

MIN(y : double, x : double): double
renvoie le minimum de y et x.

MAX(y : double, x : double): double
renvoie le maximum de y et x.

Associatif Arrays
# arr : int
renvoie le nombre d'éléments du tableau arr.

idx in arr : int
renvoie 1 si une valeur a été définie pour l'index idx dans le tableau arr. Il renvoie 0
autrement.

unset(v : tableau, idx): int
supprime l'élément indexé par idx. Il renvoie 1 si l'élément existait, 0 sinon.

unset(v : tableau): annuler
réinitialise le tableau.

Divers
sortie(v : int): annuler
les causes gvpr pour sortir avec le code de sortie v.

combustion propre(cmd : un magnifique): int
fournit la fonction C standard combustion propre(3). Il exécute cmd dans le shell de l'utilisateur
et renvoie l'état de sortie du shell.

rand() : double
renvoie un double pseudo‐aléatoire entre 0 et 1.

sable() : int

sable(v : int): int
définit une graine pour le générateur de nombres aléatoires. L'argument optionnel donne la graine ;
s'il est omis, l'heure actuelle est utilisée. La valeur de départ précédente est renvoyée.
sable doit être appelé avant tout appel à rand.

couleurx(Couleur : un magnifique, fmt : un magnifique): un magnifique
traduit une couleur d'un format à un autre. Les Couleur l'argument doit être une couleur
dans l'une des représentations sous forme de chaîne reconnues. Les fmt la valeur doit être l'une des
« RVB », « RVBA », « HSV » ou « HSVA ». Une chaîne vide est renvoyée en cas d'erreur.

INTÉGRÉ VARIABLES

gvpr fournit certaines variables intégrées spéciales, dont les valeurs sont définies automatiquement par
gvpr selon le contexte. Sauf indication contraire, l'utilisateur ne peut pas modifier ses valeurs.

$ : obj_t
désigne l'objet courant (nœud, arête, graphe) en fonction du contexte. Ce n'est pas
disponible dans COMMENCER or FIN clauses.

$F : un magnifique
est le nom du fichier d'entrée courant.

$G : graph_t
désigne le graphe en cours de traitement. Il n'est pas disponible en COMMENCER or FIN
clauses.

$NG : graph_t
désigne le prochain graphe à traiter. Si $NG est NULL, le graphique actuel $G est
dernier graphique. Notez que si l'entrée provient de stdin, le dernier graphique ne peut pas être
déterminé jusqu'à ce que le tuyau d'entrée soit fermé. Il n'est pas disponible en COMMENCER or FIN
clauses, ou si le -n drapeau est utilisé.

$O : graph_t
désigne le graphe de sortie. Avant le parcours du graphe, il est initialisé à la cible
graphique. Après la traversée et tout FIN_G actions, s'il se réfère à un graphe non vide,
ce graphique est imprimé sur le flux de sortie. Il n'est valable que dans N, E et FIN_G
clauses. Le graphique de sortie peut être défini par l'utilisateur.

$T : graph_t
désigne le graphe cible actuel. C'est un sous-graphe de $G et n'est disponible qu'en
N, E et FIN_G clauses.

$nom de la cible : un magnifique
désigne le nom du graphe cible. Par défaut, il est défini sur "gvpr_result". Si
utilisé plusieurs fois au cours de l'exécution de gvpr, le nom sera suivi d'un
entier. Cette variable peut être définie par l'utilisateur.

$racinetv : nœud_t
indique le nœud de départ pour une profondeur (orientée ou non) en premier ou en largeur.
premier parcours du graphe (cf. $typetv au dessous de). La valeur par défaut est NULL en
chaque graphique d'entrée. Après le parcours à la racine donnée, si la valeur de $racinetv
a changé, un nouveau parcours commencera avec la nouvelle valeur de $racinetv. Aussi, définissez
$tvsuivant ci-dessous.

$tvsuivant : nœud_t
indique le prochain nœud de départ pour une profondeur (orientée ou non) d'abord ou
parcours en largeur d'abord du graphe (cf. $typetv au dessous de). Si un parcours se termine
et par $racinetv n'a pas été réinitialisé mais le $tvsuivant a été réglé mais pas utilisé, ce
nœud sera utilisé comme prochain choix pour $racinetv. La valeur par défaut est NULL en
chaque graphique d'entrée.

$tvedge : bord_t
Pour les traversées BFS et DFS, ceci est défini sur le bord utilisé pour arriver au courant
nœud ou arête. Au début d'un parcours, ou pour d'autres types de parcours, le
valeur est NULL.

$typetv : tvtype_t
indique comment gvpr parcourt un graphe. Il ne peut prendre qu'une des valeurs constantes
avec le previx "TV_" décrit ci-dessous. TV_plat est la valeur par défaut.

Dans la bibliothèque de graphes sous-jacente graphique(3), les arêtes dans les graphes non orientés reçoivent un
direction arbitraire. Ceci est utilisé pour les traversées, telles que TV_avant, exigeant
bords dirigés.

ARGC : int
désigne le nombre d'arguments spécifiés par le -a args argument de ligne de commande.

ARGV : un magnifique tableau
désigne le tableau d'arguments spécifié par le -a args argument de ligne de commande. Les
il'argument est donné par ARGV[i].

INTÉGRÉ CONSTANTES

Il existe plusieurs constantes symboliques définies par gvpr.

NULL : obj_t
une référence d'objet nulle, équivalente à 0.

TV_plat : tvtype_t
un parcours simple et plat, avec des objets graphiques visités dans un ordre apparemment arbitraire.

TV_ne : tvtype_t
un parcours qui visite d'abord tous les nœuds, puis toutes les arêtes.

TV_fr : tvtype_t
un parcours qui visite d'abord toutes les arêtes, puis tous les nœuds.

TV_dfs : tvtype_t
TV_postdfs : tvtype_t
TV_prepostdfs : tvtype_t
une traversée du graphe en utilisant une recherche en profondeur d'abord sur le sous-jacent non orienté
graphique. Pour faire la traversée, gvpr vérifiera la valeur de $racinetv. Si cela a le
même valeur que précédemment (au départ, la valeur précédente est initialisée
à NULL.) gvpr recherchera simplement un nœud non visité et traversera son
composant. D'autre part, si $racinetv a changé, son composant connecté
être visité, en supposant qu'il n'a pas été visité auparavant ou, si $racinetv is NULL,
la traversée s'arrêtera. Notez qu'en utilisant TV_dfs et $racinetv, il est possible de créer
une boucle infinie.

Par défaut, le parcours se fait en pré-commande. C'est-à-dire qu'un nœud est visité avant
tous ses bords non visités. Pour TV_postdfs, toutes les arêtes non visitées d'un nœud sont
visité avant le nœud. Pour TV_prepostdfs, un nœud est visité deux fois, avant et
après tous ses bords non visités.

TV_avant : tvtype_t
TV_postfwd : tvtype_t
TV_prepostfwd : tvtype_t
Un parcours du graphe utilisant une recherche en profondeur d'abord sur le graphe suivant uniquement
arcs avant. Le choix des racines pour le parcours est le même que celui décrit pour
TV_dfs dessus. Les différents ordres de visite spécifiés par TV_avant, TV_postfwd
et TV_prepostfwd sont les mêmes que ceux spécifiés par les traversées analogues
TV_dfs, TV_postdfs et TV_prepostdfs.

TV_rev : tvtype_t
TV_postrev : tvtype_t
TV_prepostrev : tvtype_t
Un parcours du graphe utilisant une recherche en profondeur d'abord sur le graphe suivant uniquement
arcs inversés. Le choix des racines pour le parcours est le même que celui décrit pour
TV_dfs dessus. Les différents ordres de visite spécifiés par TV_rev, TV_postrev
et TV_prepostrev sont les mêmes que ceux spécifiés par les traversées analogues
TV_dfs, TV_postdfs et TV_prepostdfs.

TV_bfs : tvtype_t
Une traversée du graphe en utilisant une recherche en largeur d'abord sur le graphe en ignorant l'arête
directions. Voir l'article sur TV_dfs ci-dessus pour le rôle de $racinetv.

EXEMPLES

gvpr -i 'N[color=="bleu"]' fichier.gv

Générez le sous-graphe induit par les nœuds de tous les nœuds de couleur bleue.

gvpr -c 'N[color=="bleu"]{color = "rouge"}' fichier.gv

Rendez tous les nœuds bleus rouges.

COMMENCER { int n, e; int tot_n = 0; int tot_e = 0; }
BEG_G {
n = nNoeuds($G);
e = bords($G);
printf ("%ré nœuds %d bords %s\n", n, e, $G.nom);
tot_n += n;
tot_e += e;
}
FIN { printf ("%ré nœuds %d bords total\n", tot_n, tot_e) }

Version du programme gc.

gvpr -c ""

Équivalent à nop.

BEG_G { graph_t g = graphique ("fusionner", "S"); }
E {
nœud_t h = clone(g,$.head);
nœud_t t = clone(g,$.tail);
bord_t e = bord(t,h,"");
e.poids = e.poids + 1;
}
FIN_G { $O = g; }

Produit une version stricte du graphique d'entrée, où l'attribut de poids d'une arête
indique combien d'arêtes du graphe d'entrée l'arête représente.

COMMENCER {nœud_t n; int degré[]}
E{deg[tête]++; deg[queue]++ ; }
FIN_G {
en (degré[n]) {
printf ("deg[%s] = %d\n", n. nom, degré[n]);
}
}

Calcule les degrés des nœuds avec des arêtes.

COMMENCER {
int i, tiret ;
int vu[chaîne];
annuler PrInd (entier cnt) {
en (i = 0; i < cent ; je++) printf (" ");
}
}
BEG_G {

$typetv = TV_prepostfwd ;
$racinetv = nœud($,ARGV[0]);
}
N {
if (vu[$.name]) retrait--;
d'autre {
prInd(retrait);
impression ($.nom) ;
vu[$.name] = 1;
retrait++ ;
}
}

Imprime le parcours en profondeur d'abord du graphe, en commençant par le nœud dont le nom est
ARGV[0], sous forme de liste en retrait.

ENVIRONNEMENT

GVPRPATH
Liste des répertoires séparés par des deux-points à rechercher pour trouver le fichier spécifié par
l'option -f. gvpr a une liste par défaut intégrée. Si GVPRPATH n'est pas défini, le
la liste par défaut est utilisée. Si GVPRPATH commence par deux points, la liste est formée par
ajouter GVPRPATH à la liste par défaut. Si GVPRPATH se termine par deux points, la liste est
formé en ajoutant la liste par défaut à GVPRPATH. Autrement, GVPRPATH est utilisé pour
la liste.

Sur les systèmes Windows, remplacez ``deux-points'' par ``point-virgule'' dans le paragraphe précédent.

Utiliser gvpr en ligne en utilisant les services onworks.net