# Relatório: Compilador para a linguagem de programação Basic
###### **Alunos:** :male-student:
> Denys Menfredy Ferreira Ribeiro;
> Renuá Meireles Almeida;
> Rodrigo Moraes Rodrigues;
> Velcides Galvão Mezzomo.
:::warning
:bulb:Neste **[link](https://whimsical.com/fluxogramas-diagramas-esquemas-compiladores-R8TimzDnkkgHAXy5RdJQhH)** contém uma board com todas modelagens, diagramas e fluxogramas desenvolvidos. :rocket:
:::
---
[ToC]
---
## Linguagem de programação **BASIC**
<p style="text-align: justify">
    O **BASIC** (Beginners All-Purpose Symbolic Instruction Code, em português: Código de Instruções Simbólicas de Uso Geral para Principiantes), **é uma linguagem de programação não estrutural e imperativa** criada em **1964** por três professore da universidade de Darthmouth (John G. Kemeny, Thomas E. Kurtz e Marry Keller), tendo como objetivo disseminar o conhecimento sobre lógica de programação para usuários comuns.
</p>
<p style="text-align: justify">
    Cada instrução em BASIC ocupa uma linha. Para usar mais de uma linha é necessário usar um caractere de continuação. Um dos aspectos mais conhecidos de BASIC era a utilização de numeração para as linhas. A maioria dos interpretadores possui um comando RENUMBER que permite renumerar todas as linhas de acordo com um intervalo pré-determinado (como em RENUMBER 10). Alguns, mas não todos, dialetos mais modernos abandonaram os números e suportam a maioria, ou todas, as instruções de controle estruturada e declaração de dados, permitindo a construção de programas estruturados como em Pascal.
</p>
### `E1` Especificação
<p style="text-align: justify">
    No BASIC original existem apenas dois tipos de variáveis, as textuais e as numéricas. Para declarar uma variável numérica você precisa escrever uma caractere alfabético seguido ou não de um numérico.
</p>
#### Símbolos
- Palavras reservadas:
| | | | | | |
| - | - | - | - | - | - |
| DATA | FOR | IF | GOTO | LET | NEXT |
| PRINT | READ | REM | STEP | THEN | TO |
- Operadores:
| Operador Matemático | Função |
| - | - |
| + | Soma |
| - | Subtração |
| * | Multiplicação |
| / | Divisão |
| ^ | Exponenciação |
| Operador Lógico | Função |
| - | - |
| = | Igualdade e Atribuição |
| > | Maior que |
| >= | Maior ou igual |
| < | Menor que |
| <= | Menor ou igual |
| <> | Diferente |
- Delimitadores:
| | | |
| - | - | - |
| ( | ) | , |
#### Estruturas
- O BASIC original possuía apenas **15** comandos:
**LET**, para atribuição, como em:
```java=
10 LET A=1
```
**READ**, para ler o valor de uma ou mais variáveis de declarações DATA, como em:
```java=
20 READ B,C,D
```
**DATA**, para definir listas de valores a serem usados lidos pelo READ, como em:
```java=
30 DATA 10,20,30
```
**PRINT**, para imprimir no dispositivo de saída o valor de expressões, como em:
```java=
40 PRINT A,"VALOR DE ",B+C
```
**GOTO**, para redirecionar a execução do programa para outra linha, como em:
```java=
50 GOTO 500
```
**IF-THEN**, para redirecionar um programa para outra linha, de acordo com o valor de uma expressão lógica, como e:
```java=
500 IF B<C THEN GOTO 20
```
**FOR-TO-STEP**, para iniciar uma repetição, como em:
```java=
510 FOR I=1 to 7 STEP 2
```
**NEXT**, para indicar a continuação de uma repetição, como em:
```java=
600 NEXT I
```
**END**, que deve acabar todo o programa e indica seu fim se o processamento lá chegar.
**STOP**, que equivale a um GOTO para a linha contendo o END
**DEF**, para definir uma função.
**GOSUB**, para pular para um ponto do programa com a semântica de sub-rotina.
**RETURN**, para voltar de uma sub-rotina.
**DIM**, para definir vetores e matrizes.
**REM**, para comentários.
- Um típico programa em BASIC (original), seria o seguinte:
```java=
10 REM RESOLVE EQUACAO DO SEGUNDO GRAU
20 READ A,B,C
30 IF A=0 THEN GOTO 400
40 LET D=B*B-4*A*C
50 IF D<0 THEN GOTO 420
60 PRINT "SOLUCAO"
70 IF D=0 THEN GOTO 200
80 PRINT "PRIMEIRA SOLUCAO",(-B+SQR(D))/(2*A)
90 PRINT "SEGUNDA SOLUCAO",(-B-SQR(D))/(2*A)
100 GOTO 20
200 PRINT "SOLUCAO UNICA",(-B)/(2*A)
300 GOTO 20
400 PRINT "A DEVE SER DIFERENTE DE ZERO"
410 GOTO 20
420 PRINT "NAO HA SOLUCOES REAIS"
430 GOTO 20
490 DATA 10,20,1241,123,22,-1
500 END
```
### `E2` Formalização
#### `E2` Linguagens Regulares - AFD, ER, GR
O **analisador Léxico** deverá:
1. Ler o programa fonte **caractere por caractere**;
2. **Ignorar os elementos não funcionais**, que auxiliam a leitura do programador (Comentários, espaços em branco, pulos de linhas, tabulações);
3. **Identificar os símbolos** contidos no programa fonte;
4. **Reconhecer os símbolos** identificados no programa fonte:
4.1 Símbolos **fixos** (Palavras reservadas, operadores, delimitadores, etc.);
4.2 Símbolos **Variados** (Identificadores, constantes, sequência de caracteres, etc).
5. **Gerar** a cadeia de tokens:
5.1 Para símbolos fixos;
5.2 Para símbolos variados.
:::info
:bulb: **Importante**:
**Símbolos variados** podem ser reconhecidos por um AFD, neste caso, ocorre uma entrada na tabela de símbolos e um token ==$<Tipo\_do\_símbolo, Índice\_na\_TS>$== é gerado.
Caso **símbolos fixos** sejam reconhecidos por um dicionário, um token ==$<símbolo>$== é gerado, caso seja reconhecido por um AFD, um token ==$<Tipo\_do\_símbolo, Índice\_na\_TS>$== é gerado.
:::
<p style="text-align: justify">
As expressões regulares e seus respectivos AFDs equivalentes se dão por:
</p>
:::spoiler **Legenda dos conjuntos utilizados.**
| Conjunto | Elementos |
| - | - |
| L | Letras |
| Lr | Letras excluindo "r" |
| Le | Letras excluindo "e" |
| Lm | Letras excluindo "m" |
| D | Dígitos |
| @ | Caracteres Especiais |
| W | Espaço, Tabulação, "\n" |
:::
:::spoiler **Legenda dos símbolos utilizados nas ERs.**
| Conjunto | Elementos |
| - | - |
| * | **Nenhuma**, **uma** ou **mais de uma** aparição do símbolo anterior |
| + | **Uma** ou **mais de uma** aparição do símbolo anterior |
| ? | **Nenhuma** ou **uma** aparição do símbolo anterior |
| \| | O símbolo anterior **ou** o símbolo posterior |
:::
:::warning
**Constante: CTE**
:::
:::warning
**String: STR**
:::
:::warning
**Identificador: ID**
:::
:::warning
**Comentário: COM**
:::
:::success
**Todos em apenas um**
:::
#### `E5` Gramática de Livre Contexto - AP, GLC
:::info
- **Gramatica Livre de Contexto (GLC)**
G = (T,N,P,S)
P:{
S → -A| DB| "E| LrG| R|
A → DB
B → DB| .C| ε
C → DD
D → DD|ε
E → LE| @E| DE| WE| "F
F → ε
G → LG| DH| ε
H → DH| ε
I → Le G| D H| E J| ε
J → Lm G| D H| M K| ε
K → L K| @ K| D K| W K| \n L| ε
L → ε
}
- **Eliminação das produções vazias**
P:{
S -> "A| D B| " E| Lr G| R I| R | D |Lr
A -> D B|D
B -> D B|. C| D
C -> D D|D
D -> D D|D
E -> L E| @ E| D E| W E|" ← **Eliminando F**
G -> L G| D H| L | D
H -> D H|D
I -> Le G| D H| E J| D | E
J -> Lm G| D H| M K| D | M
K -> L K| @ K| D K| W K| L | @ | D | W | \n
}
:::
### `E3` Análise léxica
Segue abaixo o fluxograma desenvolvido que descreve o funcionamento do analisador léxico.
#### PROGRAMA EXEMPLO
Inicialmente, a etapa de análise léxica foi validada manualmente através da utilização de um programa exemplo.
:::info
10 REM RESOLVE EQUACAO DO SEGUNDO GRAU
20 READ A,B,C
30 IF A=0 THEN GOTO 400
40 LET D=B*B-4*A*C
50 IF D<0 THEN GOTO 420
60 PRINT "SOLUCAO"
70 IF D=0 THEN GOTO 200
80 PRINT "PRIMEIRA SOLUCAO",(-B+SQR(D))/(2*A)
90 PRINT "SEGUNDA SOLUCAO",(-B-SQR(D))/(2*A)
100 GOTO 20
200 PRINT "SOLUCAO UNICA",(-B)/(2*A)
300 GOTO 20
400 PRINT "A DEVE SER DIFERENTE DE ZERO"
410 GOTO 20
420 PRINT "NAO HA SOLUCOES REAIS"
430 GOTO 20
490 DATA 10,20,1241,123,22,-1
500 END
:::
#### TOKENS GERADOS
:::info
<CTE, 1>
<CTE, 2><READ><ID, 3><,><ID, 4><,><ID, 5>
<CTE, 6><IF><ID, 3><=><CTE, 7><GOTO><CTE, 8>
<CTE, 9><LET><ID, 10><=><ID, 4><*><ID, 4><-><CTE, 11><*><ID, 3><*><ID, 5>
<CTE, 12><IF><ID, 10><<><CTE, 7><THEN><GOTO><CTE, 13>
<CTE, 14><PRINT><STR, 15>
<CTE, 16><IF><ID, 10><=><CTE, 7><THEN><GOTO><CTE, 17>
<CTE, 18><PRINT><STR, 19><,><(><-><ID, 4><+><SQR><(><ID, 10><)><)></><(><CTE, 20><*><ID, 3><)>
<CTE, 21><PRINT><STR, 22><,><(><-><ID, 4><-><SQR><(><ID, 10><)><)></><(><CTE, 20><*><ID, 3><)>
<CTE, 23><GOTO><CTE, 2>
<CTE, 17><PRINT><STR, 25><,><(><-><ID, 4><)></><(><CTE, 20><*><ID, 3><)>
<CTE, 26><GOTO><CTE, 2>
<CTE, 27><PRINT><STR, 28>
<CTE, 29><GOTO><CTE, 2>
<CTE, 30><PRINT><STR, 31>
<CTE, 32><GOTO><CTE, 2>
<CTE, 33><DATA><CTE, 1><,><CTE, 2><,><CTE, 34><,><CTE, 35><,><CTE, 36><,><CTE, 37>
<CTE, 38><END>
:::
#### Tabela de Símbolos
| Índice | Símbolo | Tipo |
| -------- | -------- | -------- |
| 1 | 10 | CTE |
| 2 | 20 | CTE |
| 3 | A | ID|
| 4 | B | ID|
| 5 | C | ID|
| 6 | 30 | CTE |
| 7 | 0 | CTE |
| 8 | 400 | CTE|
| 9 | 40 | CTE |
| 10 | D | ID |
| 11 | 4 | CTE|
| 12 | 50 | CTE|
| 13 | 420 | CTE|
| 14 | 60 | CTE|
| 15 | "SOLUCAO" |STR |
|16 | 70 | CTE|
| 17 | 200| CTE|
| 18 | 80| CTE |
| 19 | "PRIMEIRA SOLUCAO" |STR |
| 20 | 2 | CTE|
| 21 | 90 | CTE |
| 22 | "SEGUNDA SOLUCAO" |STR |
| 23 | 100 | CTE|
| 24 | 200 | CTE|
| 25 | "SOLUCAO UNICA" | STR |
| 26 | 300 | CTE |
| 27 | 400 | CTE|
| 28 | "A DEVE SER DIFERENTE DE ZERO" | STR |
| 29 | 410 | CTE |
| 30 | 420 | CTE |
| 31 | "NAO HA SOLUCOES REAIS" | STR |
| 32 | 430 | CTE |
| 33 | 490 | CTE|
| 34 | 1241 | CTE|
| 35 | 123 | CTE|
| 36 | 22 | CTE|
| 37 | -1 | CTE|
| 38 | 500 | CTE |
### `E6` Análise sintática
Neste ponto, foi definido algumas mudanças na linguagem para fins de simplificação da construção do analisador sintático.
As mudanças consistem em:
- A instrução DATA, consegue apenas ler um dados por vez. Anteriormente essa função consumia todo o código em busca das instruções READ com a quantidade exata de valores para associar às variáveis solicitadas em DATA. Desta forma, a instrução passa a adotar o seguinte formato:
```java=
...
10 DATA A
...
70 READ 2.54
...
120 END
```
- Todas as linhas do programa devem começar com um número inteiro;
- O comando **IF** sofreu uma alteração por equívoco, no formato original, o comando é finalizado com **GOTO** linha_alvo, porém, não é mais necessário inserir a instrução **GOTO**, apenas a linha_alvo já é suficiente
#### Descrevendo a estrutura da linguagem em GLC
:::info
S <PROGRAMA> → <COMANDOS> <end> | <vazio>
A <COMANDOS> → <cte> | <cte> <COMANDO> | <cte> <COMANDO><COMANDOS>
B <COMANDO> → <GOTO> | <ESCREVA> | <LEIA> | <DECLARACAO_VAR> | <BLOCO>
C <GOTO> → <goto> <cte>
D <ESCREVA> → <print> <VALORES>
E <VALORES> → <VALOR> | <VALOR> <,> <VALORES>
F <VALOR> → <id> | <str> | <cte> | <EXPRESSAO_MAT>
G <EXPRESSAO_MAT> → <VALOR> <OPERADOR_MAT> <VALOR> | <(> <EXPRESSAO_MAT> <)>
H <OPERADOR_MAT> → <+> | <-> | </> | <*> | <^>
I <LEIA> → <read> <id> <COMANDOS> <data> <cte>
J <DECLARACAO_VAR> → <let> <id> <=> <VALOR>
K <BLOCO> → <LACO> | <CONDICIONAL>
L <LACO> → <for> <id> <=> <cte> <to> <cte> <PASSO> <COMANDOS> <next> <cte>
M <PASSO> → <step> <cte> | <step> <id> | <vazio>
N <CONDICIONAL> → <if> <EXPRESSAO_LOGICA> <then> <cte>
O <EXPRESSAO_LOGICA> → <VALOR> <OPERADOR_LOGICO> <VALOR>
P <OPERADOR_LOGICO> → <<> | <>> | <=> | <<> <=> | <>> <=> | <<> <>>
:::
#### Renomeando os estados
:::info
S → A <end> | <vazio>
A → <cte> | <cte> B | <cte> BA
B → C | D | I | J | K
C → <goto> <cte>
D → <print> E
E → F | F , E
F → <id> | <str> | <cte> | G
G → F H F | (G)
H → + | - | / | * | ^
I → <read> <id> A <data> <cte>
J → <let> <id> = F
K → L | N
L → <for> <id> = <cte> <to> <cte> M A <next> <cte>
M → <step> <cte> | <step> <id> | <vazio>
N → <if> O <then> <cte>
O → F P F
P → < | > | = | <= | >= | <>
:::
___
:::spoiler **Eliminando Produções Simples**
#### Estados afetados: B,E,F,K
:::info
S → A <end> | <vazio>
A → <cte> | <cte> B | <cte> BA
B → <goto> <cte> | <print> E | <read> <id> A <data> <cte> | <let> <id> = F | <for> <id> = <cte> <to> <cte> M A <next> <cte> | <if> O <then> <cte>
C → <goto> <cte>
D → <print> E
E → <id> | <str> | <cte> | F H F | (G) | F , E
F → <id> | <str> | <cte> | F H F | (G)
G → F H F | (G)
H → + | - | / | * | ^
I → <read> <id> A <data> <cte>
J → <let> <id> = F
K → <for> <id> = <cte> <to> <cte> M A <next> <cte> | <if> O <then> <cte>
L → <for> <id> = <cte> <to> <cte> M A <next> <cte>
M → <step> <cte> | <step> <id> | <vazio>
N → <if> O <then> <cte>
O → F P F
P → < | > | = | <= | >= | <>
:::
:::
___
:::spoiler **Eliminando Estados Inalcançáveis**
#### Estados afetados: C,D,I,J,K,L,N
:::info
S → A <end> | <vazio>
A → <cte> | <cte> B | <cte> BA
B → <goto> <cte> | <print> E | <read> <id> A <data> <cte> | <let> <id> = F | <for> <id> = <cte> <to> <cte> M A <next> <cte> | <if> O <then> <cte>
E → <id> | <str> | <cte> | F H F | (G) | F , E
F → <id> | <str> | <cte> | F H F | (G)
G → F H F | (G)
H → + | - | / | * | ^
M → <step> <cte> | <step> <id> | <vazio>
O → F P F
P → < | > | = | <= | >= | <>
:::
:::
___
:::spoiler **Eliminação R.E Direta**
#### Estados afetados: F
:::info
S → A <end> | <vazio>
A → <cte> | <cte> B | <cte> BA
B → <goto> <cte> | <print> E | <read> <id> A <data> <cte> | <let> <id> = F | <for> <id> = <cte> <to> <cte> M A <next> <cte> | <if> O <then> <cte>
E → <id> | <str> | <cte> | F H F | (G) | F , E
F → <id>F1 | <str>F1 | <cte>F1 | (G)F1
F1 → H FF1 | <vazio>
G → F H F | (G)
H → + | - | / | * | ^
M → <step> <cte> | <step> <id> | <vazio>
O → F P F
P → < | > | = | <= | >= | <>
:::
:::
___
:::spoiler **Eliminação Produção Vazia**
#### Estados afetados: F1 (afeta F e F1), M (afeta B)
:::info
S → A <end> | <vazio>
A → <cte> | <cte> B | <cte> BA
B → <goto> <cte> | <print> E | <read> <id> A <data> <cte> | <let> <id> = F | <for> <id> = <cte> <to> <cte> M A <next> <cte> | <if> O <then> <cte> | <for> <id> = <cte> <to> <cte> A <next> <cte>
E → <id> | <str> | <cte> | F H F | (G) | F , E
F → <id>F1 | <str>F1 | <cte>F1 | (G)F1 | <id> | <str> | <cte> | (G)
F1 → H FF1 | H F
G → F H F | (G)
H → + | - | / | * | ^
M → <step> <cte> | <step> <id>
O → F P F
P → < | > | = | <= | >= | <>
:::
:::
___
:::spoiler **Em busca da FNC**
#### Estados afetados: A, B, E, F, F1, G, M, O
:::info
S → A S1 | <vazio>
S1 → <end>
A → <cte> | <cte> B | <cte> A1
A1 → BA
B → <goto> B1 | <print> E | <read> B2 | <let> B3 | <for> B4 | <if> B5 | <for> B6
B1 → <cte>
B2 → <id> B21
B21 → A B22
B22 → <data> B23
B23 → <cte>
B3 → <id> B31
B31 → = F
B4 → <id> B41
B41 → = B42
B42 → <cte> B43
B43 → <to> B44
B44 → <cte> B45
B45 → M B46
B46 → A B47
B47 → <next> B48
B48 → <cte>
B5 → O B51
B51 → <then> B52
B52 → <cte>
B6 → <id> B61
B61 → = B62
B62 → <cte> B63
B63 → <to> B64
B64 → <cte> B65
B65 → A B66
B66 → <next> B67
B67 → <cte>
E → <id> | <str> | <cte> | F E1 | ( E2 | F E3
E1 → H F
E2 → G E22
E22 → )
E3 → , E
F → <id>F1 | <str>F1 | <cte>F1 | ( F2 | <id> | <str> | <cte> | ( F3
F1 → H F11 | H F
F11 → F F1
F2 → G F22
F22 → ) F1
F3 → G)
G → F G1 | ( G2
G1 → H F
G2 → G)
H → + | - | / | * | ^
M → <step> M1 | <step> M2
M1 → <cte>
M2 → <id>
O → F O1
O1 → P F
P → < | > | = | < P1 | > P2| < P3
P1 → =
P2 → =
P3 → >
:::
:::
___
:::spoiler **Estados Equivalentes**
:::info
**Estados Afetados:**
B1 ↔ B23 ↔ B48 ↔ B52 ↔ B67 ↔ M1
E2 ↔ F3 ↔ G2
B46 ↔ B65
P1 ↔ P2
E1 ↔ G1
============
S → A S1 | <vazio>
S1 → <end>
A → <cte> | <cte> B | <cte> A1
A1 → BA
B → <goto> B1 | <print> E | <read> B2 | <let> B3 | <for> B4 | <if> B5 | <for> B6
B1 → <cte>
B2 → <id> B21
B21 → A B22
B22 → <data> B1
B3 → <id> B31
B31 → = F
B4 → <id> B41
B41 → = B42
B42 → <cte> B43
B43 → <to> B44
B44 → <cte> B45
B45 → M B46
B46 → A B47
B47 → <next> B1
B5 → O B51
B51 → <then> B1
B6 → <id> B61
B61 → = B62
B62 → <cte> B63
B63 → <to> B64
B64 → <cte> B46
E → <id> | <str> | <cte> | F E1 | ( E2 | F E3
E1 → H F
E2 → G E22
E22 → )
E3 → , E
F → <id>F1 | <str>F1 | <cte>F1 | ( F2 | <id> | <str> | <cte> | ( E2
F1 → H F11 | H F
F11 → F F1
F2 → G F22
F22 → ) F1
G → F E1 | ( E2
H → + | - | / | * | ^
M → <step> B1 | <step> M2
M2 → <id>
O → F O1
O1 → P F
P → < | > | = | < P1 | > P1| < P3
P1 → =
P3 → >
:::
___
:::spoiler **Em busca da FNG**
#### Estados afetados: H (afeta E1 e F11), P (afeta O1)
:::info
S → A S1 | <vazio>
S1 → <end>
A → <cte> | <cte> B | <cte> A1
A1 → BA
B → <goto> B1 | <print> E | <read> B2 | <let> B3 | <for> B4 | <if> B5 | <for> B6
B1 → <cte>
B2 → <id> B21
B21 → A B22
B22 → <data> B1
B3 → <id> B31
B31 → = F
B4 → <id> B41
B41 → = B42
B42 → <cte> B43
B43 → <to> B44
B44 → <cte> B45
B45 → M B46
B46 → A B47
B47 → <next> B1
B5 → O B51
B51 → <then> B1
B6 → <id> B61
B61 → = B62
B62 → <cte> B63
B63 → <to> B64
B64 → <cte> B46
E → <id> | <str> | <cte> | F E1 | ( E2 | F E3
E1 → +F | -F | /F | *F | ^F
E2 → G E22
E22 → )
E3 → , E
F → <id>F1 | <str>F1 | <cte>F1 | ( F2 | <id> | <str> | <cte> | ( E2
F1 → +F11 | -F11 | /F11 | *F11 | ^F11 | +F | -F | /F | *F | ^F
F11 → F F1
F2 → G F22
F22 → ) F1
G → F E1 | ( E2
M → <step> B1 | <step> M2
M2 → <id>
**\*\*\* Série de Operações em O e P\*\*\***
O → F O1
O1 → < F | > F | = F | < P1 F | > P1 F | < P3 F **\# Irá mudar abaixo**
O1 → < F | > F | = F | < O2 | > O3 | < O4 **\# Irá mudar abaixo**
O2 → P1 F
O3 → P1 F **\# Irá mudar abaixo**
O4 → P3 F
P1 → =
P3 → >
**Equivalentes : O2 ↔ O3**
O1 → < F | > F | = F | < O2 | > O2 | < O4
O3 **\# Removido pela equivalência**
:::
:::
#### Versão Final
:::success
S → A S1 | <vazio>
S1 → <end>
A → <cte> | <cte> B | <cte> A1
A1 → BA
B → <goto> B1 | <print> E | <read> B2 | <let> B3 | <for> B4 | <if> B5 | <for> B6
B1 → <cte>
B2 → <id> B21
B21 → A B22
B22 → <data> B1
B3 → <id> B31
B31 → = F
B4 → <id> B41
B41 → = B42
B42 → <cte> B43
B43 → <to> B44
B44 → <cte> B45
B45 → M B46
B46 → A B47
B47 → <next> B1
B5 → O B51
B51 → <then> B1
B6 → <id> B61
B61 → = B62
B62 → <cte> B63
B63 → <to> B64
B64 → <cte> B46
E → <id> | <str> | <cte> | F E1 | ( E2 | F E3
E1 → +F | -F | /F | *F | ^F
E2 → G E22
E22 → )
E3 → , E
F → <id>F1 | <str>F1 | <cte>F1 | ( F2 | <id> | <str> | <cte> | ( E2
F1 → +F11 | -F11 | /F11 | *F11 | ^F11 | +F | -F | /F | *F | ^F
F11 → F F1
F2 → G F22
F22 → ) F1
G → F E1 | ( E2
M → <step> B1 | <step> M2
M2 → <id>
O → F O1
O1 → < F | > F | = F | < O2 | > O2 | < O4
O2 → P1 F
O4 → P3 F
P1 → =
P3 → >
:::
### `E8` Análise semântica
## IDE
<p style="text-align: justify">
    
A implementação da IDE foi realizada através da linguagem de programação <strong>Python</strong>, em sua versão <strong>3.7</strong>. E, como biblioteca de interface gráfica, foi utilizado o <strong>PyQt5</strong>.
</p>
### Layout
O layout é composto por:
- Um botão de compilar;
- Um editor de texto;
- Um console para saída de dados, dados estes que são:
-- Cadeia de Tokens;
-- Tabela de Símbolos construída;
-- Árvore de derivação;
-- Status e processos da compilação;
### `E4` Codificação Análise Léxica
:::success
Implementação realizada com a linguagem python.
:::
### `E7` Codificação Análise Sintática
:::success
Implementação realizada com a linguagem python.
:::
### `E9` Codificação Análise Semântica
:::warning
Não implementado.
:::
## `E10` Síntese do Compilador
:::warning
Não implementado.
:::spoiler Tópicos
### `E10` Especificação
### `E11` Codificação
:::
:::
## `E12` Testes e Validação :bulb: :male-scientist: :mag_right:
<p style="text-align: justify">
    
Foram realizados testes para validar o compilador até a etapa de análise sintática. Para isto, foram executados 06 exemplos de programas para verificar se o compilador consegue efetuar todos os processos implementados até então.
</p>
<p style="text-align: justify">
    Segue abaixo o resultado dos testes realizados.
</p>
### Exemplo 01 - Programa vazio
:::success
Programa executado com sucesso!
- Cadeia de tokens vazia
- Estado inicial $S$ do analisador sintático aceitou **$\epsilon$**.
:::
### Exemplo 02 - Programa sem sentido
:::danger
Erro no programa!
- Cadeia de tokens gerada com sucesso;
- Analisador léxico não esperou id no estado inicial $S$.
:::
### Exemplo 03 - Apenas constantes
:::danger
Erro no programa!
- Cadeia de tokens gerada com sucesso;
- Erro na sintaxe do programa.
:::
### Exemplo 04 - Atribuição de variável e expressão matemática
:::success
Programa executado com sucesso!
- Cadeia de tokens gerada corretamente;
- Analisador léxico aceitou o programa e gerou a árvore de derivação corretamente.
:::
### Exemplo 05 - Condicional
:::success
Programa executado com sucesso!
- Cadeia de tokens gerada corretamente;
- Analisador léxico aceitou o programa e gerou a árvore de derivação corretamente.
:::
### Exemplo 06 - Imprimindo valores separados por vírgula e resultados de expressões matemáticas
:::success
Programa executado com sucesso!
- Cadeia de tokens gerada corretamente;
- Analisador léxico aceitou o programa e gerou a árvore de derivação corretamente.
:::
## Referências
> AHO, Alfred V.; SETHI, Ravi; ULLMAN, Jeffrey D. **Compiladores: Princıpios, técnicas e ferramentas**. LTC, Rio de Janeiro, Brasil, 1995.
> KEMENY, Jhon G.; KURTZ, Thomas E. **BASIC**: Fourth Edition. 1968. Disponível em: \<http://www.bitsavers.org/pdf/dartmouth/BASIC_4th_Edition_Jan68.pdf\>.
Sign in with Wallet
Connect another wallet