ragel - Online na nuvem

PROGRAMA:

NOME

ragel - compila linguagens regulares em máquinas de estado executáveis

SINOPSE

trapo [opções] lima

DESCRIÇÃO

Ragel compila máquinas de estado finito executáveis ​​a partir de linguagens regulares. Ragel pode
gerar código C, C ++, Objective-C, D, Go ou Java. As máquinas de estado Ragel não podem apenas
reconhece sequências de bytes como fazem as máquinas de expressão regular, mas também pode executar código em
pontos arbitrários no reconhecimento de uma linguagem regular. O código do usuário é incorporado usando
operadores embutidos que não interrompem a sintaxe regular da linguagem.

A linguagem central consiste em operadores de expressão regular padrão, como união,
concatenação e estrela kleene, acompanhadas por operadores de incorporação de ações. Ragel também
fornece operadores que permitem controlar qualquer não-determinismo que você crie, construa
scanners usando o paradigma de correspondência mais longa e construir máquinas de estado usando o statechart
modelo. Também é possível influenciar a execução de uma máquina de estado de dentro de um
ação incorporada saltando ou chamando para outras partes da máquina e reprocessando
entrada.

Ragel fornece uma interface muito flexível para a linguagem hospedeira que tenta colocar
restrições mínimas sobre como o código gerado é usado e integrado no
aplicativo. O código gerado não possui dependências.

OPÇÕES

-h, -H, -?, --Socorro
Exibir ajuda e sair.

-v Imprime informações sobre a versão e sai.

-o lima
Grave a saída no arquivo. Se -o não for fornecido, um nome de arquivo padrão é escolhido por
substituindo a extensão do arquivo de entrada. Para arquivos de origem que terminam em .rh, o
o sufixo .h é usado. Para todos os outros arquivos de origem, um sufixo baseado no idioma de saída
é usado (.c, .cpp, .m, etc.). Se -o não for fornecido para a saída do Graphviz, o
O arquivo de ponto é gravado na saída padrão.

-s Imprima algumas estatísticas sobre o erro padrão.

--error-format = gnu
Imprimir mensagens de erro usando o formato "arquivo: linha: coluna:" (padrão)

--error-format = msvc
Imprima mensagens de erro usando o formato "arquivo (linha, coluna):"

-d Não remova ações duplicadas das listas de ações.

-I dir
Adicione dir à lista de diretórios para pesquisar arquivos incluídos e importados

-n Não execute minimização de estado.

-m Execute a minimização uma vez, no final da compilação da máquina de estado.

-l Minimize após quase todas as operações. Listas de operações semelhantes, como sindicatos são
minimizado uma vez no final. Esta é a opção de minimização padrão.

-e Minimize após cada operação.

-x Compile as máquinas de estado e emita uma representação XML dos dados do host e do
máquinas.

-V Gere um arquivo dot para o Graphviz.

-p Exibir caracteres imprimíveis nas etiquetas.

-S
Especificação FSM para saída.

-M
Definição / instanciação da máquina para saída.

-C A linguagem hospedeira é C, C ++, Obj-C ou Obj-C ++. Este é o idioma padrão do host
opção.

-D O idioma do host é D.

-J A linguagem do host é Java.

-Z O idioma do host é Go.

-R A linguagem hospedeira é Ruby.

-L Inibir a escrita de diretivas #line.

