Relatrio do Projeto de Compiladores

Matria: CCT810- Compiladores

Professor: Roberto Claudino
Bianca Gueldini Tella 21189
Luzia Gomes de Amorim 22561
Maria Tereza Ribeiro Reis 15598

1. Anlise lxica

1.2. Definio
Definio: O analisador lxico uma funo que transforma sequncias de
caracteres em sequncias de smbolos (palavras ou tokens). Exemplos de tokens:
Palavras reservadas do Pascal (begin, function, ), operadores (+, <=, ),
identificadores, constantes e sinais de pontuao. Por exemplo, a sequncia: 45 * 10
ser convertida em: < NUM, 45 > < *, > < NUM, 10 > onde o atributo do token NUM
o seu valor numrico.

1.3. Mtodos
Podem-se usar dois mtodos:
Utilizao de uma tabela de smbolos, onde so registados os identificadores e as
palavras-chave do texto Fonte.
Descrio dos smbolos atravs de expresses regulares.

1.4. Tabela de smbolos
O atributo do token ID pode ser o endereo do elemento da tabela, onde est
registada a cadeia de caracteres que descreve o identificador.
As operaes de gesto de uma tabela de smbolos so as seguintes:
Inicializao: com as palavras-chave e os identificadores-standard
Pesquisa de um smbolo (fornece o endereo do registo que o contm)
Insero de um novo smbolo (e informao associada)

1.5. Descrio atravs de expresses regulares
Este mtodo consiste em traduzir os tokens atravs de expresses regulares, e
utilizar autmatos finitos para reconhec-los.

Construo do autmato (algoritmo) A = (Q, T, M, q0, H):
q estado_inicial
Repetir
q delta (q, c)
Se ( q H ) {
H = conj. estados finais do autmato }
Ento
guardar (c)
ler (c)
At ( q H)
Cdigo_smbolo f (q)

Na implementao do autmato, os estados q so inteiros, com estado_inicial = 0,
reservando os negativos para os H. (se q < 0 ento... )
Existem duas formas de implementar a funo de transio :
Com um array bidimensional : delta [q, c]
Como uma funo : delta (q, c)
Ou utilizar solues intermdias
Na implementao da funo de transio com um array, a execuo mais
rpida, mas ocupa mais memria.
Por exemplo, para o autmato seguinte:

2. Analisador sinttico
Um analisador sinttico para uma gramtica G um programa que aceita como
entrada uma sentena e constri para a sentena sua rvore gramatical (ou
equivalentemente uma sequncia de derivao) ou, caso a sentena no pertena
linguagem descrita por G, uma indicao de erro.
O objetivo do analisador sinttico obter uma cadeia de tokens, provenientes de
chamadas ao analisador lxico, e verificar se esta cadeia pode ser gerada pela gramtica
da linguagem fonte. Como sada, o analisador sinttico pode gerar a rvore gramatical
correspondente cadeia de tokens durante a anlise lxica, alm de relatar eventuais
erros de sintaxe encontrados durante a fase de anlise.

3. Interligao entre os analisadores lxico e sinttico

O esquema de interao entre o analisador lxico e o analisador sinttico pode ser
visualizado na figura seguinte.

O analisador lxico funciona com sub-rotina do analisador sinttico e comunica com
este atravs de uma interface simples.
O analisador sinttico chama o analisador lxico sempre que necessita de obter um
elemento lxico. O analisador lxico devolve o cdigo do elemento lxico e informao
extra. Por exemplo, se o analisador lxico detectar uma sequncia de caracteres descrita
pela expresso regular [09]+, devolve ao analisador sinttico o cdigo do nmero
inteiro. Uma vez que o valor do nmero inteiro pode ser importante, por exemplo, se for
o literal de uma expresso aritmtica, o analisador lxico tambm deve devolver ao
analisador sinttico o valor do nmero.
Os identificadores de elementos sintticos como variveis devem ser armazenadas
na tabela de identificadores. A insero pode ser feita pelo analisador lxico ou pelo
analisador sinttico, conforme a linguagem processada e opo do compilador.
Nas linguagens de programao imperativa (Pascal e C), os identificadores podem
referir elementos distintos, tais como variveis e funes. Neste caso, prefervel o
analisador lxico passar ao analisador sinttico a referncia zona de memria para
onde copiado o identificador. Ser o analisador sinttico quem determina o significado
do identificador e efetua as aes apropriadas de insero/pesquisa do smbolo na tabela
de identificadores.

