gvpr - Online na nuvem

PROGRAMA:

NOME

gvpr - digitalização de padrões gráficos e linguagem de processamento

SINOPSE

gvpr [-icnqV?] [ -o arquivo de saída ] [ -a args ] [ 'prog' | -f perfil ] [ arquivos ]

DESCRIÇÃO

gvpr (Anteriormente conhecido como gpr) é um editor de fluxo gráfico inspirado em awk. Ele copia a entrada
gráficos para sua saída, possivelmente transformando sua estrutura e atributos, criando novos
gráficos ou impressão de informações arbitrárias. O modelo gráfico é o fornecido por
libcgraph(3). Em particular, gvpr lê e escreve gráficos usando a linguagem de pontos.

Basicamente, gvpr atravessa cada gráfico de entrada, denotado por $G, visitando cada nó e borda,
combinando-o com as regras de ação de predicado fornecidas no programa de entrada. As regras são
avaliados em ordem. Para cada predicado avaliado como verdadeiro, a ação correspondente é
realizada. Durante a travessia, o nó atual ou borda sendo visitada é denotado por $.

Para cada gráfico de entrada, há um subgráfico de destino, denotado por $T, inicialmente vazio e usado
para acumular entidades escolhidas, e um gráfico de saída, $O, usado para o processamento final e, em seguida,
escrito na saída. Por padrão, o gráfico de saída é o gráfico de destino. O gráfico de saída
pode ser definido no programa ou, em um sentido limitado, na linha de comando.

OPÇÕES

As seguintes opções são suportadas:

-a args
A corda args é dividido em tokens separados por espaços em branco, com o indivíduo
tokens disponíveis como strings no gvpr programa como ARGV [0], ..., ARGV [ARGC-1].
Caracteres de espaço em branco dentro de substrings entre aspas simples ou duplas ou precedidos por um
barra invertida, são ignorados como separadores. Em geral, um caractere de barra invertida desliga
qualquer significado especial do caractere a seguir. Observe que os tokens derivados de
múltiplo -a sinalizadores são concatenados.

-c Use o gráfico de origem como o gráfico de saída.

-i Derive a extensão do subgráfico induzida pelo nó do gráfico de saída no contexto de
seu gráfico raiz.

-o arquivo de saída
Faz com que o fluxo de saída seja gravado no arquivo especificado; por padrão, a saída é
escrito stdout.

-f perfil
Use o conteúdo do arquivo especificado como o programa a ser executado na entrada. Se
perfil contém uma barra, o nome é considerado o caminho do arquivo.
Caso contrário, gvpr usará os diretórios especificados na variável de ambiente
GVPRPATH para procurar o arquivo. Se -f não é dado, gvpr usará o primeiro não
argumento de opção como o programa.

-q Desativa as mensagens de aviso.

-n Desativa a leitura antecipada do gráfico. Por padrão, a variável $ NG está definido para o próximo gráfico
ser processado. Isso requer uma leitura do próximo gráfico antes de processar o
gráfico atual, que pode bloquear se o próximo gráfico for gerado apenas em resposta a
alguma ação pertencente ao processamento do gráfico atual.

-V Faz com que o programa imprima informações sobre a versão e saia.

-? Faz com que o programa imprima informações de uso e saia.

OPERANDOS

O seguinte operando é compatível:

arquivos Nomes de arquivos contendo 1 ou mais gráficos na linguagem de pontos. Se não -f opção
é fornecido, o primeiro nome é removido da lista e usado como o programa de entrada.
Se a lista de arquivos estiver vazia, stdin será usada.

PROGRAMAS

A gvpr programa consiste em uma lista de cláusulas de ação de predicado, tendo uma das formas:

INÍCIO { açao }

BEG_G { açao }

N [ predicado ] { açao }

E [ predicado ] { açao }

END_G { açao }

END { açao }

Um programa pode conter no máximo um de cada um dos INÍCIO, END_G e END cláusulas. Lá pode
ser qualquer número de BEG_G, N e E declarações, a primeira aplicada a gráficos, a segunda a
nós, o terceiro às arestas. Eles são separados em blocos, um bloco que consiste em um
opcional BEG_G declaração e tudo N e E declarações até o próximo BEG_G declaração, se
qualquer. A semântica de nível superior de um gvpr programa são:

Avalie o INÍCIO cláusula, se houver.
Para cada gráfico de entrada G {
Para cada bloco {
Conjunto G como o gráfico atual e o objeto atual.
Avalie o BEG_G cláusula, se houver.
Para cada nó e borda em G {
Defina o nó ou borda como o objeto atual.
Avalie o N or E cláusulas, conforme apropriado.
}
}
Conjunto G como o objeto atual.
Avalie o END_G cláusula, se houver.
}
Avalie o END cláusula, se houver.

As ações do INÍCIO, BEG_G, END_G e END cláusulas são executadas quando as cláusulas são
avaliado. Por N or E cláusulas, o predicado ou a ação podem ser omitidos. Se lá
não é um predicado com uma ação, a ação é realizada em cada nó ou borda, como
apropriado. Se não houver nenhuma ação e o predicado for avaliado como verdadeiro, o associado
nó ou borda é adicionado ao gráfico de destino.

