Attribute Grammars/Exercise 11: Operadores Lógicos - Revision history

Root at 10:50, 12 February 2019

2019-02-12T10:50:37Z

← Older revision		Revision as of 10:50, 12 February 2019
Line 11:		Line 11:
	'''disj''' representa uma disjunção; '''conj''' representa uma conjunção; '''uni''' representa expressões unárias; e '''elm''' representa elementos mais simples. O atributo booleano '''val''' representa o valor lógico associado a cada expressão.		'''disj''' representa uma disjunção; '''conj''' representa uma conjunção; '''uni''' representa expressões unárias; e '''elm''' representa elementos mais simples. O atributo booleano '''val''' representa o valor lógico associado a cada expressão.

	<text>		<source lang="text">
	disj → disj @ conj { disj_0.val = disj_1.val \|\| conj.val; }		disj → disj @ conj { disj_0.val = disj_1.val \|\| conj.val; }
	disj → conj { disj.val = conj.val; }		disj → conj { disj.val = conj.val; }
Line 21:		Line 21:
	elm → p { elm.val = p.val; }		elm → p { elm.val = p.val; }
	elm → q { elm.val = q.val; }		elm → q { elm.val = q.val; }
	</~~text~~>		</source>

	Como se pode ver pelas acções semânticas associadas à gramática, todos os atributos são sintetizados, pelo que a gramática é do tipo S.		Como se pode ver pelas acções semânticas associadas à gramática, todos os atributos são sintetizados, pelo que a gramática é do tipo S.
Line 29:		Line 29:
	== Especificação YACC (versão directa a partir da gramática acima) ==		== Especificação YACC (versão directa a partir da gramática acima) ==

	<text>		<source lang="text">
	%union{ bool val; }		%union{ bool val; }
	%type<val> 'p' 'q' disj conj uni elm		%type<val> 'p' 'q' disj conj uni elm
Line 43:		Line 43:
	elm : 'q' { $$ = $1; };		elm : 'q' { $$ = $1; };
	%%		%%
	</~~text~~>		</source>

	== Especificação YACC (versão "compacta") ==		== Especificação YACC (versão "compacta") ==

	<text>		<source lang="text">
	%union{ bool val; }		%union{ bool val; }
	%type<val> 'p' 'q' expr		%type<val> 'p' 'q' expr
Line 62:		Line 62:
	;		;
	%%		%%
	</~~text~~>		</source>

	[[category:Compiladores]]		[[category:Compiladores]]
	[[category:Ensino]]		[[category:Ensino]]

Root: /* Especificação YACC (versão directa a partir da gramática acima) */

2015-06-22T18:32:13Z

Especificação YACC (versão directa a partir da gramática acima)

← Older revision		Revision as of 18:32, 22 June 2015
Line 33:		Line 33:
	%type<val> 'p' 'q' disj conj uni elm		%type<val> 'p' 'q' disj conj uni elm
	%%		%%
	disj : disj '@' conj { $$ = $1 \|\| $3; }		disj : disj '@' conj { $$ = $1 \|\| $3; };
	disj : conj { $$ = $1; }		disj : conj { $$ = $1; };
	conj : conj '#' uni { $$ = $1 && $3; }		conj : conj '#' uni { $$ = $1 && $3; };
	conj : uni { $$ = $1; }		conj : uni { $$ = $1; };
	uni : '/' elm { $$ = !$2; }		uni : '/' elm { $$ = !$2; };
	uni : elm { $$ = $1; }		uni : elm { $$ = $1; };
	elm : '(' disj ')' { $$ = $2; }		elm : '(' disj ')' { $$ = $2; };
	elm : 'p' { $$ = $1; }		elm : 'p' { $$ = $1; };
	elm : 'q' { $$ = $1; }		elm : 'q' { $$ = $1; };
			%%
			</text>

			== Especificação YACC (versão "compacta") ==

			<text>
			%union{ bool val; }
			%type<val> 'p' 'q' expr
			%left '@'
			%left '#'
			%nonassoc '/'
			%%
			expr : expr '@' expr { $$ = $1 \|\| $3; }
			\| expr '#' expr { $$ = $1 && $3; }
			\| '/' expr { $$ = !$2; }
			\| '(' expr ')' { $$ = $2; }
			\| 'p' { $$ = $1; }
			\| 'q' { $$ = $1; }
			;
	%%		%%
	</text>		</text>

Root: /* Especificação YACC */

2015-06-22T18:27:54Z

Especificação YACC

← Older revision		Revision as of 18:27, 22 June 2015
Line 27:		Line 27:
	== Árvore Sintáctica Decorada e Grafo de Dependências ==		== Árvore Sintáctica Decorada e Grafo de Dependências ==

	== Especificação YACC ==		== Especificação YACC (versão directa a partir da gramática acima) ==

			<text>
			%union{ bool val; }
			%type<val> 'p' 'q' disj conj uni elm
			%%
			disj : disj '@' conj { $$ = $1 \|\| $3; }
			disj : conj { $$ = $1; }
			conj : conj '#' uni { $$ = $1 && $3; }
			conj : uni { $$ = $1; }
			uni : '/' elm { $$ = !$2; }
			uni : elm { $$ = $1; }
			elm : '(' disj ')' { $$ = $2; }
			elm : 'p' { $$ = $1; }
			elm : 'q' { $$ = $1; }
			%%
			</text>

	[[category:Compiladores]]		[[category:Compiladores]]
	[[category:Ensino]]		[[category:Ensino]]