3.1. LEX : um gerador automtico de analisadores lxicos

Dado um programa escrito na linguagem de programao denominada por LEX
(prog.lex), as trs fases da compilao deste programa so as seguintes :
1. lex prog.lex { contm uma funo em C chamada yylex() }



O LEX gera um autmato determinstico finito, capaz de reconhecer padres (de
acordo com as expresses regulares especificadas), permitindo ainda associar aes.
O LEX como analisador lxico:
yylex() uma funo que fornece o valor zero no fim do ficheiro, e pode fornecer os
cdigos dos smbolos reconhecidos.
Exemplo :
letra [azAZ]
dig [0-9]
%%
BEGIN { return (1) ; }
END { return (2) ; }
:= { return (3) ; }
{ letra } ( { letra } | { dig } ) * { return (4) ; }
.
.
.
Para escrever todos os valores dos cdigos dos smbolos que ocorrem nem texto :
While (c = yylex () )
printf (%d, c) ;
yytext um array externo onde ficam armazenados os caracteres reconhecidos.
Para escrever a palavra lida :
[az] + printf (%s, yytext) ;
ou, abreviadamente
[az] + ECHO ;
yyleng d o comprimento do padro reconhecido
[azAZ] + { palavras ++ ; letras += yyleng ; }
Exemplo :
Somar 3 a todo o inteiro no negativo que seja divisvel por 7.
%%
int k ;
[0-9] + { k = atoi (yytext) ;
if (k % 7 == 0)
printf (%d, k+3) ;
else
printf (%d, k) ; }
4. Tabela de Anlise Sinttica LR (1)

A maioria das linguagens de programao podem ser descritas por uma gramtica
livre de contexto que pode ser analisado por um analisador LR(1). Para a regra A- > a
possvel indicar exatamente quais smbolos de entrada podem se seguir a um gerador a
para o qual exista uma possvel reduo A. A informao extra incorporada dentro do
estado pela redefinio dos itens, de forma que incluam um smbolo terminal como um
segundo componente. A tabela LR(1) construda da mesma forma que a LR(0) exceto
na maneira de inserir os reduces (redues). Quando h um item [A - > a.,a] em um
estado i, ento deve-se inserir na linha i coluna a a reduo da regra de produo A - >
a.

"PROGRAMA" [A-Z], [a-z]} [0-9]
S S-> PROGRAMA



"PROGRAMA" [A-Z], [a-z]} [0-9]
PROGRAMA PROGRAMA ->
"PROGRAMA"
NOMEPROG "INICIO"
PROG "FIM"



"PROGRAMA" [A-Z], [a-z]} [0-9]
NOMEPROG NOMEPROG -> ID_TEXTO

NOMEPROG ->
ID_TEXTO



"PROGRAMA" [A-Z], [a-z]} [0-9]
ID_TEXTO ID_TEXTO ->
ID_CARACTER_ALPHA
TEXTO_APLHA_NUMERIC
ID_TEXTO ->
ID_CARACTER_ALPHA
TEXTO_APLHA_NUME
RIC


"PROGRAMA" [A-Z], [a-z]} [0-9]
ID_CARACTER_ALPHA ID_CARACTER_ALPHA ->
[A-Z]

ID_CARACTER_ALPHA -
> [a-z]



"PROGRAMA" [A-Z], [a-z]} [0-9]
TEXTO_APLHA_NUMERIC TEXTO_APLHA_NUMERIC
->
CARACTER_ALPHA_NUM
ERIC
TEXTO_APLHA_NUMERIC
TEXTO_APLHA_NUME
RIC ->
CARACTER_ALPHA_NU
MERIC
TEXTO_APLHA_NUME
RIC
TEXTO_APLHA_NUME
RIC ->
CARACTER_ALPHA_NU
MERIC
TEXTO_APLHA_NUME
RIC

