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

Root: Redirected page to ist:Attribute Grammars/Exercise 11: Operadores Lógicos

2018-12-05T23:18:13Z

Redirected page to ist:Attribute Grammars/Exercise 11: Operadores Lógicos

← Older revision		Revision as of 23:18, 5 December 2018
Line 1:		Line 1:
	~~== Problema ==~~		#REDIRECT [[ist:Attribute Grammars/Exercise 11: Operadores Lógicos]]

	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.'''

	~~== 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 ==~~

	~~== 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>~~

	~~== 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>~~

	[[~~category~~:~~Compiladores]]~~
	~~[[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.