---
# System prepended metadata

title: 'Relatório: Compilador para a linguagem de programação Basic'

---

# 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">
&ensp;&ensp;&ensp;&ensp;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">
&ensp;&ensp;&ensp;&ensp;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">
&ensp;&ensp;&ensp;&ensp;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**
![](https://i.imgur.com/arS75gD.jpg)
:::

:::warning
**String: STR**
![](https://i.imgur.com/AdS1LCw.jpg)
:::

:::warning
**Identificador: ID**
![](https://i.imgur.com/3Jg8RJA.jpg)
:::

:::warning
**Comentário: COM**
![](https://i.imgur.com/R48I27D.jpg)
:::

:::success
**Todos em apenas um**
![](https://i.imgur.com/eX1LVtd.jpg)
:::

#### `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.

![](https://i.imgur.com/ERzrxKJ.png)
#### 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">
&ensp;&ensp;&ensp;&ensp;
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;
 
![](https://i.imgur.com/N7YLfua.png)
![](https://i.imgur.com/BhUJ5sg.png)

### `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">
&ensp;&ensp;&ensp;&ensp;
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">
&ensp;&ensp;&ensp;&ensp;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$**.

![exemplo01](https://i.imgur.com/7b5IBVT.jpg)
:::

### 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$.

![](https://i.imgur.com/9tYDkYT.jpg)
:::

### Exemplo 03 - Apenas constantes
:::danger
Erro no programa!
- Cadeia de tokens gerada com sucesso;
- Erro na sintaxe do programa.

![](https://i.imgur.com/5acTLty.jpg)
:::

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

![](https://i.imgur.com/ZYnBNDh.jpg)
![](https://i.imgur.com/qO46hRP.jpg)
![](https://i.imgur.com/l9MWTxA.jpg)
:::

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

![](https://i.imgur.com/a046caB.jpg)
![](https://i.imgur.com/hRjeb8K.jpg)
:::

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

![](https://i.imgur.com/EdJUfOC.jpg)
![](https://i.imgur.com/NHzT6qZ.jpg)
![](https://i.imgur.com/7ENUQNW.jpg)

:::

## 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\>.