"PROGRAMA" [A-Z], [a-z]} [0-9]
CARACTER_ALPHA_NUMERIC CARACTER_ALPHA_NUM
ERIC -> [A-Z]
CARACTER_ALPHA_NU
MERIC -> [a-z]
CARACTER_ALPHA_NU
MERIC [0-9]


"PROGRAMA" [A-Z], [a-z]} [0-9]
PROG PROG -> DECLARACOES
ALGORITMO

PROG ->
DECLARACOES
ALGORITMO

PROG ->
DECLARACOES
ALGORITMO

[0-9].[0-9] ['@', '_', '-', '$', '%', '&'] ( NO
PROG PROG -> DECLARACOES
ALGORITMO

PROG -> DECLARACOES
ALGORITMO

PROG ->
DECLARACOES
ALGORITMO



"PROGRAMA" [A-Z], [a-z]} [0-9]
DECLARACOES DECLARACOES ->
DECLARACAO
DECLARACOES
DECLARACOES ->
DECLARACAO
DECLARACOES
DECLARACOES ->
DECLARACAO
DECLARACOES
[0-9].[0-9] ['@', '_', '-', '$', '%', '&'] ( NO
DECLARACOES DECLARACOES ->
DECLARACAO
DECLARACOES
DECLARACOES ->
DECLARACAO
DECLARACOES
DECLARACOES ->
DECLARACAO
DECLARACOES


"PROGRAMA" [A-Z], [a-z]} [0-9]
TIPO TIPO -> CARACTER

TIPO -> TEXTO
TIPO -> CARACTER

TIPO -> TEXTO
TIPO -> INTEIRO

TIPO -> CARACTER

TIPO -> TEXTO
[0-9].[0-9] ['@', '_', '-', '$', '%', '&'] ( NO
TIPO TIPO -> REAL TIPO -> CARACTER

TIPO -> TEXTO
TIPO -> CADEIA

TIPO -> LISTA_INT

TIPO -> REAL


"PROGRAMA" [A-Z], [a-z]} [0-9]
ID ID -> ID_TEXTO

ID -> ID_TEXTO



"PROGRAMA" [A-Z], [a-z]} [0-9]
ALGORITMO ALGORITMO ->
EXPRESSAO ALGORITMO

ALGORITMO ->
COMANDO ALGORITMO

ALGORITMO ->
EXPRESSAO
ALGORITMO

ALGORITMO ->
COMANDO
ALGORITMO

ALGORITMO ->
EXPRESSAO
ALGORITMO

ALGORITMO ->
COMANDO
ALGORITMO

[0-9].[0-9] ['@', '_', '-', '$', '%', '&'] ( NO
ALGORITMO ALGORITMO ->
EXPRESSAO
ALGORITMO

ALGORITMO ->
ALGORITMO ->
EXPRESSAO ALGORITMO

ALGORITMO ->
COMANDO ALGORITMO
ALGORITMO ->
EXPRESSAO
ALGORITMO

ALGORITMO ->

COMANDO ALGORITMO

COMANDO
ALGORITMO

OU E LEIA ESCREVA
ALGORITMO ALGORITMO ->
COMANDO
ALGORITMO

ALGORITMO ->
COMANDO
ALGORITMO

SE ENQUANTO FUNCAO
ALGORITMO ALGORITMO ->
COMANDO ALGORITMO

ALGORITMO ->
COMANDO ALGORITMO

ALGORITMO ->
COMANDO
ALGORITMO



"PROGRAMA" [A-Z], [a-z]} [0-9]
EXPRESSAO EXPRESSAO ->
EXP_ARITIMETICA

EXPRESSAO -
>EXP_RELACIONAL

EXPRESSAO ->
EXP_LOGICA


EXPRESSAO ->
EXP_ARITIMETICA

EXPRESSAO -
>EXP_RELACIONAL

EXPRESSAO ->
EXP_LOGICA

EXPRESSAO ->
EXP_ARITIMETICA

EXPRESSAO -
>EXP_RELACIONAL

EXPRESSAO ->
EXP_LOGICA

