gvpr - Online en la nube

PROGRAMA:

NOMBRE

gvpr - lenguaje de procesamiento y escaneo de patrones de gráficos

SINOPSIS

gvpr [-icnqV?] [ -o archivar ] [ -a args ] [ 'prog' | -f perfil ] [ archivos ]

DESCRIPCIÓN

gvpr (anteriormente conocido como gpr) es un editor de flujo de gráficos inspirado en awk. Copia la entrada
gráficos a su salida, posiblemente transformando su estructura y atributos, creando nuevos
gráficos o imprimir información arbitraria. El modelo gráfico es el proporcionado por
libcgrafo(3). En particular, gvpr lee y escribe gráficos usando el lenguaje de puntos.

Básicamente, gvpr atraviesa cada gráfico de entrada, denotado por $G, visitando cada nodo y borde,
comparándolo con las reglas de acción de predicado proporcionadas en el programa de entrada. Las reglas son
evaluado en orden. Para cada predicado que se evalúa como verdadero, la acción correspondiente es
realizado. Durante el recorrido, el nodo o borde actual que se está visitando se indica mediante $.

Para cada gráfico de entrada, hay un subgráfico de destino, denotado por $T, inicialmente vacío y usado
para acumular entidades elegidas, y un gráfico de salida, $O, utilizado para el procesamiento final y luego
escrito en la salida. De forma predeterminada, el gráfico de salida es el gráfico de destino. El gráfico de salida
se puede configurar en el programa o, en un sentido limitado, en la línea de comando.

CAMPUS

Se admiten las siguientes opciones:

-a args
La cuerda args se divide en tokens separados por espacios en blanco, con el individuo
tokens disponibles como cadenas en el gvpr programar como ARGV [0], ..., ARGV [ARGC-1].
Caracteres de espacio en blanco dentro de subcadenas entre comillas simples o dobles, o precedidos por un
barra invertida, se ignoran como separadores. En general, un carácter de barra invertida se apaga
cualquier significado especial del siguiente carácter. Tenga en cuenta que los tokens derivados de
múltiples -a los indicadores están concatenados.

-c Utilice el gráfico de origen como gráfico de salida.

-i Derivar la extensión del subgráfico inducida por nodos del gráfico de salida en el contexto de
su gráfico raíz.

-o archivar
Hace que la secuencia de salida se escriba en el archivo especificado; por defecto, la salida es
escrito a stdout.

-f perfil
Utilice el contenido del archivo especificado como programa para ejecutar en la entrada. Si
perfil contiene un carácter de barra, el nombre se toma como la ruta del archivo.
De lo contrario, gvpr utilizará los directorios especificados en la variable de entorno
GVPRPATH para buscar el archivo. Si -f no se da, gvpr utilizará la primera no
argumento de opción como el programa.

-q Desactiva los mensajes de advertencia.

-n Desactiva la lectura anticipada del gráfico. Por defecto, la variable $ NG se establece en el siguiente gráfico
para ser procesado. Esto requiere una lectura del siguiente gráfico antes de procesar el
gráfico actual, que puede bloquearse si el siguiente gráfico sólo se genera en respuesta a
alguna acción relacionada con el procesamiento del gráfico actual.

-V Hace que el programa imprima la información de la versión y se cierre.

-? Hace que el programa imprima la información de uso y se cierre.

OPERANDOS

Se admite el siguiente operando:

archivos Nombres de archivos que contienen 1 o más gráficos en el lenguaje de puntos. Si no -f opción
se da, el nombre se elimina de la lista y se utiliza como programa de entrada.
Si la lista de archivos está vacía, stdin se utilizará.

PROGRAMAS

A gvpr El programa consta de una lista de cláusulas de acción de predicado, que tienen una de las formas:

EMPEZAR { DE ACTUAR! }

BEG_G { DE ACTUAR! }

N [ predicado ] { DE ACTUAR! }

E [ predicado ] { DE ACTUAR! }

END_G { DE ACTUAR! }

FIN { DE ACTUAR! }

Un programa puede contener como máximo uno de cada uno de los EMPEZAR, END_G y FIN cláusulas. Allí pueden
ser cualquier número de BEG_G, N y E declaraciones, la primera aplicada a gráficos, la segunda a
nodos, el tercero a los bordes. Estos se separan en bloques, un bloque que consta de un
opcional BEG_G declaración y todo N y E declaraciones hasta la siguiente BEG_G declaración, si
alguna. La semántica de alto nivel de un gvpr programa son:

Evalúa el EMPEZAR cláusula, si la hubiera.
Para cada gráfico de entrada G {
Para cada bloque {
Set G como el gráfico actual y el objeto actual.
Evalúa el BEG_G cláusula, si la hubiera.
Para cada nodo y borde en G {
Establece el nodo o borde como el objeto actual.
Evalúa el N or E cláusulas, según corresponda.
}
}
Set G como el objeto actual.
Evalúa el END_G cláusula, si la hubiera.
}
Evalúa el FIN cláusula, si la hubiera.

Las acciones del EMPEZAR, BEG_G, END_G y FIN las cláusulas se realizan cuando las cláusulas son
evaluado. Para N or E cláusulas, se puede omitir el predicado o la acción. Sí hay
no es un predicado con una acción, la acción se realiza en cada nodo o borde, como
apropiado. Si no hay acción y el predicado se evalúa como verdadero, el asociado
El nodo o borde se agrega al gráfico de destino.

