recursão esquerda - Left recursion

Na teoria linguagem formal de ciência da computação , recursão esquerda é um caso especial de recursão , onde uma string é reconhecido como parte de uma linguagem pelo fato de que ele se decompõe em uma string a partir desse mesmo idioma (à esquerda) e um sufixo (em o certo). Por exemplo, pode ser reconhecido como uma soma porque pode ser dividida em , também uma soma, e , um sufixo adequado. ${\ Displaystyle 1 + 2 + 3}$${\ Displaystyle 1 + 2}$${\ Displaystyle {} 3}$

Em termos de gramática livre de contexto , um não-terminal está à esquerda-recursiva se o símbolo mais à esquerda em uma das suas produções é em si (no caso de recursividade esquerda directo) ou pode ser feito em si por uma sequência de substituições (no caso de indirecta recursão à esquerda).

Definição

A gramática é deixado-recursiva se e somente se existe um símbolo não-terminal que pode derivar de uma forma sentencial com ele mesmo como o símbolo mais à esquerda. simbolicamente, ${\ A displaystyle}$

${\ Displaystyle A \ Rightarrow ^ {+} A \ alfa}$,

onde indica a operação de fazer uma ou mais substituies, e é qualquer sequência de símbolos terminais e não terminais. ${\ Displaystyle \ Rightarrow ^ {+}}$${\ Displaystyle \ alfa}$

recursão direta esquerda

recursão direta esquerdo ocorre quando a definição pode ser satisfeita com apenas uma substituição. Ela exige uma regra da forma

${\ Displaystyle A \ a A \ alfa}$

onde é uma sequência de não-terminais e terminais. Por exemplo, a regra ${\ Displaystyle \ alfa}$

${\ Displaystyle {\ mathit {Expressão}} \ to {\ mathit {Expressão}} + {\ mathit {Termo}}}$

está diretamente deixou-recursiva. A da esquerda para a direita analisador descendente recursivo para esta regra pode parecer

void Expression() {
  Expression();
  match('+');
  Term();
}

e tal código cairia em recursão infinita quando executado.

Indireta recursão esquerda

recursão esquerda indireta ocorre quando a definição de recursão esquerda está satisfeito através de várias substituições. Ela implica um conjunto de regras seguindo o padrão

${\ A_ displaystyle {0} \ a \ _ beta {0} A_ {1} \ _ alfa {0}}$

${\ A_ displaystyle {1} \ a \ _ beta {1} A_ {2} \ _ alfa {1}}$

${\ displaystyle \ cdots}$

${\ A_ displaystyle {n} \ a \ beta _ {n} A_ {0} \ alfa _ {n}}$

onde são sequências que podem cada produzem a cadeia vazia , enquanto podem ser quaisquer sequências de símbolos terminais e não terminais de todo. Note-se que estas sequências podem ser vazio. a derivação ${\ Displaystyle \ beta _ {0}, \ beta _ {1}, \ ldots, \ beta _ {n}}$${\ Displaystyle \ _ alfa {0}, \ _ alfa {1}, \ ldots, \ alfa _ {n}}$

${\ A_ displaystyle {0} \ Rightarrow \ beta _ {0} A_ {1} \ alfa _ {0} \ Rightarrow ^ {+} A_ {1} \ alfa _ {0} \ Rightarrow \ beta _ {1} A_ {2} \ alfa _ {1} \ alfa _ {0} \ Rightarrow ^ {+} \ cdots \ Rightarrow ^ {+} A_ {0} \ alfa _ {n} \ pontos \ alfa _ {1} \ alfa _ {0}}$

em seguida, dá como mais à esquerda, na sua forma sentenciai final. ${\ A_ displaystyle {0}}$

Removendo recursão esquerda

Recursão esquerda muitas vezes coloca problemas para os analisadores, ou porque ele leva-los para recursão infinita (como no caso da maioria dos analisadores top-down ) ou porque esperam regras de uma forma normal que o proíbe (como no caso de muitos bottom-up analisadores , incluindo o algoritmo cyk ). Portanto, uma gramática é muitas vezes pré-processado para eliminar a recursão esquerda.