[0-9].[0-9] ['@', '_', '-', '$', '%', '&'] ( NO
EXPRESSAO EXPRESSAO ->
EXP_ARITIMETICA

EXPRESSAO -
>EXP_RELACIONAL

EXPRESSAO ->
EXP_LOGICA

EXPRESSAO ->
EXP_ARITIMETICA

EXPRESSAO -
>EXP_RELACIONAL

EXPRESSAO ->
EXP_LOGICA

EXPRESSAO ->
EXP_ARITIMETICA

EXPRESSAO -
>EXP_RELACIONAL

EXPRESSAO ->
EXP_LOGICA

EXPRESSAO ->
EXP_LOGICA


"PROGRAMA" [A-Z], [a-z]} [0-9]
EXP_ARITIMETICA EXP_ARITIMETICA -> VAR

EXP_ARITIMETICA ->
VAR

EXP_ARITIMETICA ->
CONST

EXP_ARITIMETICA ->
VAR


[0-9].[0-9] ['@', '_', '-', '$', '%', '&'] ( NO
EXP_ARITIMETICA EXP_ARITIMETICA ->
VAR

EXP_ARITIMETICA -> VAR

EXP_ARITIMETICA -> (
OP_ARITIMETICA )

EXP_ARITIMETICA ->
VAR



"PROGRAMA" [A-Z], [a-z]} [0-9]
OP_ARITIMETICA OP_ARITIMETICA ->
EXP_ARITIMETICA
OPERADOR
EXP_ARITIMETICA

OP_ARITIMETICA ->
EXP_ARITIMETICA
OPERADOR
EXP_ARITIMETICA

OP_ARITIMETICA ->
EXP_ARITIMETICA
OPERADOR
EXP_ARITIMETICA

[0-9].[0-9] ['@', '_', '-', '$', '%', '&'] ( NO
OP_ARITIMETICA ->
EXP_ARITIMETICA
OPERADOR
EXP_ARITIMETICA
OP_ARITIMETICA ->
EXP_ARITIMETICA
OPERADOR
EXP_ARITIMETICA
OP_ARITIMETICA ->
EXP_ARITIMETICA
OPERADOR
EXP_ARITIMETICA



+ - * /
OPERADOR OPERADOR -> '+'

OPERADOR -> '-'

OPERADOR -> '*'

OPERADOR -> '/'


"PROGRAMA" [A-Z], [a-z]} [0-9]
CONST CONST -> NUMERO


"PROGRAMA" [A-Z], [a-z]} [0-9]
NUMERO NUMERO -> DIGITO
NUMERO

NUMERO -> DIGITO

"PROGRAMA" [A-Z], [a-z]} [0-9]
DIGITO DIGITO -> [0-9]


"PROGRAMA" [A-Z], [a-z]} [0-9]
VAR VAR -> ID

VAR -> CARACTER

VAR -> TEXTO


VAR -> ID

VAR -> CARACTER

VAR -> TEXTO


VAR -> INTEIRO

VAR -> CARACTER

VAR -> TEXTO

[0-9].[0-9] ['@', '_', '-', '$', '%', '&'] ( NO
VAR VAR -> REAL

VAR -> CARACTER

VAR -> TEXTO

VAR -> CARACTER

VAR -> TEXTO

VAR -> LIST_INT

VAR -> LIST_REAL



"PROGRAMA" [A-Z], [a-z]} [0-9]
EXP_RELACIONAL EXP_RELACIONAL -> VAR EXP_RELACIONAL ->
VAR
EXP_RELACIONAL ->
VAR

EXP_RELACIONAL ->
CONST

[0-9].[0-9] ['@', '_', '-', '$', '%', '&'] ( NO
EXP_RELACIONAL EXP_RELACIONAL ->
VAR
EXP_RELACIONAL -> VAR EXP_RELACIONAL -> (
OP_RELACIONAL )


"PROGRAMA" [A-Z], [a-z]} [0-9]
OP_RELACIONAL OP_RELACIONAL ->
EXP_RELACIONAL
OPERADOR_REL
EXP_RELACIONAL

OP_RELACIONAL ->
EXP_RELACIONAL
OPERADOR_REL
EXP_RELACIONAL

