O trabalho consiste em implementar um montador para o processador cuja arquitetura está
descrita abaixo. Deve ser utilizada a linguagem C, C++ ou Java. O montador deverá ter duas
passagens, sendo que existe um processador de macros embutido na primeira passagem.

 O montador recebe como entrada um arquivo texto (ASCII) comum. Este arquivo texto não
possui qualquer marca de formatação. São apenas linhas separadas por CR e/ou LF. Espaços e/ou
tabulações separam os elementos de uma linha. O montador gera como saída um arquivo executável,
cujo formato (estrutura interna) é descrito mais adiante.

 A entrega consiste no seguinte:
- Listagem do código fonte;
- Demonstração no computador, com a presença de todos os integrantes do grupo, em horário a ser
combinado. Serão feitas perguntas sobre o trabalho e somente será atribuída nota aos componentes
do grupo que participarem da demonstração.

Características da Linguagem de Montagem a ser implementada

1. Formato do código fonte
<rótulo>:     <operação>     <operando>     ; <comentário>

2. Diretivas suportadas
<rótulo>:     SPACE     <número de bytes>
Reserva o número especificado de bytes na memória, sem inicializar.

<rótulo>:     CONST     <conteúdo inicial>
Reserva um byte de memória e inicializa.

<rótulo>:     SET      <constante>
Define um novo símbolo. Não é permitido redefinir o valor deste símbolo.

<rótulo>:     MACRO     <argumentos>
Inicia a definição de uma macro.

                  ENDMACRO     <nome da macro>
Termina a definição de uma macro.

Observações sobre macros:
- Macros devem ser definidas antes de chamadas;
- Não é permitida definição embutida de macro;
- Deve ser provida alguma forma para que rótulos sejam definidos no corpo da macro.

3. Lista obrigatória de erros, mas que pode ser expandida
- Símbolo indefinido;                     - Símbolo duplamente definido;
- Operação não identificada;         - Número errado de operandos;
- Posição alvo fora do alcançe;     - Número errado de argumentos para macro;
- ENDMACRO com nome de macro errado.
 
 

4. Conjunto de instruções do processador
BRK   Para o processador   00H
LDI val16  ACC*valor16   01H valor-lsb valor-msb
LDA end16  ACC*[end16]   02H end-lsb end-msb
STA end16  [end16]*ACC   03H end-lsb end-msb
INC    ACC*ACC+1   11H
DEC    ACC*ACC-1    12H
ADC end16  ACC*ACC+[end16]+Cy  A1H end-lsb end-msb
SBC end16  ACC*ACC-[end16]   A2H end-lsb end-msb
BCC desl8  Se Cy=0 então PC*PC+desl8 B1H desl
BCS desl8  Se Cy=1 então PC*PC+desl8 B2H desl
BEQ desl8  Se Zr=1 então PC*PC+desl8 B3H desl
BNE desl8  Se Zr=0 então PC*PC+desl8 B4H desl
JMP end16  PC*end16    88H end-lsb end-msb
CLC   Cy*0     22H
STC   Cy*1     33H
 
5. Formato do arquivo executável gerado
 O arquivo executável gerado deverá conter, além do código objeto, um mapa de bits para
relocação. O formato do arquivo é mostrado abaixo, onde int representa um inteiro com 32 bits.

int assinatura = 0x12345678;
int tamanho_do_cabeçalho_em_bytes = 16;
int tamanho_do_código_gerado_em_bytes;
int tamanho_do_mapa_de_relocação_em_bytes;

char código_gerado [ tamanho_do_código_gerado_em_bytes ];

char mapa_de_relocação [ tamanho_do_mapa_de_relocação_em_bytes ];

6. Observações Gerais
- A tabela de símbolos do montador deve ser implementada com cálculo de endereço (função hash).
- O mapa de relocação deve usar o bit 1 para relativo e o bit 0 para absoluto.
- Todos os valores relativos são endereços que ocupam 2 bytes e devem ser tratados como tal.
- Dentro do mapa de relocação, bit mais significativo dentro de um mesmo byte significa byte
anterior no código executável.
- O tamanho do mapa de relocação é dado pelo tamanho do código gerado em bytes dividido por 8.
Caso não resulte em número inteiro de bytes, completar com zeros até que o mapa de bits tenha um
tamanho múltiplo de 8.
- No momento do salto condicional, o deslocamento é somado ao endereço da instrução que segue a
instrução de salto condicional no programa.