Los bloques se evalúan en el orden en que ocurren. Dentro de una cuadra, el N cláusulas
(E cláusulas, respectivamente) se evalúan en el orden en que ocurren. Tenga en cuenta, sin embargo,
que dentro de una cuadra, N or E las cláusulas pueden estar entrelazadas, dependiendo del orden transversal.

Los predicados y las acciones son secuencias de declaraciones en el dialecto C respaldadas por el
expr(3) biblioteca. La única diferencia entre predicados y acciones es que los primeros
debe tener un tipo que pueda interpretarse como verdadero o falso. Aquí la habitual C
se sigue la convención, en la que un valor distinto de cero se considera verdadero. Esto incluiría
cadenas no vacías y referencias no vacías a nodos, bordes, etc. Sin embargo, si una cadena puede
convertirse en un número entero, se utiliza este valor.

Además de los tipos de base C habituales (vacío, int, tanque, flotar, Corto, no firmado y doble),
gvpr proporciona un cadena como sinónimo de char *y los tipos basados ​​en gráficos nodo_t, borde_t,
gráfico_t y objeto_t. objeto_t El tipo se puede ver como un supertipo de los otros 3 tipos de concreto.
tipos; el tipo de base correcto se mantiene dinámicamente. Además de estos tipos de base, el
solo otras expresiones de tipo admitidas son matrices (asociativas).

Las constantes siguen la sintaxis de C, pero las cadenas se pueden citar con "..." or '...'. gvpr
acepta comentarios de C ++ así como comentarios de tipo cpp. Para este último, si una línea comienza con
un carácter '#', el resto de la línea se ignora.

Una declaración puede ser una declaración de una función, una variable o una matriz, o un ejecutable.
declaración. Para las declaraciones, hay un único ámbito. Las declaraciones de matriz tienen la forma:

tipo matriz [ type0 ]

donde type0 es opcional. Si se proporciona, el analizador aplicará que todas las matrices
los subíndices tienen el tipo especificado. Si no se suministra, los objetos de todo tipo se pueden
utilizado como subíndices. Como en C, las variables y las matrices deben declararse. En particular, un
La variable no declarada se interpretará como el nombre de un atributo de un nodo, borde o
gráfico, según el contexto.

Las declaraciones ejecutables pueden ser una de las siguientes:

{ [ ambiental ... ] }
expresión // comúnmente var = expresión
if ( expresión ) ambiental [ más ambiental ]
por( expresión ; expresión ; expresión ) ambiental
por( matriz [ var ]) ambiental
forr matriz [ var ]) ambiental
tiempo ( expresión ) ambiental
cambiar( expresión ) case declaraciones
romper [ expresión ]
continue [ expresión ]
volvemos [ expresión ]
Los elementos entre paréntesis son opcionales.

En la segunda forma del para declaración y el para declaración, la variable var se establece a
cada valor utilizado como índice en la matriz especificada y luego el asociado ambiental is
evaluado. Para índices numéricos y de cadena, los índices se devuelven aumentando
(decreciente) orden numérico o lexicográfico para para (para, respectivamente). Esto se puede utilizar
para clasificar.

Las definiciones de funciones solo pueden aparecer en el EMPEZAR cláusula.