OP_RELACIONAL ->
EXP_RELACIONAL
OPERADOR_REL
EXP_RELACIONAL

[0-9].[0-9] ['@', '_', '-', '$', '%', '&'] ( NO
OP_RELACIONAL OP_RELACIONAL ->
EXP_RELACIONAL
OPERADOR_REL
EXP_RELACIONAL

OP_RELACIONAL ->
EXP_RELACIONAL
OPERADOR_REL
EXP_RELACIONAL

OP_RELACIONAL ->
EXP_RELACIONAL
OPERADOR_REL
EXP_RELACIONAL



MAQ MAI MEQ MEI
OPERADOR_REL OPERADOR_REL ->
.MAQ.

OPERADOR_REL ->
.MAI.

OPERADOR_REL ->
.MEQ.

OPERADOR_REL ->
.MEI.

IGU DIF {
OPERADOR_REL OPERADOR_REL ->
.IGU.

OPERADOR_REL -> .DIF.



"PROGRAMA" [A-Z], [a-z]} [0-9]
EXP_LOGICA EXP_LOGICA -> VAR

EXP_LOGICA -> VAR

EXP_LOGICA -> CONST

EXP_LOGICA -> VAR


[0-9].[0-9] ['@', '_', '-', '$', '%', '&'] ( NO
EXP_LOGICA EXP_LOGICA -> VAR

EXP_LOGICA -> VAR

EXP_LOGICA -> (
OP_LOGICA )

EXP_LOGICA -> VAR

EXP_LOGICA -> | NEG (
OP_LOGICA )

"PROGRAMA" [A-Z], [a-z]} [0-9]
OP_LOGICA OP_LOGICA ->
EXP_LOGICA
OPERADOR_LOG
EXP_LOGICA

OP_LOGICA ->
EXP_LOGICA
OPERADOR_LOG
EXP_LOGICA

OP_LOGICA ->
EXP_LOGICA
OPERADOR_LOG
EXP_LOGICA

[0-9].[0-9] ['@', '_', '-', '$', '%', '&'] ( NO
OP_LOGICA OP_LOGICA ->
EXP_LOGICA
OPERADOR_LOG
EXP_LOGICA

OP_LOGICA ->
EXP_LOGICA
OPERADOR_LOG
EXP_LOGICA

OP_LOGICA ->
EXP_LOGICA
OPERADOR_LOG
EXP_LOGICA

OP_LOGICA ->
EXP_LOGICA
OPERADOR_LOG
EXP_LOGICA


OU E LEIA ESCREVA
OPERADOR_LOG OPERADOR_LOG ->
'.OU.'

OPERADOR_LOG -> ' '.E.'



[0-9].[0-9] ['@', '_', '-', '$', '%', '&'] ( NO
NEG NEG -> '.NAO.'


"PROGRAMA" [A-Z], [a-z]} [0-9]
COMANDO COMANDO ->
ATRIBUICAO
COMANDO ->
ATRIBUICAO
COMANDO ->
ATRIBUICAO
[0-9].[0-9] ['@', '_', '-', '$', '%', '&'] ( NO
COMANDO COMANDO ->
ATRIBUICAO
COMANDO ->
ATRIBUICAO
COMANDO ->
ATRIBUICAO

OU E LEIA ESCREVA
COMANDO COMANDO ->
ENTRADA
COMANDO -> SAIDA

SE ENQUANTO FUNCAO
COMANDO COMANDO -> SELECAO

COMANDO -> REPETICAO

COMANDO ->
ESPECIFICAS




"PROGRAMA" [A-Z], [a-z]} [0-9]
ATRIBUICAO ATRIBUICAO -> VAR ':='
VALOR

ATRIBUICAO -> VAR
':=' VALOR

ATRIBUICAO -> VAR
':=' VALOR

[0-9].[0-9] ['@', '_', '-', '$', '%', '&'] ( NO
ATRIBUICAO ATRIBUICAO -> VAR ':='
VALOR

ATRIBUICAO -> VAR ':='
VALOR

ATRIBUICAO -> VAR
':=' VALOR



OU E LEIA ESCREVA
ENTRADA SAIDA -> 'ESCREVA'
VAR



OU E LEIA ESCREVA
SAIDA SAIDA -> 'ESCREVA'
VAR


SE ENQUANTO FUNCAO
SELECAO SELECAO -> COND


SELECAO -> COND
'SENO' COMANDO
'FIM_SE'


SE ENQUANTO FUNCAO
COND COND -> 'SE'
EXP_RELACIONAL
'ENTO' COMANDO



SE ENQUANTO FUNCAO
REPETICAO REPETICAO ->
'ENQUANTO'
EXP_RELACIONAL
COMANDO
'FIM_ENQUANTO'



SE ENQUANTO FUNCAO
ESPECIFICAS ESPECIFICAS ->
"FUNCAO" ID_TEXTO
"(" DECLARACOES ")"
"INICIO" PROG "FIM"
"(" DECLARACOES ")"



"PROGRAMA" [A-Z], [a-z]} [0-9]
INTEIRO INTEIRO -> NUMERO


[0-9].[0-9] ['@', '_', '-', '$', '%', '&'] ( NO
REAL
REAL -> NUMERO .
NUMERO



"PROGRAMA" [A-Z], [a-z]} [0-9]
CARACTER CARACTER -> [A-Z]

CARACTER -> | [a-z]

CARACTER -> [0-9]

[0-9].[0-9] ['@', '_', '-', '$', '%', '&'] ( NO
CARACTER CARACTER -> ['@', '_', '-',
'$', '%', '&']



[0-9].[0-9] ['@', '_', '-', '$', '%', '&'] ( NO
CADEIA CADEIA -> '(' VAR ')'

CADEIA -> '(' VAR ')'
CADEIA



"PROGRAMA" [A-Z], [a-z]} [0-9]
TEXTO TEXTO -> CARACTER
TEXTO

TEXTO -> CARACTER

TEXTO -> CARACTER
TEXTO

TEXTO -> CARACTER
TEXTO

TEXTO -> CARACTER
TEXTO |

TEXTO -> CARACTER

[0-9].[0-9] ['@', '_', '-', '$', '%', '&'] ( NO
TEXTO TEXTO -> CARACTER
TEXTO

TEXTO -> CARACTER



[0-9].[0-9] ['@', '_', '-', '$', '%', '&'] ( NO
LISTA_INT LISTA_INT -> '('
INTEIRO ')' LISTA_INT

LISTA_INT -> '('
INTEIRO ')'



IGU DIF {
COMENTARIO COMENTARIO -> '{'
TEXTO '}'




5. rvore Sinttica

Gramtica:

S-> PROGRAMA
PROGRAMA -> "PROGRAMA" NOMEPROG "INICIO" PROG "FIM"

-------------------------------------------

NOMEPROG -> ID_TEXTO
ID_TEXTO -> ID_CARACTER_ALPHA TEXTO_APLHA_NUMERIC | ID_CARACTER_ALPHA
ID_CARACTER_ALPHA -> [A-Z] | [a-z]
TEXTO_APLHA_NUMERIC -> CARACTER_ALPHA_NUMERIC TEXTO_APLHA_NUMERIC | CARACTER_ALPHA_NUMERIC
CARACTER_ALPHA_NUMERIC -> [A-Z] | [a-z] | [0-9]

--------------------------------------------

PROG -> DECLARACOES ALGORITMO

--------------------------------------------

DECLARACOES -> DECLARACAO DECLARACOES | DECLARACAO
DECLARACAO -> TIPO ID
TIPO -> INTEIRO | REAL | CARACTER | CADEIA | TEXTO | LISTA_INT | LISTA_REAL
ID -> ID_TEXTO

--------------------------------------------

ALGORITMO -> EXPRESSAO ALGORITMO | COMANDO ALGORITMO

-------------------------------------------

EXPRESSAO -> EXP_ARITIMETICA | EXP_RELACIONAL | EXP_LOGICA | EXP_CARACTERES

-------------------------------------------

EXP_ARITIMETICA -> ( OP_ARITIMETICA ) | CONST | VAR
OP_ARITIMETICA -> EXP_ARITIMETICA OPERADOR EXP_ARITIMETICA
OPERADOR -> '+' | '-' | '*' | '/'



CONST -> NUMERO
NUMERO -> DIGITO NUMERO | DIGITO
DIGITO -> [0-9]
VAR -> ID | INTEIRO | REAL | CARACTER | CADEIA | TEXTO | LISTA_INT | LISTA_REAL

-------------------------------------------

EXP_RELACIONAL -> ( OP_RELACIONAL ) | VAR | CONST
OP_RELACIONAL -> EXP_RELACIONAL OPERADOR_REL EXP_RELACIONAL
OPERADOR_REL -> .MAQ.| .MAI.| .MEQ.| .MEI.| .IGU.| .DIF.
-------------------------------------------
EXP_LOGICA -> ( OP_LOGICA ) | NEG ( OP_LOGICA ) | VAR | CONST
OP_LOGICA -> EXP_LOGICA OPERADOR_LOG EXP_LOGICA
OPERADOR_LOG -> '.OU.' | '.E.'
NEG -> '.NAO.'

-------------------------------------------

COMANDO -> ATRIBUICAO | ENTRADA | SAIDA | SELECAO | REPETICAO | ESPECIFICAS

-------------------------------------------

ATRIBUICAO -> VAR ':=' VALOR
VALOR -> CONST | VAR | EXPRESSAO

-------------------------------------------

ENTRADA -> 'LEIA' VAR

-------------------------------------------

SAIDA -> 'ESCREVA' VAR

-------------------------------------------

SELECAO -> COND | COND 'SENO' COMANDO 'FIM_SE'
COND -> 'SE' EXP_RELACIONAL 'ENTO' COMANDO

-------------------------------------------

REPETICAO -> 'ENQUANTO' EXP_RELACIONAL COMANDO 'FIM_ENQUANTO'

-------------------------------------------

ESPECIFICAS -> "FUNCAO" ID_TEXTO "(" DECLARACOES ")" "INICIO" PROG "FIM" "(" DECLARACOES ")"

-------------------------------------------

INTEIRO -> NUMERO
REAL -> NUMERO . NUMERO
CARACTER -> [A-Z] | [a-z] | [0-9] | ['@', '_', '-', '$', '%', '&']
CADEIA -> '(' VAR ')' CADEIA | '(' VAR ')'
TEXTO -> CARACTER TEXTO | CARACTER
LISTA_INT -> '(' INTEIRO ')' LISTA_INT | '(' INTEIRO ')'
LISTA_REAL -> '(' REAL ')' LISTA_REAL | '(' REAL ')'

-------------------------------------------

COMENTARIO -> '{' TEXTO '}'



5.1. rvore Sinttica
Definio: Uma rvore de anlise sinttica, ou simplesmente rvore sinttica,
uma estrutura de dados em rvore, que representa a estrutura sinttica de uma cadeia de
acordo com alguma gramtica formal. Em uma rvore sinttica, os ns internos so
rotulados por smbolos no-terminais da gramtica, enquanto os ns folha so rotuladas
por smbolos terminais da gramtica. Um programa que produz tais rvores
denominado um analisador sinttico. rvores sintticas podem ser geradas
para sentenas em linguagem natural como tambm durante o processamento de
linguagens formais, tais como as linguagens de programao.


S
|
PROGRAMA
|
"PROGRAMA" NOMEPROG "INICIO" PROG "FIM"


PROG
|
DECLARACOES ALGORITMO




ALGORITMO
/ \
EXPRESSAO ALGORITMO COMANDO ALGORITMO




























































6. Bibliografia

NEPOMUCENO, M. R. Compiladores: Anlise Sinttica. Disponvel em:
<http://www.fafiman.br/leandro/arquivos/compiladores/apoio/Analise%20Sintatica/Ana
liseSintatica.pdf> Acesso em: 28 de novembro de 2013.
RIGO, S. Anlise Lxica. Disponvel em: <
http://www.ic.unicamp.br/~sandro/cursos/mc910/slides/cap2-lex.pdf> Acesso em: 28 de
novembro de 2013.