Root: /* Gramática Atributiva */

2015-06-22T18:19:43Z

Gramática Atributiva

← Older revision		Revision as of 18:19, 22 June 2015
Line 8:		Line 8:

	== Gramática Atributiva ==		== Gramática Atributiva ==

			'''disj''' representa uma disjunção; '''conj''' representa uma conjunção; '''uni''' representa expressões unárias; e '''elm''' representa elementos mais simples. O atributo booleano '''val''' representa o valor lógico associado a cada expressão.

			<text>
			disj → disj @ conj { disj_0.val = disj_1.val \|\| conj.val; }
			disj → conj { disj.val = conj.val; }
			conj → conj # uni { conj_0.val = conj_1.val && uni.val; }
			conj → uni { conj.val = uni.val; }
			uni → / elm { uni.val = !elm.val; }
			uni → elm { uni.val = elm.val; }
			elm → ( disj ) { elm.val = disj.val; }
			elm → p { elm.val = p.val; }
			elm → q { elm.val = q.val; }
			</text>

			Como se pode ver pelas acções semânticas associadas à gramática, todos os atributos são sintetizados, pelo que a gramática é do tipo S.

	== Árvore Sintáctica Decorada e Grafo de Dependências ==		== Árvore Sintáctica Decorada e Grafo de Dependências ==

Root: /* Problema */

2015-06-22T18:04:18Z

Problema

← Older revision		Revision as of 18:04, 22 June 2015
Line 1:		Line 1:
	== Problema ==		== Problema ==

	Pretende-se construir uma gramática atributiva (em C++) que avalie expressões lógicas. As expressões podem ser constituídas por literais '''p''' ou '''q''', ou por aplicações dos operadores lógicos: '''#''' (conjunção lógica – operador binário), '''@''' (disjunção lógica inclusiva – operador binário), '''/''' (negação lógica – operador unário). Assuma que os terminais '''p''' e '''q''' têm definido o atributo booleano val (respectivamente, igual ao valor C++ '''true''', para ''verdadeiro''; e '''false''', para ''falso''). O operador unário tem precedência superior aos binários e '''#''' tem precedência superior a '''@'''. É possível usar parênteses (curvos) para alterar as precedências.		Pretende-se construir uma gramática atributiva (em C++) que avalie expressões lógicas. As expressões podem ser constituídas por literais '''p''' ou '''q''', ou por aplicações dos operadores lógicos: '''#''' (conjunção lógica – operador binário), '''@''' (disjunção lógica inclusiva – operador binário), '''/''' (negação lógica – operador unário). Assuma que os terminais '''p''' e '''q''' têm definido o atributo booleano '''val''' (respectivamente, igual ao valor C++ '''true''', para ''verdadeiro''; e '''false''', para ''falso''). O operador unário tem precedência superior aos binários e '''#''' tem precedência superior a '''@'''. É possível usar parênteses (curvos) para alterar as precedências.

	# Identifique a gramática atributiva correspondente ao problema. Descreva o significado e o tipo de cada atributo. Que tipo de gramática obteve?		# Identifique a gramática atributiva correspondente ao problema. Descreva o significado e o tipo de cada atributo. Que tipo de gramática obteve?

Root: /* Problema */

2015-06-22T18:01:59Z

Problema

← Older revision		Revision as of 18:01, 22 June 2015
Line 5:		Line 5:
	# Identifique a gramática atributiva correspondente ao problema. Descreva o significado e o tipo de cada atributo. Que tipo de gramática obteve?		# Identifique a gramática atributiva correspondente ao problema. Descreva o significado e o tipo de cada atributo. Que tipo de gramática obteve?
	# Identifique a árvore de sintaxe decorada (apresentando o valor lógico da expressão no nó raiz da árvore) e o grafo de dependências para a expressão '''(p@q)#/(p#q)'''		# Identifique a árvore de sintaxe decorada (apresentando o valor lógico da expressão no nó raiz da árvore) e o grafo de dependências para a expressão '''(p@q)#/(p#q)'''
	# Escreva uma especificação YACC que implemente a gramática descrita em 1. Codifique toda a especificação (incluindo as zonas de declarações e de regras) e todas as funções auxiliares. Não utilizar variáveis globais.		# Escreva uma especificação YACC que implemente a gramática descrita em 1. Codifique toda a especificação (incluindo as zonas de declarações e de regras) e todas as funções auxiliares. '''Não utilizar variáveis globais.'''

	== Gramática Atributiva ==		== Gramática Atributiva ==

Root at 18:01, 22 June 2015

2015-06-22T18:01:29Z