-T0 (C / D / Java / Ruby / C # / Go) Gere um FSM baseado em tabela. Este é o estilo de código padrão.
O FSM baseado em tabela representa a máquina de estado como dados estáticos. Existem mesas
de estados, transições, indícios e ações. O estado atual é armazenado em um
variável. A execução é um loop que parece dado o estado atual e
o caractere atual a ser processado procura a transição a ser realizada usando uma pesquisa binária,
executa todas as ações e passa para o estado de destino. Em geral, a mesa dirigida
FSM produz um binário menor e requer uma compilação de linguagem host menos cara
mas resulta em um código de execução mais lento. O FSM baseado em tabela é adequado para qualquer FSM.

-T1 (C / D / Ruby / C # / Go) Gere um FSM mais rápido baseado em tabelas expandindo listas de ação em
o código de execução da ação.

-F0 (C / D / Ruby / C # / Go) Gere um FSM baseado em tabela plana. As transições são representadas como
uma matriz indexada pelo caractere do alfabeto atual. Isso elimina a necessidade de um
busca binária para localizar transições e produzir código mais rápido, no entanto, é apenas
adequado para pequenos alfabetos.

-F1 (C / D / Ruby / C # / Go) Gere um FSM mais rápido baseado em tabela plana expandindo listas de ação
no código de execução da ação.

-G0 (C / D / C # / Go) Gerar um FSM controlado por goto. O FSM controlado por goto representa o estado
máquina como uma série de instruções goto. Enquanto na máquina, o estado atual é
armazenado pelo ponteiro de instrução do processador. A execução é uma função simples
onde o controle é passado de estado para estado usando gotos. Em geral, o goto FSM
produz código mais rápido, mas resulta em um binário maior e um host mais caro
compilar a linguagem.

-G1 (C / D / C # / Go) Gere um FSM mais rápido impulsionado por goto expandindo listas de ação no
ação executar código.

-G2 (C / D / Go) Gere um FSM conduzido por goto realmente rápido incorporando listas de ação no
código de controle de máquina estatal.

-P (C / D) N-Way Split FSM movido a goto realmente rápido.

RAGEL INPUT

NOTA: Esta é uma breve descrição da entrada de Ragel. Ragel é descrito com mais detalhes
no guia do usuário disponível na página inicial (veja abaixo).

Ragel normalmente passa os arquivos de entrada direto para a saída. Quando vê um FSM
especificação que contém instanciações de máquina ela pára para gerar a máquina de estado.
Se houver instruções write (como "write exec"), o ragel emite o correspondente
código. Pode haver qualquer número de especificações FSM em um arquivo de entrada. Um FSM multilinha
especificação começa com '%% {' e termina com '} %%'. Uma especificação FSM de linha única
começa com %% e termina na primeira nova linha.

FSM AFIRMAÇÕES

Lavagem Nome:
Defina o nome da máquina. Se fornecido, deve ser a primeira declaração.

Alfabeto Tipo:
Defina o tipo de dados do alfabeto.

Obter chave:
Especifique como recuperar o caractere do alfabeto do tipo de elemento.

Incluir:
Incluir uma máquina com o mesmo nome da atual ou com um nome diferente no
arquivo atual ou algum outro arquivo.

Açao Social Definição:
Defina uma ação que pode ser invocada pelo FSM.

fsm Definição, Instanciação e Longest Match Instanciação:
Usado para construir FSMs. Descrição da sintaxe nas próximas seções.

Acesse em:
Especifique como acessar as variáveis ​​de máquina de estado persistente.

Escreva: Escreva algum componente da máquina.

Variável:
Substitua os nomes das variáveis ​​padrão (p, pe, cs, act, etc).

BASIC MÁQUINAS

As máquinas básicas são os operandos básicos das expressões regulares da linguagem.

'Olá'
Concat literal. Produz uma concatenação dos caracteres na string. Apoia
sequências de escape com '\'. O resultado terá um estado inicial e uma transição para
um novo estado para cada caractere na string. O último estado da sequência será
ser finalizado. Para tornar a string insensível a maiúsculas e minúsculas, acrescente um 'i' à string, como
em 'cmd'i.

"Olá"
Idêntica à versão de aspas simples.

[Olá]
Ou literal. Produz uma união de personagens. Suporta intervalos de caracteres com '-',
negar o sentido da união com um '^' inicial e sequências de escape com '\'.
O resultado terá dois estados com uma transição entre eles para cada personagem
ou intervalo.

NOTA: '', "" e [] produzem FSMs nulos. Máquinas nulas têm um estado que é ao mesmo tempo um começo
estado e um estado final e coincidir com a string de comprimento zero. Uma máquina nula pode ser criada
com a máquina nula embutida.

número inteiro
Faz uma máquina de dois estados com uma transição no número inteiro fornecido.

feitiço Faz uma máquina de dois estados com uma transição no número hexadecimal fornecido.

/ simple_regex /
Uma expressão regular simples. Suporta a notação '.', '*' E '[]', caractere
varia com '-', negando o sentido de uma expressão OR com '^' inicial e
sequências de escape com '\'. Também suporta um sinalizador final: i. Use-o para produzir um
expressão regular que não faz distinção entre maiúsculas e minúsculas, como em / GET / i.

cama .. cama
Especifica um intervalo. Os limites superior e inferior permitidos são literais concat de
comprimento um e máquinas numéricas. Por exemplo, 0x10..0x20, 0..63 e 'a' .. 'z' são
intervalos válidos.

variable_name
Faz referência à definição da máquina atribuída ao nome da variável fornecido.

máquina_construída
Existem várias máquinas embutidas disponíveis. Eles são todos duas máquinas de estado para
o propósito de combinar classes comuns de personagens. Eles são:

qualquer Qualquer caractere do alfabeto.

ascii Caracteres Ascii 0..127.

estender Personagens estendidos Ascii. Este é o intervalo -128..127 para alfabetos com sinais
e o intervalo de 0..255 para alfabetos não assinados.

alfa Caracteres alfabéticos / [A-Za-z]/.

dígito Dígitos / [0-9]/.

alnum Alfanuméricos / [0-9A-Za-z]/.

diminuir Caracteres minúsculos / [az]/.

superior Caracteres maiúsculos / [AZ]/.

xdígito Dígitos hexadecimais / [0-9A-Fa-f]/.

controle Caracteres de controle 0..31.

gráfico Caracteres gráficos / [! - ~]/.

impressão Caracteres imprimíveis / [- ~]/.

ponto Pontuação. Caracteres gráficos que não são alfanuméricos
/ [! - /: - @ \ [- `{- ~]/.

espaço Espaço em branco / [\ t \ v \ f \ n \ r]/.

nulo String de comprimento zero. Equivalente a '', "" e [].

vazio Conjunto vazio. Não corresponde a nada.

BREVE OPERADOR REFERÊNCIA

Os operadores são agrupados por precedência, sendo o grupo 1 o mais baixo e o grupo 6 o mais alto.

GRUPO 1:

expr , expr
Junte as máquinas sem desenhar qualquer transição, configurando um estado inicial ou
quaisquer estados finais. O estado inicial deve ser especificado explicitamente com o rótulo "início".
Os estados finais podem ser especificados com as transições de um épsilon para o implicitamente
criado estado "final".

GRUPO 2:

expr | expr
Produz uma máquina que corresponde a qualquer string na máquina um ou na máquina dois.

expr & expr
Produz uma máquina que corresponde a qualquer string que esteja na máquina um e na máquina
dois.

expr - expr
Produz uma máquina que corresponde a qualquer string que esteja na máquina um, mas não em
máquina dois.

expr -- expr
Subtração forte. Corresponde a qualquer string na máquina que não tenha nenhuma string
na máquina dois como substring.

GRUPO 3:

expr . expr
Produz uma máquina que combina todas as cordas na máquina um seguido por todos os
cordas na máquina dois.

expr :> expr
Concatenação protegida por entrada: termina a máquina um ao entrar na máquina dois.

expr : >> expr
Concatenação protegida por término: termina a máquina um quando a máquina dois termina.

expr <: expr
Concatenação com proteção à esquerda: dá uma prioridade mais alta à máquina um.

NOTA: A concatenação é o operador padrão. Duas máquinas próximas uma da outra sem
operador entre eles resulta na operação de concatenação.

GRUPO 4:

rotular: expr
Anexa um rótulo a uma expressão. Os rótulos podem ser usados ​​por transições épsilon e
instruções fgoto e fcall em ações. Observe também que a referência de uma máquina
definição causa a criação implícita de rótulo com o mesmo nome.

GRUPO 5:

expr -> rótulo
Desenha uma transição épsilon para o estado definido pelo rótulo. O rótulo deve ser um nome em
o escopo atual. As transições do Epsilon são resolvidas quando os operadores de vírgula são
avaliada e na raiz da árvore de expressão da máquina
atribuição / instanciação.

GRUPO 6: Opções

Uma ação pode ser um nome predefinido com uma instrução de ação ou pode ser especificada diretamente
com '{' e '}' na expressão.

expr > açao
Incorpora ação nas transições iniciais.

expr @ açao
Incorpora ação em transições que vão para um estado final.

expr $ açao
Incorpora ação em todas as transições. Não inclui transições de saída pendentes.

expr % açao
Incorpora ação nas transições pendentes dos estados finais.

GRUPO 6: EOF Opções

Quando a rotina de término de uma máquina é chamada, as ações EOF do estado atual são executadas.

expr >/ açao
Incorpore uma ação EOF ao estado inicial.

expr </ açao
Incorpore uma ação EOF em todos os estados, exceto no estado inicial.

expr $/ açao
Incorpore uma ação EOF em todos os estados.

expr %/ açao
Incorpore uma ação EOF nos estados finais.

expr @/ açao
Incorpore uma ação EOF em todos os estados que não são finais.

expr <> / açao
Incorpore uma ação EOF em todos os estados que não são o estado inicial e que não são
final (estados intermediários).

GRUPO 6: Global erro Opções

As ações de erro global são armazenadas em estados até que a máquina de estado final tenha sido totalmente
construído. Eles são então transferidos para transições de erro, dando o efeito de um
ação padrão.

expr >! açao
Incorpore uma ação de erro global ao estado inicial.

expr <! açao
Incorpore uma ação de erro global em todos os estados, exceto o estado inicial.

expr $! açao
Incorpore uma ação de erro global em todos os estados.

expr %! açao
Incorpore uma ação de erro global aos estados finais.

expr @! açao
Incorpore uma ação de erro global em todos os estados que não são finais.

expr <>! açao
Incorpore uma ação de erro global em todos os estados que não são o estado inicial e são
não final (estados intermediários).

GRUPO 6: Locais de erro Opções

Ações de erro locais são armazenadas em estados até que a máquina nomeada seja totalmente construída.
Eles são então transferidos para transições de erro, dando o efeito de uma ação padrão para
uma seção da máquina total. Observe que o nome pode ser omitido, caso em que o
a ação será transferida para ações de erro na construção da máquina atual.

expr >^ açao
Incorpore uma ação de erro local ao estado inicial.

expr <^ açao
Incorpore uma ação de erro local em todos os estados, exceto o estado inicial.

expr $^ açao
Incorpore uma ação de erro local em todos os estados.

expr %^ açao
Incorpore uma ação de erro local nos estados finais.

expr @^ açao
Incorpore uma ação de erro local em todos os estados que não são finais.

expr <> ^ açao
Incorpore uma ação de erro local em todos os estados que não são o estado inicial e são
não final (estados intermediários).

GRUPO 6: Declarar Opções

As ações de estado são armazenadas em estados e executadas sempre que a máquina entra em um
Estado. Isso inclui transições regulares e transferências de controle, como fgoto. Observação
que define o estado atual de fora da máquina (por exemplo, durante
inicialização) não conta como uma transição para um estado.

expr >~ açao
Incorpore uma ação de ação para o estado no estado inicial.

expr <~ açao
Incorpore uma ação para o estado em todos os estados, exceto o estado inicial.

expr $~ açao
Incorpore uma ação para o estado em todos os estados.

expr %~ açao
Incorpore uma ação para o estado nos estados finais.

expr @~ açao
Incorpore uma ação para o estado em todos os estados que não são finais.

expr <> ~ açao
Incorpore uma ação para o estado em todos os estados que não são o estado inicial e não são
final (estados intermediários).

GRUPO 6: De-estado Opções

As ações do estado são executadas sempre que um estado faz uma transição em um personagem. Esse
inclui a transição de erro e uma transição para o self.

expr >* açao
Incorpore uma ação do estado inicial ao estado inicial.

expr <* açao
Incorpore uma ação do estado em cada estado, exceto o estado inicial.

expr $* açao
Incorpore uma ação do estado em todos os estados.

expr %* açao
Incorpore uma ação do estado aos estados finais.

expr @* açao
Incorpore uma ação do estado em todos os estados que não são finais.

expr <> * açao
Incorpore uma ação do estado em todos os estados que não são o estado inicial e não são
final (estados intermediários).

GRUPO 6: Prioridade Atribuição

As prioridades são atribuídas a nomes nas transições. Apenas as prioridades com o mesmo nome são
permissão para interagir. Na primeira forma de prioridades, o nome padrão é o nome do
definição da máquina em que a prioridade é atribuída. Transições não têm padrão
prioridades.

expr > int
Atribui a prioridade interna em todas as transições que saem do estado inicial.

expr @ int
Atribui a prioridade interna em todas as transições que vão para um estado final.

expr $ int
Atribui a prioridade interna em todas as transições existentes.

expr % int
Atribui a prioridade interna em todas as transições de saída pendentes.

Uma segunda forma de atribuição de prioridade permite ao programador especificar o nome para o qual
a prioridade é atribuída, permitindo que as interações ultrapassem os limites da definição da máquina.

expr > (nome, int)
Atribui a prioridade int para nomear em todas as transições que saem do estado inicial.

expr @ (nome, interno)
Atribui a prioridade int para nomear em todas as transições que vão para um estado final.

expr $ (nome, interno)
Atribui a prioridade int para nomear em todas as transições existentes.

expr % (nome, interno)
Atribui a prioridade int para nomear em todas as transições de saída pendentes.

GRUPO 7:

expr * Produz a estrela kleene de uma máquina. Corresponde a zero ou mais repetições do
máquina.

expr **
Estrela Kleene de correspondência mais longa. Esta versão do kleene star coloca uma prioridade mais alta em
ficar na máquina durante o processo de embrulhar e recomeçar. Este operador é
equivalente a ((expr) $ 0% 1) *.

expr ? Produz uma máquina que aceita a máquina fornecida ou a string nula. Este operador
é equivalente a (expr | '').

expr + Produz a máquina concatenada com a própria estrela kleen. Corresponde a um ou
mais repetições da máquina. Este operador é equivalente a (expr. Expr *).

expr {não}
Produz uma máquina que corresponde exatamente a n repetições de expr.

expr {, n}
Produz uma máquina que corresponde a qualquer lugar de zero a n repetições de expr.

expr {n,}
Produz uma máquina que corresponde a n ou mais repetições de expr.

expr {n, m}
Produz uma máquina que combina n a m repetições de expr.

GRUPO 8:

! expr Produz uma máquina que corresponde a qualquer string não compatível com a máquina fornecida. Esse
operador é equivalente a (* extend - expr).

^ expr Negação no nível do personagem. Corresponde a qualquer caractere único que não corresponda ao único
personagem máquina expr.

GRUPO 9:

( expr )
Força a precedência nos operadores.

VALORES DISPONÍVEL IN CÓDIGO BLOCOS

fc O personagem atual. Equivalente a * p.

fpc Um ponteiro para o personagem atual. Equivalente a p.

peles Um valor inteiro que representa o estado atual.

Ftargs Um valor inteiro que representa o estado de destino.

fentry ( )
Um valor inteiro que representa o ponto de entrada .

AFIRMAÇÕES DISPONÍVEL IN CÓDIGO BLOCOS

segurar; Não avance sobre o personagem atual. Equivalente a --p ;.

fexec ;
Define o caractere atual para outra coisa. Equivalente a p = ( ) -1;

vá para ;
Salte para a máquina definida por .

vá para * ;
Salte para o ponto de entrada fornecido por . A expressão deve ser avaliada como um inteiro
valor que representa um estado.

próximo ;
Defina o próximo estado como o ponto de entrada definido por . A declaração fnext
não pula imediatamente para o estado especificado. Qualquer código de ação após o
declaração é executada.

próximo * ;
Defina o próximo estado como o ponto de entrada fornecido por . A expressão deve
avalia como um valor inteiro que representa um estado.

chamar ;
Ligue para a máquina definida por . O próximo traste irá saltar para o alvo do
transição na qual a ação é invocada.

chamar * ;
Ligue para o ponto de entrada fornecido por . O próximo traste irá saltar para o alvo do
transição na qual a ação é invocada.

fricção; Retorne ao estado de destino da transição em que a última fcall foi feita.

pausa;
Salve o estado atual e saia imediatamente da máquina.

CRÉDITOS

Ragel foi escrito por Adrian Thurston[email protegido]>. Saída Objective-C
contribuição de Erich Ocean. Saída D contribuída por Alan West. Saída Ruby contribuída por
Victor Hugo Borja. Geração de código C Sharp contribuído por Daniel Tang. Contribuições para
Geração de código Java por Colin Fleming. Geração de código Go contribuído por Justine Tunney.

Use ragel online usando serviços onworks.net