Removendo recursão esquerda direto

O algoritmo geral para remover recursão direta esquerda segue. Várias melhorias para este método foram feitas. Para um não-terminal deixou-recursiva , descartar quaisquer regras da forma e considerar aqueles que permanecem: ${\ A displaystyle}$${\ Displaystyle A \ rightarrow A}$

${\ Displaystyle A \ rightarrow A \ _ alfa {1} \ meados \ ldots \ meados Um \ alfa _ {n} \ meados \ beta _ {1} \ meados \ ldots \ meados \ beta _ {m}}$

Onde:

• cada é uma sequência não vazio de não-terminais e os terminais, e${\ Displaystyle \ alfa}$
• cada é uma sequência de não-terminais e os terminais que não começa com .${\ Displaystyle \ beta}$${\ A displaystyle}$

Substitua-os com dois conjuntos de produções, um conjunto para : ${\ A displaystyle}$

${\ Displaystyle A \ rightarrow \ beta _ {1} A ^ {\ privilegiada} \ mid \ ldots \ mid \ beta _ {m} A ^ {\ privilegiada}}$

e outro conjunto para o não-terminal fresco (muitas vezes chamado de "cauda" ou o "resto"): ${\ A displaystyle '}$

${\ A displaystyle ^ {\ privilegiada} \ rightarrow \ alpha _ {1} A ^ {\ privilegiada} \ mid \ ldots \ mid \ alpha _ {n} A ^ {\ privilegiada} \ mid \ epsilon}$

Repita este processo até que não haja restos de recursão esquerda diretos.

Como exemplo, considere o conjunto de regras

${\ Displaystyle {\ mathit {Expressão}} \ rightarrow {\ mathit {Expressão}} + {\ mathit {Expressão}} \ meados {\ mathit {Integer}} \ meados {\ mathit {String}}}$

Esta poderia ser reescrito para evitar recursão esquerdo como

${\ Displaystyle {\ mathit {Expressão}} \ rightarrow {\ mathit {Integer}} \, {\ mathit {Expressão}} '\ meados {\ mathit {String}} \, {\ mathit {Expressão}}'}$

${\ Displaystyle {\ mathit {Expressão}} '\ rightarrow {} + {\ mathit {Expressão}} \, {\ mathit {Expressão}}' \ mid \ epsilon}$

Removendo todos os recursão esquerda

Ao estabelecer uma ordenação topológica em nonterminals, o processo acima pode ser estendido para também eliminar a recursão esquerda indireta:

Entradas Uma gramática: um conjunto de não-terminais e suas produções${\ A_ displaystyle {1}, \ ldots, A_ {n}}$

Saída Uma gramática modificada gerando a mesma língua, mas sem recursão esquerda

1. Para cada não-terminal :${\ A_ displaystyle {i}}$
   1. Repita até uma iteração deixa a gramática inalterada:
      1. Para cada regra , sendo uma seqüência de terminais e não terminais:${\ A_ displaystyle {i} \ rightarrow \ alpha _ {i}}$${\ Displaystyle \ alpha _ {i}}$
         1. Se começa com um não-terminal e :${\ Displaystyle \ alpha _ {i}}$${\ Displaystyle A_ {j}}$${\ J displaystyle <i}$
            1. Vamos ser sem o seu líder .${\ Displaystyle \ beta _ {i}}$${\ Displaystyle \ alpha _ {i}}$${\ Displaystyle A_ {j}}$
            2. Remover a regra .${\ A_ displaystyle {i} \ rightarrow \ alpha _ {i}}$
            3. Para cada regra :${\ Displaystyle A_ {j} \ rightarrow \ _ alfa {j}}$
               1. Adicione a regra .${\ A_ displaystyle {i} \ rightarrow \ _ {alfa} j \ beta _ {i}}$
   2. Remover recursão esquerda direto para como descrito acima.${\ A_ displaystyle {i}}$

Note-se que este algoritmo é altamente sensível à ordenação não-terminal; otimizações muitas vezes se concentrar em escolher esta ordenação bem.

armadilhas

Embora as transformações acima preservar a linguagem gerada por uma gramática, eles podem alterar as árvores de análise que testemunha o reconhecimento cordas. Com a contabilidade adequada, reescrita árvore pode recuperar os originais, mas se este passo for omitido, as diferenças podem mudar a semântica de uma análise.

Associativity é particularmente vulnerável; associativo esquerda operadores normalmente aparecem no direito associativo-like regime reservado pela nova gramática. Por exemplo, começando com esta gramática:

${\ Displaystyle {\ mathit {Expressão}} \ rightarrow {\ mathit {Expressão}} \, - \, {\ mathit {Termo}} \ meados {\ mathit {Termo}}}$

${\ Displaystyle {\ mathit {Termo}} \ rightarrow {\ mathit {Termo}} \, * \, {\ mathit {Fator}} \ meados {\ mathit {Fator}}}$

${\ Displaystyle {\ mathit {Fator}} \ rightarrow ({\ mathit {Expressão}}) \ meados {\ mathit {Integer}}}$

as transformações convencionais para remover recursão esquerda deu o seguinte:

${\ Displaystyle {\ mathit {Expressão}} \ rightarrow {\ mathit {Termo}} \ {\ mathit {Expressão}} '}$

${\ Displaystyle {\ mathit {Expressão}} '\ rightarrow {} - {\ mathit {Termo}} \ {\ mathit {Expressão}}' \ mid \ epsilon}$

${\ Displaystyle {\ mathit {Termo}} \ rightarrow {\ mathit {Fator}} \ {\ mathit {Termo}} '}$

${\ Displaystyle {\ mathit {Termo}} '\ rightarrow {} * {\ mathit {Fator}} \ {\ mathit {Termo}}' \ mid \ epsilon}$

${\ Displaystyle {\ mathit {Fator}} \ rightarrow ({\ mathit {Expressão}}) \ meados {\ mathit {Integer}}}$

Analisar a string "1 - 2 - 3" com a primeira gramática em um analisador LALR (que pode lidar com gramáticas deixou-recursiva) teria resultado na árvore de análise:

Este de análise grupos de árvores os termos do lado esquerdo, dando a semântica correta (1 - 2) - 3 .

Analisando com o segundo gramática dá

que, devidamente interpretadas, significa 1 + (-2 + (-3)) , também correctas, mas menos fiel para a entrada e muito mais difícil de executar para alguns operadores. Observe como termos para a direita aparecem mais profundo na árvore, tanto quanto uma gramática direito recursivo iria organizá-los para 1 - (2-3) .

Acomodando recursão esquerdo na análise top-down

A gramática formal que contém recursão esquerda não pode ser analisado por um LL (k) -parser ou outro ingênuo analisador descendente recursivo a menos que seja convertida para um fracamente equivalente forma correta recursiva. Em contraste, a recursividade esquerda é preferido para analisadores LALR porque resulta no uso da pilha inferior a recursividade direita . No entanto, mais sofisticados analisadores top-down pode implementar gerais gramáticas livres de contexto por uso de corte. Em 2006, Frost e Hafiz descrito um algoritmo que acomoda gramática ambígua com esquerda-recursiva diretos regras de produção . Esse algoritmo foi estendido para uma completa análise algoritmo para acomodar indireta, bem como recursão direta esquerda na polinomial tempo, e para gerar representações de tamanho polinomial compactas do número potencialmente exponencial de árvores de análise para gramáticas altamente ambíguas por Geada, Hafiz e Callaghan, em 2007 . os autores, em seguida, implementou o algoritmo como um conjunto de combinadores analisador escritas no Haskell linguagem de programação.

Veja também

• recursão de cauda

Referências

links externos

• Considerações práticos para LALR (1) gramáticas