Las expresiones incluyen las expresiones C habituales. Comparaciones de cadenas usando == y != tratar el
operando de la derecha como patrón con el propósito de hacer coincidir expresiones regulares. Patrones
utilizan el ksh(1) sintaxis del patrón de coincidencia de archivos. (Para igualdad de cadenas simple, use el strcmp
función.

gvpr intentará utilizar una expresión como cadena o valor numérico según corresponda. Ambos
Las conversiones de tipo C y las plantillas de funciones harán que se realicen conversiones, si es posible.

Expresiones de tipo gráfico (es decir, gráfico_t, nodo_t, borde_t, objeto_t) puede ir seguido de un
referencia de campo en forma de .nombre . El valor resultante es el valor del atributo
llamado nombre del objeto dado. Además, en ciertos contextos, un no declarado,
El identificador no modificado se toma como un nombre de atributo. Específicamente, tales identificadores
denotar atributos del nodo o borde actual, respectivamente, en N y E cláusulas, y la
gráfico actual en BEG_G y END_G cláusulas.

Como es habitual en el libcgrafo(3) modelo, los atributos se valoran como cadenas. Además, gvpr
admite ciertos pseudoatributos de objetos gráficos, no necesariamente con valores de cadena. Estas
reflejan propiedades intrínsecas de los objetos gráficos y no pueden ser configuradas por el usuario.

cabeza : nodo_t
la cabeza de un borde.

cola : nodo_t
la cola de un borde.

nombre : cadena
el nombre de un borde, nodo o gráfico. El nombre de un borde tiene la forma "<tail‐
nombre>[]", dónde es "->"O"--" Dependiendo de
si el gráfico está dirigido o no. La parte del soporte [] solo aparece si el
edge tiene una clave no trivial.

grado : int
el grado de un nodo.

excedido : int
el grado de salida de un nodo.

la licenciatura : int
el grado de un nodo.

raíz : gráfico_t
el gráfico raíz de un objeto. La raíz de un gráfico raíz es ella misma.

con el futuro bebé : gráfico_t
el gráfico principal de un subgráfico. El padre de una gráfica raíz es NULL

n_bordes : int
el número de aristas en el gráfico

n_nodos : int
el número de nodos en el gráfico

que dirigieron : int
verdadero (distinto de cero) si la gráfica está dirigida

estricto : int
verdadero (distinto de cero) si el gráfico es estricto

INCORPORADO Las funciones

Las siguientes funciones están integradas en gvpr. Esas funciones que devuelven referencias al gráfico
los objetos regresan NULL en caso de fallo.

Gráficos y subgrafo
gráfica(s : cadena, t : cadena): gráfico_t
crea un gráfico cuyo nombre es s y cuyo tipo está especificado por la cadena t.
Ignorando el caso, los personajes U, D, S, N hacer que la interpretación no esté dirigida,
dirigido, estricto y no estricto, respectivamente. Si t está vacío, dirigido, no‐
Se genera un gráfico estricto.

subg(g : gráfico_t, s : cadena): gráfico_t
crea un subgrafo en el grafo g con nombre s. Si el subgrafo ya existe, es
devuelto.

esSubg(g : gráfico_t, s : cadena): gráfico_t
devuelve el subgrafo en el gráfico g con nombre s, si existe, o NULL de otra manera.

fstsubg(g : gráfico_t): gráfico_t
devuelve el primer subgrafo del gráfico go NULL si no existe ninguno.

nxtsubg(sg : gráfico_t): gráfico_t
devuelve el siguiente subgrafo después de sgo NULL.

esDirecto(g : gráfico_t): int
devuelve verdadero si y solo si g está dirigido.

es estricto(g : gráfico_t): int
devuelve verdadero si y solo si g es estricto.

nNodos(g : gráfico_t): int
devuelve el número de nodos en g.

nBordes(g : gráfico_t): int
devuelve el número de aristas en g.

Nodes
nodo(sg : gráfico_t, s : cadena): nodo_t
crea un nodo en el gráfico g de nombre s. Si tal nodo ya existe, se devuelve.

subnodo(sg : gráfico_t, n : nodo_t): nodo_t
inserta el nodo n en el subgrafo g. Devuelve el nodo.

nodofst(g : gráfico_t): nodo_t
devuelve el primer nodo en el gráfico go NULL si no existe ninguno.

nxtnodo(n : nodo_t): nodo_t
devuelve el siguiente nodo después n en el gráfico raíz, o NULL.

nxtnode_sg(sg : gráfico_t, n : nodo_t): nodo_t
devuelve el siguiente nodo después n in sgo NULL.

esNodo(sg : gráfico_t, s : cadena): nodo_t
busca un nodo en (sub) gráfico sg de nombre s. Si tal nodo existe, se devuelve.
De lo contrario, NULL es regresado.

esSubnodo(sg : gráfico_t, n : nodo_t): int
devuelve un valor distinto de cero si el nodo n está en (sub) gráfico sg, o cero en caso contrario.

engradoDe(sg : gráfico_t, n : nodo_t): int
devuelve el grado de grado del nodo n en (sub) gráfico sg.

fuera de grado(sg : gráfico_t, n : nodo_t): int
devuelve el grado de salida del nodo n en (sub) gráfico sg.

grado de(sg : gráfico_t, n : nodo_t): int
devuelve el grado de nodo n en (sub) gráfico sg.

Bordes
Edge(t : nodo_t, h : nodo_t, s : cadena): borde_t
crea un borde con un nodo de cola t, nodo principal h y nombre s en el gráfico raíz. Si el
gráfico no está dirigido, la distinción entre los nodos de cabeza y cola no es importante.
Si tal ventaja ya existe, se devuelve.

borde_sg(sg : gráfico_t, t : nodo_t, h : nodo_t, s : cadena): borde_t
crea un borde con un nodo de cola t, nodo principal h y nombre s en (sub) gráfico sg (y todo
gráficos de los padres). Si el gráfico no está dirigido, la distinción entre cabeza y cola
nodos no es importante. Si tal ventaja ya existe, se devuelve.

subeditar(g : gráfico_t, e : borde_t): borde_t
inserta el borde e en el subgrafo g. Devuelve el borde.

esBorde(t : nodo_t, h : nodo_t, s : cadena): borde_t
busca un borde con nodo de cola t, nodo principal h y nombre s. Si el gráfico es
Si no está dirigida, la distinción entre los nodos de la cabeza y la cola carece de importancia. Si tal
el borde existe, se devuelve. De lo contrario, NULL es regresado.

isEdge_es(sg : gráfico_t, t : nodo_t, h : nodo_t, s : cadena): borde_t
busca un borde con nodo de cola t, nodo principal h y nombre s en (sub) gráfico sg. Si el
gráfico no está dirigido, la distinción entre los nodos de cabeza y cola no es importante.
Si existe tal ventaja, se devuelve. De lo contrario, NULL es regresado.

esSubedge(g : gráfico_t, e : borde_t): int
devuelve un valor distinto de cero si el borde e está en (sub) gráfico sg, o cero en caso contrario.

Fstout(n : nodo_t): borde_t
devuelve la primera salida del nodo n en el gráfico raíz.

fstout_sg(sg : gráfico_t, n : nodo_t): borde_t
devuelve la primera salida del nodo n en (sub) gráfico sg.

nxtout(e : borde_t): borde_t
devuelve la próxima salida después de e en el gráfico raíz.

nxtout_sg(sg : gráfico_t, e : borde_t): borde_t
devuelve la próxima salida después de e en gráfico sg.

fstin(n : nodo_t): borde_t
devuelve el primer borde del nodo n en el gráfico raíz.

fstin_sg(sg : gráfico_t, n : nodo_t): borde_t
devuelve el primer borde del nodo n en gráfico sg.

nxtin(e : borde_t): borde_t
devuelve el siguiente borde después de e en el gráfico raíz.

nxtin_sg(sg : gráfico_t, e : borde_t): borde_t
devuelve el siguiente borde después de e en gráfico sg.

fstedge(n : nodo_t): borde_t
devuelve el primer borde del nodo n en el gráfico raíz.

fstedge_sg(sg : gráfico_t, n : nodo_t): borde_t
devuelve el primer borde del nodo n en gráfico sg.

borde(e : borde_t, nodo_t): borde_t
devuelve el siguiente borde después de e en el gráfico raíz.

nxtedge_sg(sg : gráfico_t, e : borde_t, nodo_t): borde_t
devuelve el siguiente borde después de e en el grafico sg.

opp(e : borde_t, nodo_t): nodo_t
devuelve el nodo en el borde e no igual a n. Devuelve NULL si n no es un nodo de
e. Esto puede resultar útil al utilizar fstedge y borde para enumerar los vecinos de
n.

Gráfico I / O
escribir(g : gráfico_t): vacío
huellas dactilares g en formato de puntos en el flujo de salida.

escribirG(g : gráfico_t, fnombre : cadena): vacío
huellas dactilares g en formato de puntos en el archivo fnombre.

escribirG(g : gráfico_t, fd : int): vacío
huellas dactilares g en formato de puntos en la secuencia abierta denotada por el entero fd.

leerG(fnombre : cadena): gráfico_t
devuelve un gráfico leído del archivo fnombre. El gráfico debe estar en formato de puntos. Si no
se puede leer el gráfico, NULL es regresado.

FreadG(fd : int): gráfico_t
devuelve el siguiente gráfico leído del flujo abierto fd. Devoluciones NULL al final del archivo.

Gráfico miscelánea
borrar(g : gráfico_t, x : objeto_t): vacío
elimina objeto x del gráfico g. Si g is NULL, la función usa la raíz gráfica de
x. Si x es un gráfico o subgráfico, está cerrado a menos que x está bloqueado.

es en(g : gráfico_t, x : objeto_t): int
devuelve verdadero si x está en subgrafo g.

clonar(g : gráfico_t, s : cadena): gráfico_t
crea un clon de gráfico g con nombre de s. Si s es "", el gráfico creado tiene la
mismo nombre que g.

clonar(g : gráfico_t, x : objeto_t): objeto_t
crea un clon de objeto x en gráfico g. En particular, el nuevo objeto tiene el mismo
Atributos de nombre / valor y estructura como el objeto original. Si un objeto con el
misma clave que x ya existe, sus atributos se superponen con los de x y del
se devuelve el objeto. Si se clona un borde, ambos extremos se clonan implícitamente.
Si se clona un gráfico, todos los nodos, bordes y subgráficos se clonan implícitamente. Si x
es un gráfico, g puede ser NULL, en cuyo caso el objeto clonado será una nueva raíz
grafico. En este caso, la llamada es equivalente a cloneG (x, "").

copia(g : gráfico_t, x : objeto_t): objeto_t
crea una copia del objeto x en gráfico g, donde el nuevo objeto tiene el mismo nombre / valor
atributos como el objeto original. Si un objeto con la misma clave que x ya haya utilizado
existe, sus atributos se superponen a los de x y se devuelve el objeto. Nota
que esta es una copia superficial. Si x es un gráfico, ninguno de sus nodos, bordes o subgrafos
se copian en el nuevo gráfico. Si x es un borde, los puntos finales se crean si
necesarios, pero no se clonan. Si x es un gráfico, g puede ser NULL, en ese caso
el objeto clonado será un nuevo gráfico raíz.

copiarA(src : objeto_t, TGT : objeto_t): int
copia los atributos del objeto src al objeto TGT, sobrescribiendo cualquier valor de atributo
TGT puede tener inicialmente.

inducir(g : gráfico_t): vacío
Se extiende g a su extensión de subgrafo inducida por nodos en su grafo raíz.

tieneAttr(src : objeto_t, nombre : cadena): int
devuelve un objeto distinto de cero src tiene un atributo cuyo nombre es nombre . Devuelve 0
de otra manera.

esAttr(g : gráfico_t, tipo : cadena, nombre : cadena): int
devuelve un valor distinto de cero si un atributo nombre ha sido definido en g para objetos de la
dado tipo. Para nodos, aristas y gráficos, tipo debe ser "N", "E" y "G",
respectivamente. Devuelve 0 en caso contrario.

obtener(src : objeto_t, nombre : cadena): cadena
devuelve el valor del atributo nombre en objeto src. Esto es útil para esos casos
cuando nombre entra en conflicto con una de las palabras clave como "head" o "root". Si el
El atributo no ha sido declarado en el gráfico, la función lo inicializará con
un valor predeterminado de "". Para evitar esto, uno debe usar el tieneAttr or esAttr función
para comprobar que el atributo existe.

un conjunto(src : objeto_t, nombre : cadena, propuesta de : cadena): int
establece el valor del atributo nombre en objeto src a propuesta de. Devuelve 0 en caso de éxito,
distinto de cero en caso de fallo. Ver obtener anterior.

obtenerDflt(g : gráfico_t, tipo : cadena, nombre : cadena): cadena
devuelve el valor predeterminado del atributo nombre en objetos en g de lo dado tipo. For
nodos, aristas y gráficos, tipo debe ser "N", "E" y "G", respectivamente. Si el
El atributo no ha sido declarado en el gráfico, la función lo inicializará con
un valor predeterminado de "". Para evitar esto, uno debe usar el esAttr función para comprobar
que el atributo existe.

establecerDflt(g : gráfico_t, tipo : cadena, nombre : cadena, propuesta de : cadena): int
establece el valor predeterminado del atributo nombre a propuesta de en objetos en g de lo dado
tipo. Para nodos, aristas y gráficos, tipo debe ser "N", "E" y "G", respectivamente.
Devuelve 0 en caso de éxito, distinto de cero en caso de error. Ver obtenerDflt anterior.

fstAttr(g : gráfico_t, tipo : cadena): cadena
devuelve el nombre del primer atributo de los objetos en g de lo dado tipo. For
nodos, aristas y gráficos, tipo debe ser "N", "E" y "G", respectivamente. Sí hay
no hay atributos, se devuelve la cadena "".

nxtAttr(g : gráfico_t, tipo : cadena, nombre : cadena): cadena
devuelve el nombre del siguiente atributo de los objetos en g de lo dado tipo después de la
atributo nombre . El argumento nombre debe ser el nombre de un atributo existente; eso
normalmente será el valor de retorno de una llamada anterior a fstAttr or nxtAttr. For
nodos, aristas y gráficos, tipo debe ser "N", "E" y "G", respectivamente. Sí hay
si no quedan atributos, se devuelve la cadena "".

CompOf(g : gráfico_t, n : nodo_t): gráfico_t
devuelve el componente conectado del gráfico g que contiene el nodo n, como un subgrafo de
g. El subgrafo solo contiene los nodos. Uno puede usar inducir para agregar los bordes. los
la función falla y regresa NULL if n no está dentro g. La conectividad se basa en
gráfico subyacente no dirigido de g.

mas o menos(obj : objeto_t): cadena
devuelve una indicación del tipo de obj. Para nodos, bordes y gráficos, devuelve
"N", "E" y "G", respectivamente.

bloquear(g : gráfico_t, v : int): int
implementa el bloqueo de gráficos en los gráficos raíz. Si el entero v es positivo, la gráfica es
configurado para que futuras llamadas a borrar no tienen ningún efecto inmediato. Si v es cero, el
El gráfico está desbloqueado. Si ha habido una llamada para eliminar el gráfico mientras estaba
bloqueado, el gráfico está cerrado. Si v es negativo, no se hace nada. En todos los casos, la
se devuelve el valor de bloqueo anterior.

Tangas
correr(fmt : cadena, ...): cadena
devuelve la cadena resultante de formatear los valores de las expresiones
ocurriendo después fmt de acuerdo con la Printf(3) formato fmt

g-sub(str : cadena, palmadita : cadena): cadena

g-sub(str : cadena, palmadita : cadena, responder : cadena): cadena
devoluciones str con todas las subcadenas coincidentes palmadita eliminado o reemplazado por responder,
respectivamente.

por debajo(str : cadena, palmadita : cadena): cadena

por debajo(str : cadena, palmadita : cadena, responder : cadena): cadena
devoluciones str con la subcadena coincidente más a la izquierda palmadita eliminado o reemplazado por responder,
respectivamente. Los caracteres '^' y '$' pueden usarse al principio y al final,
respectivamente, de palmadita para anclar el patrón al principio o al final de str.

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

substr(str : cadena, idx : int, len : int): cadena
devuelve la subcadena de str comenzando en la posición idx hasta el final de la cadena o
de longitud len, respectivamente. La indexación comienza en 0. Si idx es negativo o idx is
mayor que la longitud de str, se produce un error fatal. Del mismo modo, en el segundo
caso, si len es negativo o idx + len es mayor que la longitud de str, una fatal
se produce un error.

strcmp(s1 : cadena, s2 : cadena): int
proporciona la función C estándar strcmp(3).

de largo(s : cadena): int
devuelve la longitud de la cadena s.

índice(s : cadena, t : cadena): int

Rindex(s : cadena, t : cadena): int
devuelve el índice del carácter en cadena s donde la copia más a la izquierda (más a la derecha)
de cuerda t se puede encontrar, o -1 si t no es una subcadena de s.

partido(s : cadena, p : cadena): int
devuelve el índice del carácter en cadena s donde la coincidencia de patrón más a la izquierda
p se puede encontrar, o -1 si no hay subcadena de s cerillas p.

topper(s : cadena): cadena
devuelve una versión de s con los caracteres alfabéticos convertidos a mayúsculas.

reducir(s : cadena): cadena
devuelve una versión de s con los caracteres alfabéticos convertidos a minúsculas.

canon(s : cadena): cadena
devuelve una versión de s apropiado para ser utilizado como un identificador en un archivo de puntos.

html(g : gráfico_t, s : cadena): cadena
devuelve una versión `` mágica '' de s como una cadena HTML. Esto normalmente se utilizará para
adjuntar una etiqueta similar a HTML a un objeto gráfico. Tenga en cuenta que la cadena devuelta vive en
g. En particular, se liberará cuando g está cerrado, y para actuar como una cadena HTML,
tiene que ser utilizado con un objeto de g. Además, tenga en cuenta que el corchete angular
las citas no deben ser parte de s. Estos se agregarán si g está escrito en concreto DOT
formato.

ishtml(s : cadena): int
devuelve un valor distinto de cero si y solo si s es una cadena HTML.

xDe(s : cadena): cadena
devuelve la cadena "x" Si s tiene la forma "x,y", donde ambos x y y son numéricos.

tu(s : cadena): cadena
devuelve la cadena "y" Si s tiene la forma "x,y", donde ambos x y y son numéricos.

llof(s : cadena): cadena
devuelve la cadena "lx,lly" Si s tiene la forma "lx,lly,Urx,ury", donde todos lx,
lly, Urxy ury son numéricos.

urOf (s)
urOf(s : cadena): cadena devuelve la cadena "Urx,ury" Si s tiene la forma
"lx,lly,Urx,ury", donde todos lx, lly, Urxy ury son numéricos.

escanear(s : cadena, fmt : cadena, ...): int
escanea la cadena s, extrayendo valores según el escanear(3) formato fmt.
los valores se almacenan en las direcciones siguientes fmt, direcciones que tienen el formulario &v,
donde v es alguna variable declarada del tipo correcto. Devuelve el número de artículos
escaneado con éxito.

dividido(s : cadena, arr : matriz, septiembres : cadena): int

dividido(s : cadena, arr : matriz): int

fichas(s : cadena, arr : matriz, septiembres : cadena): int

fichas(s : cadena, arr : matriz): int
El dividido función rompe la cuerda s en los campos, mientras que el fichas función
rompe la cadena en fichas. Un campo consta de todos los caracteres no separadores.
entre dos caracteres separadores o el principio o el final de la cadena. Por lo tanto, un
El campo puede ser la cadena vacía. Un token es una subcadena máxima, no vacía, no
que contiene un carácter separador. Los caracteres separadores son los dados en el
septiembres argumento. Si septiembres no se proporciona, el valor predeterminado es "\ t \ n". los
las funciones devuelven el número de campos o tokens.

Los campos y tokens se almacenan en la matriz de argumentos. La matriz debe ser cadena-
valorado y, si se especifica un tipo de índice, debe ser int. Las entradas están indexadas
por enteros consecutivos, comenzando en 0. Cualquier valor ya almacenado en la matriz
se sobrescribirá o aún estará presente después de que regrese la función.

I / O
Imprimir(...): vacío
impresión( expr, ... ) imprime una representación de cadena de cada argumento a su vez en
stdout, seguido de una nueva línea.

Printf(fmt : cadena, ...): int

Printf(fd : int, fmt : cadena, ...): int
imprime la cadena resultante de formatear los valores de las expresiones siguientes
fmt de acuerdo con la Printf(3) formato fmt. Devuelve 0 en caso de éxito. Por defecto,
imprime en stdout. Si el entero opcional fd se da, la salida se escribe en el
flujo abierto asociado con fd.

scanf(fmt : cadena, ...): int

scanf(fd : int, fmt : cadena, ...): int
escanea los valores de un flujo de entrada de acuerdo con el scanf(3) formato fmt.
los valores se almacenan en las direcciones siguientes fmt, direcciones que tienen el formulario &v,
donde v es alguna variable declarada del tipo correcto. Por defecto, lee de
stdin. Si el entero opcional fd se da, la entrada se lee de la secuencia abierta
asociado con fd. Devuelve el número de elementos escaneados con éxito.

abrirF(s : cadena, t : cadena): int
abre el archivo s como un flujo de E / S. El argumento de la cadena t especifica cómo es el archivo
abrió. Los argumentos son los mismos que para la función C abierto(3). Devuelve un
entero que denota la secuencia, o -1 en caso de error.

Como de costumbre, los flujos 0, 1 y 2 ya están abiertos como stdin, stdouty stderr,
respectivamente. Ya que gvpr puede usar stdin para leer los gráficos de entrada, el usuario debe
Evite el uso de esta secuencia.

cerrarF(fd : int): int
cierra la secuencia abierta denotada por el entero fd. Las secuencias 0, 1 y 2 no se pueden
cerrado. Devuelve 0 en caso de éxito.

leerL(fd : int): cadena
devuelve la siguiente línea leída del flujo de entrada fd. Devuelve la cadena vacía ""
al final del archivo. Tenga en cuenta que el carácter de nueva línea se deja en la cadena devuelta.

Matemáticas
exp(d : doble): doble
devuelve e al dth poder.

log(d : doble): doble
devuelve el logaritmo natural de d.

sqrt(d : doble): doble
devuelve la raíz cuadrada del doble d.

prisionero de guerra(d : doble, x : doble): doble
devoluciones d elevado a la xth poder.

carro(d : doble): doble
devuelve el coseno de d.

el pecado(d : doble): doble
devuelve el seno de d.

atan2(y : doble, x : doble): doble
devuelve el arcotangente de y / x en el rango de -pi a pi.

MIN(y : doble, x : doble): doble
devuelve el mínimo de y y x.

MAX(y : doble, x : doble): doble
devuelve el máximo de y y x.

De asociación Matrices
# arr : int
devuelve el número de elementos de la matriz arr.

idx in arr : int
devuelve 1 si se ha establecido un valor para el índice idx en la matriz arr. Devuelve 0
de otra manera.

desarmado(v : matriz, idx): int
elimina el elemento indexado por idx. Devuelve 1 si el elemento existía, 0 en caso contrario.

desarmado(v : matriz): vacío
reinicializa la matriz.

Observaciones
salida(v : int): vacío
causas gvpr para salir con el código de salida v.

te(cmd : cadena): int
proporciona la función C estándar te(3). Se ejecuta cmd en el caparazón del usuario
entorno y devuelve el estado de salida del shell.

rand(): doble
devuelve un doble pseudoaleatorio entre 0 y 1.

sardina(): int

sardina(v : int): int
establece una semilla para el generador de números aleatorios. El argumento opcional da la semilla;
si se omite, se utiliza la hora actual. Se devuelve el valor inicial anterior.
sardina debe ser llamado antes de cualquier llamada a rand.

colorx(Color : cadena, fmt : cadena): cadena
traduce un color de un formato a otro. los Color el argumento debe ser un color
en una de las representaciones de cadenas reconocidas. los fmt el valor debe ser uno de
"RGB", "RGBA", "HSV" o "HSVA". Se devuelve una cadena vacía en caso de error.

INCORPORADO VARIABLES

gvpr proporciona ciertas variables especiales incorporadas, cuyos valores se establecen automáticamente por
gvpr dependiendo del contexto. Salvo que se indique lo contrario, el usuario no puede modificar sus valores.

$ : objeto_t
denota el objeto actual (nodo, borde, gráfico) según el contexto. No lo es
disponible en EMPEZAR or FIN cláusulas.

$F : cadena
es el nombre del archivo de entrada actual.

$G : gráfico_t
indica el gráfico actual que se está procesando. No esta disponible en EMPEZAR or FIN
cláusulas.

$ NG : gráfico_t
denota el siguiente gráfico que se procesará. Si $ NG es NULL, el gráfico actual $G son los
último gráfico. Tenga en cuenta que si la entrada proviene de stdin, el último gráfico no se puede
determinado hasta que la tubería de entrada esté cerrada. No esta disponible en EMPEZAR or FIN
cláusulas, o si el -n se utiliza la bandera.

$O : gráfico_t
denota el gráfico de salida. Antes del recorrido del gráfico, se inicializa en el objetivo
grafico. Después de atravesar y cualquier END_G acciones, si se refiere a un gráfico no vacío,
ese gráfico se imprime en el flujo de salida. Solo es valido en N, E y END_G
cláusulas. El gráfico de salida puede configurarlo el usuario.

$T : gráfico_t
denota el gráfico objetivo actual. Es un subgrafo de $G y está disponible solo en
N, E y END_G cláusulas.

$ tgtname : cadena
denota el nombre del gráfico de destino. De forma predeterminada, está configurado en "gvpr_result". Si
utilizado varias veces durante la ejecución de gvpr, el nombre se agregará con un
entero. El usuario puede establecer esta variable.

$ tvroot : nodo_t
indica el nodo inicial para una profundidad (dirigida o no dirigida) primero o ancho
primer recorrido del gráfico (cf. $ tvtype debajo). El valor predeterminado es NULL para
cada gráfico de entrada. Después del recorrido en la raíz dada, si el valor de $ tvroot
ha cambiado, un nuevo recorrido comenzará con el nuevo valor de $ tvroot. Además, establezca
$ tvnext abajo.

$ tvnext : nodo_t
indica el siguiente nodo de inicio para una profundidad (dirigida o no dirigida) primero o
primer recorrido en anchura del gráfico (cf. $ tvtype debajo). Si termina una travesía
y del $ tvroot no se ha reiniciado pero el $ tvnext se ha configurado pero no se ha utilizado,
El nodo se utilizará como la siguiente opción para $ tvroot. El valor predeterminado es NULL para
cada gráfico de entrada.

$ tvedge : borde_t
Para recorridos de BFS y DFS, esto se establece en el borde utilizado para llegar a la corriente
nodo o borde. Al comienzo de un recorrido, o para otros tipos de recorrido, el
Valor es NULL.

$ tvtype : tipo de tv_t
indica como gvpr atraviesa un gráfico. Solo puede tomar uno de los valores constantes
con el anterior "TV_" que se describe a continuación. Piso_TV es el predeterminado.

En la biblioteca de gráficos subyacente cgraf(3), los bordes en gráficos no dirigidos reciben una
dirección arbitraria. Esto se utiliza para recorridos, como TV_avance, requiriendo
bordes dirigidos.

ARGC : int
denota el número de argumentos especificados por el -a args argumento de línea de comandos.

ARGV : cadena matriz
denota la matriz de argumentos especificados por el -a args argumento de línea de comandos. los
iEl argumento viene dado por ARGV [i].

INCORPORADO Constantes

Hay varias constantes simbólicas definidas por gvpr.

NULL : objeto_t
una referencia de objeto nulo, equivalente a 0.

Piso_TV : tipo de tv_t
un recorrido simple y plano, con objetos gráficos visitados en un orden aparentemente arbitrario.

TV_ne : tipo de tv_t
un recorrido que visita primero todos los nodos, luego todos los bordes.

TV_es : tipo de tv_t
un recorrido que visita primero todos los bordes, luego todos los nodos.

tv_dfs : tipo de tv_t
TV_postdfs : tipo de tv_t
TV_prepostdfs : tipo de tv_t
un recorrido del gráfico utilizando una búsqueda en profundidad en el subyacente no dirigido
grafico. Para hacer el recorrido, gvpr comprobará el valor de $ tvroot. Si esto tiene el
mismo valor que tenía anteriormente (al inicio, se inicializa el valor anterior
a NULL.) gvpr simplemente buscará algún nodo no visitado y atravesará su conexión
componente. Por otro lado, si $ tvroot ha cambiado, su componente conectado
ser recorrida, asumiendo que no ha sido visitada previamente o, si $ tvroot is NULL, la
el recorrido se detendrá. Tenga en cuenta que el uso de tv_dfs y $ tvroot, es posible crear
un bucle infinito.

De forma predeterminada, el recorrido se realiza en preorden. Es decir, se visita un nodo antes
todos sus bordes no visitados. Para TV_postdfs, todos los bordes no visitados de un nodo son
visitado antes del nodo. Para TV_prepostdfs, un nodo se visita dos veces, antes y
después de todos sus bordes no visitados.

TV_avance : tipo de tv_t
TV_postfwd : tipo de tv_t
TV_prepostfwd : tipo de tv_t
Un recorrido del gráfico mediante una búsqueda en profundidad en el gráfico siguiente únicamente
arcos delanteros. La elección de raíces para el recorrido es la misma que se describe para
tv_dfs encima. El diferente orden de visita especificado por TV_avance, TV_postfwd
y TV_prepostfwd son los mismos que los especificados por los recorridos análogos
tv_dfs, TV_postdfs y TV_prepostdfs.

TV_rev : tipo de tv_t
TV_postrev : tipo de tv_t
TV_prepostrev : tipo de tv_t
Un recorrido del gráfico mediante una búsqueda en profundidad en el gráfico siguiente únicamente
arcos inversos. La elección de raíces para el recorrido es la misma que se describe para
tv_dfs encima. El diferente orden de visita especificado por TV_rev, TV_postrev
y TV_prepostrev son los mismos que los especificados por los recorridos análogos
tv_dfs, TV_postdfs y TV_prepostdfs.

tv_bfs : tipo de tv_t
Un recorrido del gráfico mediante una búsqueda en amplitud en el gráfico ignorando el borde
direcciones. Ver el artículo en tv_dfs arriba para el papel de $ tvroot.

EJEMPLOS

gvpr -i 'N [color == "azul"]' archivo.gv

Genere el subgráfico inducido por nodos de todos los nodos con color azul.

gvpr -c 'N [color == "azul"] {color = "rojo"}' archivo.gv

Haz que todos los nodos azules sean rojos.

EMPEZAR { int n, e; int tot_n = 0; int totalizador = 0; }
BEG_G {
n = nNodos ($ G);
e = nEdges ($ G);
Printf ("%D nodos %d bordes % s \ n ", n, e, $ G.name);
tot_n += n;
totalizador += e;
}
FIN { Printf ("%D nodos %d bordes total \ n ", tot_n, totalizador) }

Versión del programa gc.

gvpr -c ""

Equivalente a nop.

BEG_G { gráfico_t g = gráfica ("unir", "S"); }
E {
nodo_t h = clon (g, $. cabeza);
nodo_t t = clon (g, $. cola);
borde_t e = borde (t, h, "");
e.peso = e.peso + 1;
}
END_G { $O = g; }

Produce una versión estricta del gráfico de entrada, donde el atributo de peso de un borde
indica cuántos bordes del gráfico de entrada representa el borde.

EMPEZAR {nodo_t n; int deg []}
E {deg [cabeza] ++; deg [cola] ++; }
END_G {
para (grados [n]) {
Printf ("grados [% s]) = % d \ n ", n. nombre, grados [n]);
}
}

Calcula los grados de los nodos con aristas.

EMPEZAR {
int i, sangrar;
int visto [cadena];
vacío prind (En t ct) {
para (i = 0; i < ct; i ++) Printf (" ");
}
}
BEG_G {

$ tvtype = TV_prepostfwd;
$ tvroot = nodo ($, ARGV [0]);
}
N {
if (visto [$. nombre]) sangrar--;
más {
prInd (sangría);
Imprimir ($ .nombre);
visto [$. name] = 1;
sangría ++;
}
}

Imprime el recorrido en profundidad del gráfico, comenzando con el nodo cuyo nombre es
ARGV [0], como una lista con sangría.

MEDIO AMBIENTE

GVPRPATH
Lista de directorios separados por dos puntos en los que se buscará el archivo especificado por
la opción -f. gvpr tiene una lista predeterminada incorporada. Si GVPRPATH no está definido, el
se utiliza la lista predeterminada. Si GVPRPATH comienza con dos puntos, la lista está formada por
adjuntando GVPRPATH a la lista predeterminada. Si GVPRPATH termina con dos puntos, la lista es
formado agregando la lista predeterminada a GVPRPATH. De otra manera, GVPRPATH se utiliza para
la lista.

En sistemas Windows, reemplace `` dos puntos '' por `` punto y coma '' en el párrafo anterior.

Utilice gvpr en línea utilizando los servicios de onworks.net