Os bloqueios são avaliados na ordem em que ocorrem. Dentro de um bloco, o N cláusulas
(E cláusulas, respectivamente) são avaliadas na ordem em que ocorrem. Observe, porém,
que dentro de um bloco, N or E as cláusulas podem ser entrelaçadas, dependendo da ordem de percurso.

Predicados e ações são sequências de declarações no dialeto C suportadas pelo
expr(3) biblioteca. A única diferença entre predicados e ações é que o primeiro
deve ter um tipo que pode ser interpretado como verdadeiro ou falso. Aqui o C usual
a convenção é seguida, na qual um valor diferente de zero é considerado verdadeiro. Isso incluiria
strings não vazias e referências não vazias a nós, arestas, etc. No entanto, se uma string pode
ser convertido em um inteiro, este valor é usado.

Além dos tipos de base C usuais (anular, int, carbonizar, flutuar, longo, não assinado e duplo),
gvpr fornece corda como sinônimo de Caracteres*, e os tipos baseados em gráficos nó_t, borda_t,
gráfico_t e objeto_t. O objeto_t tipo pode ser visto como um supertipo dos outros 3 concreto
tipos; o tipo de base correto é mantido dinamicamente. Além desses tipos de base, o
apenas outras expressões de tipo com suporte são matrizes (associativas).

As constantes seguem a sintaxe C, mas as strings podem ser citadas com qualquer "..." or '...'. gvpr
aceita comentários C ++, bem como comentários do tipo cpp. Para o último, se uma linha começar com
um caractere '#', o resto da linha é ignorado.

Uma declaração pode ser uma declaração de uma função, uma variável ou um array, ou um executável
declaração. Para declarações, há um único escopo. As declarações de matriz têm o formato:

tipo ordem [ type0 ]

onde type0 é opcional. Se for fornecido, o analisador fará com que todas as matrizes
os subscritos têm o tipo especificado. Se não for fornecido, objetos de todos os tipos podem ser
usado como subscrito. Como em C, variáveis ​​e matrizes devem ser declaradas. Em particular, um
variável não declarada será interpretada como o nome de um atributo de um nó, aresta ou
gráfico, dependendo do contexto.

As instruções executáveis ​​podem ser uma das seguintes:

{ [ afirmação ... ] }
expressão // comumente var = expressão
se ( expressão ) afirmação [ outro afirmação ]
para ( expressão ; expressão ; expressão ) afirmação
para ( ordem [ var ]) afirmação
forr ( ordem [ var ]) afirmação
enquanto ( expressão ) afirmação
trocar( expressão ) casas declarações
quebrar [ expressão ]
continuar [ expressão ]
retorno [ expressão ]
Os itens entre colchetes são opcionais.

Na segunda forma do para declaração e o para declaração, a variável var está definido para
cada valor usado como um índice na matriz especificada e, em seguida, o associado afirmação is
avaliado. Para índices numéricos e de string, os índices são retornados em ordem crescente
(decrescente) ordem numérica ou lexicográfica para para (para, respectivamente). Isso pode ser usado
para classificação.

As definições de função só podem aparecer no INÍCIO cláusula.