← Older revision		Revision as of 18:01, 22 June 2015
Line 6:		Line 6:
	# Identifique a árvore de sintaxe decorada (apresentando o valor lógico da expressão no nó raiz da árvore) e o grafo de dependências para a expressão '''(p@q)#/(p#q)'''		# Identifique a árvore de sintaxe decorada (apresentando o valor lógico da expressão no nó raiz da árvore) e o grafo de dependências para a expressão '''(p@q)#/(p#q)'''
	# Escreva uma especificação YACC que implemente a gramática descrita em 1. Codifique toda a especificação (incluindo as zonas de declarações e de regras) e todas as funções auxiliares. Não utilizar variáveis globais.		# Escreva uma especificação YACC que implemente a gramática descrita em 1. Codifique toda a especificação (incluindo as zonas de declarações e de regras) e todas as funções auxiliares. Não utilizar variáveis globais.

			== Gramática Atributiva ==

			== Árvore Sintáctica Decorada e Grafo de Dependências ==

			== Especificação YACC ==


			[[category:Compiladores]]
			[[category:Ensino]]

Root: /* Problema */

2015-06-22T18:00:00Z

Problema

← Older revision		Revision as of 18:00, 22 June 2015
Line 1:		Line 1:
	== Problema ==		== Problema ==

	Pretende-se construir uma gramática atributiva (em C++) que avalie expressões lógicas. As expressões podem ser constituídas por literais p ou q, ou por aplicações dos operadores lógicos: '''#''' (conjunção lógica – operador binário), '''@''' (disjunção lógica inclusiva – operador binário), '''/''' (negação lógica – operador unário). Assuma que os terminais '''p''' e '''q''' têm definido o atributo booleano val (respectivamente, igual ao valor C++ '''true''', para ''verdadeiro''; e '''false''', para ''falso''). O operador unário tem precedência superior aos binários e '''#''' tem precedência superior a '''@'''. É possível usar parênteses (curvos) para alterar as precedências.		Pretende-se construir uma gramática atributiva (em C++) que avalie expressões lógicas. As expressões podem ser constituídas por literais '''p''' ou '''q''', ou por aplicações dos operadores lógicos: '''#''' (conjunção lógica – operador binário), '''@''' (disjunção lógica inclusiva – operador binário), '''/''' (negação lógica – operador unário). Assuma que os terminais '''p''' e '''q''' têm definido o atributo booleano val (respectivamente, igual ao valor C++ '''true''', para ''verdadeiro''; e '''false''', para ''falso''). O operador unário tem precedência superior aos binários e '''#''' tem precedência superior a '''@'''. É possível usar parênteses (curvos) para alterar as precedências.

	# Identifique a gramática atributiva correspondente ao problema. Descreva o significado e o tipo de cada atributo. Que tipo de gramática obteve?		# Identifique a gramática atributiva correspondente ao problema. Descreva o significado e o tipo de cada atributo. Que tipo de gramática obteve?
	# Identifique a árvore de sintaxe decorada (apresentando o valor lógico da expressão no nó raiz da árvore) e o grafo de dependências para a expressão '''(p@q)#/(p#q)'''		# Identifique a árvore de sintaxe decorada (apresentando o valor lógico da expressão no nó raiz da árvore) e o grafo de dependências para a expressão '''(p@q)#/(p#q)'''
	# Escreva uma especificação YACC que implemente a gramática descrita em 1. Codifique toda a especificação (incluindo as zonas de declarações e de regras) e todas as funções auxiliares. Não utilizar variáveis globais.		# Escreva uma especificação YACC que implemente a gramática descrita em 1. Codifique toda a especificação (incluindo as zonas de declarações e de regras) e todas as funções auxiliares. Não utilizar variáveis globais.

Root: Created page with "== Problema == Pretende-se construir uma gramática atributiva (em C++) que avalie expressões lógicas. As expressões podem ser constituídas por literais p ou q, ou por ap..."

2015-06-22T17:59:45Z

Created page with "== Problema == Pretende-se construir uma gramática atributiva (em C++) que avalie expressões lógicas. As expressões podem ser constituídas por literais p ou q, ou por ap..."

New page

== Problema ==

Pretende-se construir uma gramática atributiva (em C++) que avalie expressões lógicas. As expressões podem ser constituídas por literais p ou q, ou por aplicações dos operadores lógicos: '''#''' (conjunção lógica – operador binário), '''@''' (disjunção lógica inclusiva – operador binário), '''/''' (negação lógica – operador unário). Assuma que os terminais '''p''' e '''q''' têm definido o atributo booleano val (respectivamente, igual ao valor C++ '''true''', para ''verdadeiro''; e '''false''', para ''falso''). O operador unário tem precedência superior aos binários e '''#''' tem precedência superior a '''@'''. É possível usar parênteses (curvos) para alterar as precedências.

# Identifique a gramática atributiva correspondente ao problema. Descreva o significado e o tipo de cada atributo. Que tipo de gramática obteve?
# Identifique a árvore de sintaxe decorada (apresentando o valor lógico da expressão no nó raiz da árvore) e o grafo de dependências para a expressão '''(p@q)#/(p#q)'''
# Escreva uma especificação YACC que implemente a gramática descrita em 1. Codifique toda a especificação (incluindo as zonas de declarações e de regras) e todas as funções auxiliares. Não utilizar variáveis globais.