As expressões incluem as expressões C usuais. Comparações de strings usando == e != tratar o
operando à direita como um padrão para fins de correspondência de expressão regular. Padrões
usar ksh(1) sintaxe de padrão de correspondência de arquivo. (Para igualdade de string simples, use o strcmp
função.

gvpr tentará usar uma expressão como string ou valor numérico conforme apropriado. Ambos
Casts tipo C e modelos de função farão com que as conversões sejam realizadas, se possível.

Expressões de tipo gráfico (ou seja, gráfico_t, nó_t, borda_t, objeto_t) pode ser seguido por um
referência de campo na forma de .nome. O valor resultante é o valor do atributo
nomeado nome do objeto fornecido. Além disso, em certos contextos, um não declarado,
identificador não modificado é considerado um nome de atributo. Especificamente, esses identificadores
denotam atributos do nó ou borda atual, respectivamente, em N e E cláusulas, e o
gráfico atual em BEG_G e END_G cláusulas.

Como de costume no libcgraph(3) modelo, os atributos têm valores de string. Além disso, gvpr
suporta certos pseudo-atributos de objetos gráficos, não necessariamente com valor de string. Esses
refletem propriedades intrínsecas dos objetos gráficos e não podem ser definidas pelo usuário.

cabeça : nó_t
a ponta de uma borda.

cauda : nó_t
a cauda de uma borda.

nome : corda
o nome de uma aresta, nó ou gráfico. O nome de uma aresta tem a forma "<cauda-
nome>[]", Onde é "->"Ou"--" dependendo
se o gráfico é direcionado ou não. A parte do suporte [] só aparece se o
edge tem uma chave não trivial.

em grau : int
o indegree de um nó.

grau superior : int
o outdegree de um nó.

grau : int
o grau de um nó.

raiz : gráfico_t
o gráfico raiz de um objeto. A raiz de um gráfico raiz é ela mesma.

principal : gráfico_t
o gráfico pai de um subgrafo. O pai de um gráfico raiz é NULL

n_bordas : int
o número de arestas no gráfico

n_nós : int
o número de nós no gráfico

dirigido : int
verdadeiro (diferente de zero) se o gráfico for direcionado

rigoroso : int
verdadeiro (diferente de zero) se o gráfico for estrito

CONSTRUÍDAS EM FUNÇÕES

As funções a seguir são integradas ao gvpr. Essas funções retornando referências ao gráfico
objetos retornam NULL em caso de falha.

Gráficos e subgráfico
gráfico(s : corda, t : corda): gráfico_t
cria um gráfico cujo nome é s e cujo tipo é especificado pela string t.
Ignorando maiúsculas e minúsculas, os personagens U, D, S, N ter a interpretação não direcionada,
dirigido, estrito e não estrito, respectivamente. Se t é vazio, um dirigido, não
gráfico estrito é gerado.

subg(g : gráfico_t, s : corda): gráfico_t
cria um subgráfico no gráfico g com nome s. Se o subgrafo já existe, é
devolvida.

isSubg(g : gráfico_t, s : corda): gráfico_t
retorna o subgráfico no gráfico g com nome s, se existir, ou NULL de outra forma.

fstsubg(g : gráfico_t): gráfico_t
retorna o primeiro subgrafo no gráfico gou NULL se não existir.

nxtsubg(sg : gráfico_t): gráfico_t
retorna o próximo subgrafo após sgou NULL.

é Direto(g : gráfico_t): int
retorna verdadeiro se e somente se g é direcionado.

é estrito(g : gráfico_t): int
retorna verdadeiro se e somente se g é estrito.

nNós(g : gráfico_t): int
retorna o número de nós em g.

nExtremidades(g : gráfico_t): int
retorna o número de arestas em g.

Nodes
nó(sg : gráfico_t, s : corda): nó_t
cria um nó no gráfico g de nome s. Se esse nó já existir, ele será retornado.

subnó(sg : gráfico_t, n : nó_t): nó_t
insere o nó n no subgrafo g. Retorna o nó.

nófst(g : gráfico_t): nó_t
retorna o primeiro nó no gráfico gou NULL se não existir.

nxtnode(n : nó_t): nó_t
retorna o próximo nó após n no gráfico raiz, ou NULL.

nxtnode_sg(sg : gráfico_t, n : nó_t): nó_t
retorna o próximo nó após n in sgou NULL.

isNode(sg : gráfico_t, s : corda): nó_t
procura um nó no (sub) gráfico sg de nome s. Se tal nó existir, ele será retornado.
Caso contrário, NULL é devolvido.

isSubnode(sg : gráfico_t, n : nó_t): int
retorna diferente de zero se o nó n está no (sub) gráfico sg, ou zero caso contrário.

indegreeOf(sg : gráfico_t, n : nó_t): int
retorna o indegree do nó n no (sub) gráfico sg.

outdegreeOf(sg : gráfico_t, n : nó_t): int
retorna o outdegree do nó n no (sub) gráfico sg.

grau de(sg : gráfico_t, n : nó_t): int
retorna o grau de nó n no (sub) gráfico sg.

Arestas
Beira(t : nó_t, h : nó_t, s : corda): borda_t
cria uma aresta com nó de cauda t, nó principal h e nome s no gráfico raiz. Se o
o gráfico não é direcionado, a distinção entre os nós da cabeça e da cauda não é importante.
Se essa borda já existir, ela será retornada.

borda_sg(sg : gráfico_t, t : nó_t, h : nó_t, s : corda): borda_t
cria uma aresta com nó de cauda t, nó principal h e nome s no (sub) gráfico sg (e tudo
gráficos pais). Se o gráfico não for direcionado, a distinção entre a cabeça e a cauda
nós não é importante. Se essa borda já existir, ela será retornada.

sub-borda(g : gráfico_t, e : borda_t): borda_t
insere a borda e no subgrafo g. Retorna a borda.

isEdge(t : nó_t, h : nó_t, s : corda): borda_t
procura por uma aresta com nó de cauda t, nó principal h e nome s. Se o gráfico for
não direcionado, a distinção entre os nós da cabeça e da cauda não é importante. Se tal
borda existe, ele é retornado. De outra forma, NULL é devolvido.

isEdge_sg(sg : gráfico_t, t : nó_t, h : nó_t, s : corda): borda_t
procura por uma aresta com nó de cauda t, nó principal h e nome s no (sub) gráfico sg. Se o
o gráfico não é direcionado, a distinção entre os nós da cabeça e da cauda não é importante.
Se tal borda existir, ela será retornada. De outra forma, NULL é devolvido.

isSubedge(g : gráfico_t, e : borda_t): int
retorna diferente de zero se a borda e está no (sub) gráfico sg, ou zero caso contrário.

primeiro(n : nó_t): borda_t
retorna a primeira borda externa do nó n no gráfico raiz.

fstout_sg(sg : gráfico_t, n : nó_t): borda_t
retorna a primeira borda externa do nó n no (sub) gráfico sg.

nxtout(e : borda_t): borda_t
retorna a próxima saída após e no gráfico raiz.

nxtout_sg(sg : gráfico_t, e : borda_t): borda_t
retorna a próxima saída após e no gráfico sg.

tudo bem(n : nó_t): borda_t
retorna a primeira borda do nó n no gráfico raiz.

fstin_sg(sg : gráfico_t, n : nó_t): borda_t
retorna a primeira borda do nó n no gráfico sg.

nxtin(e : borda_t): borda_t
retorna o próximo passo após e no gráfico raiz.

nxtin_sg(sg : gráfico_t, e : borda_t): borda_t
retorna o próximo passo após e no gráfico sg.

Fstedge(n : nó_t): borda_t
retorna a primeira aresta do nó n no gráfico raiz.

fstedge_sg(sg : gráfico_t, n : nó_t): borda_t
retorna a primeira aresta do nó n no gráfico sg.

nxtedge(e : borda_t, nó_t): borda_t
retorna a próxima borda após e no gráfico raiz.

nxtedge_sg(sg : gráfico_t, e : borda_t, nó_t): borda_t
retorna a próxima borda após e no gráfico sg.

opp(e : borda_t, nó_t): nó_t
retorna o nó na borda e não é igual a n. Retorna NULL se n não é um nó de
e. Isso pode ser útil ao usar Fstedge e nxtedge enumerar os vizinhos de
n.

Gráfico I / O
escrever(g : gráfico_t): anular
impressões g em formato de ponto no fluxo de saída.

escreva G(g : gráfico_t, nome : corda): anular
impressões g em formato de ponto no arquivo nome.

escreverG(g : gráfico_t, fd : int): anular
impressões g em formato de ponto no fluxo aberto denotado pelo número inteiro fd.

leia G(nome : corda): gráfico_t
retorna um gráfico lido do arquivo nome. O gráfico deve estar em formato de ponto. Se não
gráfico pode ser lido, NULL é devolvido.

pãoG(fd : int): gráfico_t
retorna o próximo gráfico lido do fluxo aberto fd. Devoluções NULL no final do arquivo.

Gráfico miscelânea
excluir(g : gráfico_t, x : objeto_t): anular
deleta objeto x do gráfico g. Se g is NULL, a função usa o gráfico raiz de
x. Se x é um gráfico ou subgrafo, é fechado a menos que x está bloqueado.

é em(g : gráfico_t, x : objeto_t): int
retorna verdadeiro se x está no subgrafo g.

cloneG(g : gráfico_t, s : corda): gráfico_t
cria um clone de gráfico g com nome de s. Se s é "", o gráfico criado tem o
mesmo nome que g.

clonar(g : gráfico_t, x : objeto_t): objeto_t
cria um clone de objeto x no gráfico g. Em particular, o novo objeto tem o mesmo
atributos de nome / valor e estrutura como o objeto original. Se um objeto com o
mesma chave que x já existe, seus atributos são sobrepostos por aqueles de x e os votos de
objeto é retornado. Se uma borda for clonada, ambos os terminais serão clonados implicitamente.
Se um gráfico for clonado, todos os nós, arestas e subgráficos serão clonados implicitamente. Se x
é um gráfico, g pode ser NULL, caso em que o objeto clonado será uma nova raiz
gráfico. Neste caso, a chamada é equivalente a cloneG (x, "").

cópia(g : gráfico_t, x : objeto_t): objeto_t
cria uma cópia do objeto x no gráfico g, onde o novo objeto tem o mesmo nome / valor
atributos como o objeto original. Se um objeto com a mesma chave que x já
existe, seus atributos são sobrepostos por aqueles de x e o objeto é retornado. Observação
que esta é uma cópia superficial. Se x é um grafo, nenhum de seus nós, arestas ou subgráficos
são copiados para o novo gráfico. Se x é uma borda, os pontos finais são criados se
necessário, mas eles não são clonados. Se x é um gráfico, g pode ser NULL, nesse caso
o objeto clonado será um novo gráfico raiz.

cópia A(src : objeto_t, tgt : objeto_t): int
copia os atributos do objeto src objetar tgt, substituindo quaisquer valores de atributo
tgt pode ter inicialmente.

induzir(g : gráfico_t): anular
se estende g à sua extensão de subgrafo induzida por nó em seu grafo raiz.

temAttr(src : objeto_t, nome : corda): int
retorna diferente de zero se o objeto src tem um atributo cujo nome é nome. Retorna 0
de outra forma.

isAttr(g : gráfico_t, tipo : corda, nome : corda): int
retorna diferente de zero se um atributo nome foi definido em g para objetos do
dado tipo. Para nós, arestas e gráficos, tipo deve ser "N", "E" e "G",
respectivamente. Caso contrário, retorna 0.

obter(src : objeto_t, nome : corda): corda
retorna o valor do atributo nome no objeto src. Isso é útil para esses casos
quando nome conflita com uma das palavras-chave, como "head" ou "root". Se o
atributo não foi declarado no gráfico, a função irá inicializá-lo com
um valor padrão de "". Para evitar isso, deve-se usar o temAttr or isAttr função
para verificar se o atributo existe.

de ativos(src : objeto_t, nome : corda, valor : corda): int
define o valor do atributo nome no objeto src para valor. Retorna 0 em caso de sucesso,
diferente de zero em caso de falha. Ver obter acima.

obterDflt(g : gráfico_t, tipo : corda, nome : corda): corda
retorna o valor padrão do atributo nome em objetos em g do dado tipo. Para
nós, arestas e gráficos, tipo deve ser "N", "E" e "G", respectivamente. Se o
atributo não foi declarado no gráfico, a função irá inicializá-lo com
um valor padrão de "". Para evitar isso, deve-se usar o isAttr função para verificar
que o atributo existe.

definirDflt(g : gráfico_t, tipo : corda, nome : corda, valor : corda): int
define o valor padrão do atributo nome para valor em objetos em g do dado
tipo. Para nós, arestas e gráficos, tipo deve ser "N", "E" e "G", respectivamente.
Retorna 0 em caso de sucesso, diferente de zero em caso de falha. Ver obterDflt acima.

fstAttr(g : gráfico_t, tipo : corda): corda
retorna o nome do primeiro atributo de objetos em g do dado tipo. Para
nós, arestas e gráficos, tipo deve ser "N", "E" e "G", respectivamente. Se lá
não há atributos, a string "" é retornada.

nxtAttr(g : gráfico_t, tipo : corda, nome : corda): corda
retorna o nome do próximo atributo de objetos em g do dado tipo depois de
atributo nome. O argumento nome deve ser o nome de um atributo existente; isto
normalmente será o valor de retorno de uma chamada anterior para fstAttr or nxtAttr. Para
nós, arestas e gráficos, tipo deve ser "N", "E" e "G", respectivamente. Se lá
não há atributos restantes, a string "" é retornada.

compOf(g : gráfico_t, n : nó_t): gráfico_t
retorna o componente conectado do gráfico g contendo nó n, como um subgrafo de
g. O subgráfico contém apenas os nós. Pode-se usar induzir para adicionar as bordas. O
a função falha e retorna NULL if n não está em g. A conectividade é baseada no
gráfico não direcionado subjacente de g.

tipo de(vol : objeto_t): corda
retorna uma indicação do tipo de vol. Para nós, arestas e gráficos, ele retorna
"N", "E" e "G", respectivamente.

trancar(g : gráfico_t, v : int): int
implementa bloqueio de gráfico em gráficos raiz. Se o inteiro v é positivo, o gráfico é
definido para que chamadas futuras para excluir não tem efeito imediato. Se v é zero, o
o gráfico está desbloqueado. Se houve uma chamada para excluir o gráfico enquanto ele estava
bloqueado, o gráfico é fechado. Se v é negativo, nada é feito. Em todos os casos, o
o valor de bloqueio anterior é retornado.

Cordas
corrida(fmt : corda, ...): corda
retorna a string resultante da formatação dos valores das expressões
ocorrendo depois fmt de acordo com a printf(3) formato fmt

gsub(str : corda, pancadinha : corda): corda

gsub(str : corda, pancadinha : corda, substituir : corda): corda
Retorna str com todas as substrings correspondentes pancadinha excluído ou substituído por substituir,
respectivamente.

abaixo(str : corda, pancadinha : corda): corda

abaixo(str : corda, pancadinha : corda, substituir : corda): corda
Retorna str com a correspondência de substring mais à esquerda pancadinha excluído ou substituído por substituir,
respectivamente. Os caracteres '^' e '$' podem ser usados ​​no início e no final,
respectivamente, de pancadinha para ancorar o padrão no início ou no final de str.

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

substr(str : corda, idx : int, len : int): corda
retorna a substring de str começando na posição idx até o final da corda ou
de comprimento len, respectivamente. A indexação começa em 0. Se idx é negativo ou idx is
maior que o comprimento de str, ocorre um erro fatal. Da mesma forma, no segundo
caso, se len é negativo ou idx + len é maior que o comprimento de str, um fatal
ocorreu um erro.

strcmp(s1 : corda, s2 : corda): int
fornece a função C padrão strcmp(3).

comprimento(s : corda): int
retorna o comprimento da string s.

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

Rindex(s : corda, t : corda): int
retorna o índice do caractere na string s onde a cópia mais à esquerda (mais à direita)
de corda t pode ser encontrado, ou -1 se t não é uma substring de s.

partida(s : corda, p : corda): int
retorna o índice do caractere na string s onde a correspondência mais à esquerda do padrão
p pode ser encontrado, ou -1 se nenhuma substring de s fósforos p.

tupper(s : corda): corda
retorna uma versão de s com os caracteres alfabéticos convertidos em maiúsculas.

abaixar(s : corda): corda
retorna uma versão de s com os caracteres alfabéticos convertidos em minúsculas.

cânone(s : corda): corda
retorna uma versão de s apropriado para ser usado como um identificador em um arquivo dot.

html(g : gráfico_t, s : corda): corda
retorna uma versão `` mágica '' de s como uma string HTML. Isso normalmente será usado para
anexar um rótulo semelhante a HTML a um objeto gráfico. Observe que a string retornada vive em
g. Em particular, será liberado quando g está fechado, e para atuar como uma string HTML,
tem que ser usado com um objeto de g. Além disso, observe que o colchete angular
citações não devem fazer parte de s. Estes serão adicionados se g é escrito em DOT concreto
formato.

ishtml(s : corda): int
retorna diferente de zero se e somente se s é uma string HTML.

xOf(s : corda): corda
retorna a string "x" E se s tem a forma "x,y", onde ambos x e y são numéricos.

você(s : corda): corda
retorna a string "y" E se s tem a forma "x,y", onde ambos x e y são numéricos.

llOf(s : corda): corda
retorna a string "llx,lly" E se s tem a forma "llx,lly,urx,ury", onde tudo de llx,
lly, urx e ury são numéricos.

urOf (s)
urOf(s : corda): corda retorna a string "urx,ury" E se s tem a forma
"llx,lly,urx,ury", onde tudo de llx, lly, urx e ury são numéricos.

scanf(s : corda, fmt : corda, ...): int
escaneia a corda s, extraindo valores de acordo com o scanf(3) formato fmt. O
os valores são armazenados nos seguintes endereços fmt, endereços com o formulário &v,
onde v é alguma variável declarada do tipo correto. Retorna o número de itens
verificado com sucesso.

divisão(s : corda, arr : ordem, setembro : corda): int

divisão(s : corda, arr : ordem): int

tokens(s : corda, arr : ordem, setembro : corda): int

tokens(s : corda, arr : ordem): int
A divisão função quebra a string s em campos, enquanto o tokens função
divide a string em fichas. Um campo consiste em todos os caracteres não separadores
entre dois caracteres separadores ou o início ou fim da string. Assim, um
campo pode ser a string vazia. Um token é uma substring máxima não vazia, não
contendo um caractere separador. Os caracteres separadores são aqueles dados no
setembro argumento. Se setembro não for fornecido, o valor padrão é "\ t \ n". O
funções retornam o número de campos ou tokens.

Os campos e tokens são armazenados na matriz do argumento. A matriz deve ser corda-
avaliado e, se um tipo de índice for especificado, deve ser int. As entradas são indexadas
por inteiros consecutivos, começando em 0. Quaisquer valores já armazenados na matriz serão
ser sobrescrito ou ainda estar presente após o retorno da função.

I / O
impressão(...): anular
imprimir( expr, ... ) imprime uma representação de string de cada argumento por vez em
stdout, seguido por uma nova linha.

printf(fmt : corda, ...): int

printf(fd : int, fmt : corda, ...): int
imprime a string resultante da formatação dos valores das expressões seguintes
fmt de acordo com a printf(3) formato fmt. Retorna 0 em caso de sucesso. Por padrão,
imprime em stdout. Se o inteiro opcional fd é fornecido, a saída é escrita no
fluxo aberto associado com fd.

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

scanf(fd : int, fmt : corda, ...): int
verifica os valores de um fluxo de entrada de acordo com o scanf(3) formato fmt. O
os valores são armazenados nos seguintes endereços fmt, endereços com o formulário &v,
onde v é alguma variável declarada do tipo correto. Por padrão, ele lê de
stdin. Se o inteiro opcional fd é fornecido, a entrada é lida a partir do fluxo aberto
associado fd. Retorna o número de itens verificados com sucesso.

abrir F(s : corda, t : corda): int
abre o arquivo s como um fluxo de E / S. O argumento da string t especifica como o arquivo é
aberto. Os argumentos são os mesmos da função C abrir(3). Retorna um
inteiro denotando o fluxo ou -1 em caso de erro.

Como de costume, os fluxos 0, 1 e 2 já estão abertos como stdin, stdout e stderr,
respectivamente. Desde a gvpr pode utilizar stdin para ler os gráficos de entrada, o usuário deve
evite usar este fluxo.

fecharF(fd : int): int
fecha o fluxo aberto denotado pelo inteiro fd. Streams 0, 1 e 2 não podem ser
fechado. Retorna 0 em caso de sucesso.

leia L(fd : int): corda
retorna a próxima linha lida do fluxo de entrada fd. Ele retorna a string vazia ""
no final do arquivo. Observe que o caractere de nova linha é deixado na string retornada.

Matemática
exp(d : duplo): duplo
retorna e para o do poder.

log(d : duplo): duplo
retorna o log natural de d.

sqrt(d : duplo): duplo
retorna a raiz quadrada do duplo d.

prisioneiro de guerra(d : duplo, x : duplo): duplo
Retorna d levantado para o xo poder.

carrinho(d : duplo): duplo
retorna o cosseno de d.

sem(d : duplo): duplo
retorna o seno de d.

atan2(y : duplo, x : duplo): duplo
retorna o arco tangente de y / x no intervalo de -pi a pi.

MIN(y : duplo, x : duplo): duplo
retorna o mínimo de y e x.

MAX(y : duplo, x : duplo): duplo
retorna o máximo de y e x.

Associativo Arrays
# arr : int
retorna o número de elementos na matriz arr.

idx in arr : int
retorna 1 se um valor foi definido para o índice idx na matriz arr. Retorna 0
de outra forma.

não definido(v : ordem, idx): int
remove o item indexado por idx. Retorna 1 se o item existia, 0 caso contrário.

não definido(v : ordem): anular
reinicializa a matriz.

Gerais
saída(v : int): anular
causas gvpr sair com o código de saída v.

.(cmd : corda): int
fornece a função C padrão .(3). Executa cmd no shell do usuário
ambiente e retorna o status de saída do shell.

rand(): duplo
retorna um duplo pseudo-aleatório entre 0 e 1.

areia(): int

areia(v : int): int
define uma semente para o gerador de números aleatórios. O argumento opcional fornece a semente;
se for omitido, a hora atual será usada. O valor da semente anterior é retornado.
areia deve ser chamado antes de qualquer chamada para rand.

cor x(cor : corda, fmt : corda): corda
traduz uma cor de um formato para outro. O cor argumento deve ser uma cor
em uma das representações de string reconhecidas. O fmt o valor deve ser um de
"RGB", "RGBA", "HSV" ou "HSVA". Uma string vazia é retornada em caso de erro.

CONSTRUÍDAS EM VARIÁVEIS

gvpr fornece certas variáveis ​​especiais embutidas, cujos valores são definidos automaticamente por
gvpr dependendo do contexto. Exceto conforme observado, o usuário não pode modificar seus valores.

$ : objeto_t
denota o objeto atual (nó, aresta, gráfico) dependendo do contexto. Não é
disponível em INÍCIO or END cláusulas.

$F : corda
é o nome do arquivo de entrada atual.

$G : gráfico_t
denota o gráfico atual sendo processado. Não está disponível em INÍCIO or END
cláusulas.

$ NG : gráfico_t
denota o próximo gráfico a ser processado. Se $ NG é NULL, o gráfico atual $G é o
último gráfico. Observe que se a entrada vier de stdin, o último gráfico não pode ser
determinado até que o tubo de entrada seja fechado. Não está disponível em INÍCIO or END
cláusulas, ou se o -n bandeira é usada.

$O : gráfico_t
denota o gráfico de saída. Antes da travessia do gráfico, ele é inicializado para o destino
gráfico. Após travessia e qualquer END_G ações, se se refere a um gráfico não vazio,
esse gráfico é impresso no fluxo de saída. Só é válido em N, E e END_G
cláusulas. O gráfico de saída pode ser definido pelo usuário.

$T : gráfico_t
denota o gráfico de destino atual. É um subgrafo de $G e está disponível apenas em
N, E e END_G cláusulas.

$ tgtname : corda
denota o nome do gráfico de destino. Por padrão, é definido como "gvpr_result". Se
usado várias vezes durante a execução de gvpr, o nome será anexado com um
inteiro. Esta variável pode ser definida pelo usuário.

$ tvroot : nó_t
indica o nó inicial para uma profundidade (direcionada ou não direcionada) primeiro ou largura
primeiro percurso do gráfico (cf. $ tvtype abaixo). o valor padrão é NULL para
cada gráfico de entrada. Após a travessia na raiz fornecida, se o valor de $ tvroot
mudou, uma nova travessia começará com o novo valor de $ tvroot. Além disso, defina
$ tvnext abaixo.

$ tvnext : nó_t
indica o próximo nó inicial para uma profundidade (direcionada ou não direcionada) ou
largura - primeiro travessia do gráfico (cf. $ tvtype abaixo). Se uma travessia terminar
e os votos de $ tvroot não foi reiniciado, mas o $ tvnext foi definido, mas não usado, este
nó será usado como a próxima escolha para $ tvroot. o valor padrão é NULL para
cada gráfico de entrada.

$ tvedge : borda_t
Para travessias BFS e DFS, isso é definido como a borda usada para chegar ao atual
nó ou borda. No início de um percurso, ou para outros tipos de percurso, o
valor é NULL.

$ tvtype : tvtype_t
indica como gvpr atravessa um gráfico. Só pode levar um dos valores constantes
com o previx "TV_" descrito abaixo. TV_plano é o padrão.

Na biblioteca de gráficos subjacente gráfico(3), as arestas em gráficos não direcionados recebem um
direção arbitrária. Isso é usado para travessias, como TV_fwd, exigindo
bordas direcionadas.

ARGC : int
denota o número de argumentos especificados pelo -a args argumento da linha de comando.

ARGV : corda ordem
denota a matriz de argumentos especificados pelo -a args argumento da linha de comando. O
io argumento é dado por ARGV [i].

CONSTRUÍDAS EM CONSTANTES

Existem várias constantes simbólicas definidas por gvpr.

NULL : objeto_t
uma referência de objeto nula, equivalente a 0.

TV_plano : tvtype_t
um percurso simples e plano, com objetos gráficos visitados em uma ordem aparentemente arbitrária.

TV_ne : tvtype_t
uma travessia que primeiro visita todos os nós, depois todas as arestas.

TV_pt : tvtype_t
uma travessia que primeiro visita todas as arestas, depois todos os nós.

TV_dfs : tvtype_t
TV_postdfs : tvtype_t
TV_prepostdfs : tvtype_t
uma travessia do gráfico usando uma pesquisa em profundidade na base não direcionada
gráfico. Para fazer a travessia, gvpr irá verificar o valor de $ tvroot. Se este tem o
mesmo valor que tinha anteriormente (no início, o valor anterior é inicializado
para NULL.) gvpr irá simplesmente procurar por algum nodo não visitado e percorrer seus nodos conectados
componente. Por outro lado, se $ tvroot mudou, seu componente conectado
ser visitado, supondo que não tenha sido visitado anteriormente ou, se $ tvroot is NULL,
a travessia irá parar. Observe que usando TV_dfs e $ tvroot, é possível criar
um loop infinito.

Por padrão, o percurso é feito na pré-encomenda. Ou seja, um nó é visitado antes
todas as suas bordas não visitadas. Por TV_postdfs, todas as bordas não visitadas de um nó são
visitado antes do nó. Por TV_prepostdfs, um nó é visitado duas vezes, antes e
depois de todas as suas bordas não visitadas.

TV_fwd : tvtype_t
TV_postfwd : tvtype_t
TV_prepostfwd : tvtype_t
Uma travessia do gráfico usando uma pesquisa em profundidade no gráfico a seguir apenas
arcos para a frente. A escolha das raízes para a travessia é a mesma descrita para
TV_dfs acima. A ordem diferente de visitação especificada por TV_fwd, TV_postfwd
e TV_prepostfwd são os mesmos que os especificados pelos percursos análogos
TV_dfs, TV_postdfs e TV_prepostdfs.

TV_rev : tvtype_t
TV_postrev : tvtype_t
TV_prepostrev : tvtype_t
Uma travessia do gráfico usando uma pesquisa em profundidade no gráfico a seguir apenas
arcos reversos. A escolha das raízes para a travessia é a mesma descrita para
TV_dfs acima. A ordem diferente de visitação especificada por TV_rev, TV_postrev
e TV_prepostrev são os mesmos que os especificados pelos percursos análogos
TV_dfs, TV_postdfs e TV_prepostdfs.

TV_bfs : tvtype_t
Uma travessia do gráfico usando uma pesquisa em largura no gráfico, ignorando a borda
instruções. Veja o item em TV_dfs acima para o papel de $ tvroot.

EXEMPLOS

gvpr -i 'N [color == "blue"]' arquivo.gv

Gere o subgrafo induzido por nós de todos os nós com a cor azul.

gvpr -c 'N [color == "blue"] {color = "vermelho"}' arquivo.gv

Torne todos os nós azuis vermelhos.

INÍCIO { int n, e; int tot_n = 0; int carregar = 0; }
BEG_G {
n = nNodes ($ G);
e = nEdges ($ G);
printf ("% d nós %d bordas % s \ n ", n, e, $ G.name);
tot_n += n;
carregar += e;
}
END { printf ("% d nós %d bordas total \ n ", tot_n, carregar) }

Versão do programa gc.

gvpr -c ""

Equivalente a nop.

BEG_G { gráfico_t g = gráfico ("mesclar", "S"); }
E {
nó_t h = clone (g, $. cabeça);
nó_t t = clone (g, $. cauda);
borda_t e = borda (t, h, "");
e.peso = e.peso + 1;
}
END_G { $O = g; }

Produz uma versão estrita do gráfico de entrada, onde o atributo de peso de uma aresta
indica quantas arestas do gráfico de entrada a aresta representa.

INÍCIO {nó_t n; int deg []}
E {deg [cabeça] ++; deg [tail] ++; }
END_G {
para (deg [n]) {
printf ("deg [% s] = % d \ n ", s.nome, deg [n]);
}
}

Calcula os graus de nós com arestas.

INÍCIO {
int i, recuar;
int visto [string];
anular prInd (int cnt) {
para (i = 0; i < cnt; i ++) printf (" ");
}
}
BEG_G {

$ tvtype = TV_prepostfwd;
$ tvroot = nó ($, ARGV [0]);
}
N {
if (visto [$. name]) recuar--;
outro {
prInd (recuo);
impressão ($ .name);
visto [$. name] = 1;
recuo ++;
}
}

Imprime a travessia em profundidade do gráfico, começando com o nó cujo nome é
ARGV [0], como uma lista recuada.

MEIO AMBIENTE

GVPRPATH
Lista separada por vírgulas de diretórios a serem pesquisados ​​para encontrar o arquivo especificado por
a opção -f. gvpr tem uma lista padrão embutida. GVPRPATH não está definido, o
lista padrão é usada. Se GVPRPATH começa com dois pontos, a lista é formada por
acrescentando GVPRPATH para a lista padrão. Se GVPRPATH termina com dois pontos, a lista é
formado anexando a lista padrão a GVPRPATH. De outra forma, GVPRPATH é usado para
a lista.

Em sistemas Windows, substitua `` dois pontos '' por `` ponto-e-vírgula '' no parágrafo anterior.

Use gvpr online usando serviços onworks.net