MANUAL DE INSTRUÇÕES PARA O ASSEMBLADOR RSC-II
===============================================
Este pacote contém os arquivos necessários para a impressão do manual
de uso do assemblador/linkador RSC - II.
Introdução
O macro-assemblador/linkador RSC II é um extenso e excelente programa
composto por: um assemblador de dois passos, um linkador, um desassem-
blador e um simulador/depurador, que pode funcionar perfeitamente em
qualquer computador MSX, com um mínimo de 64 k de memória RAM. A
ampla gama de possibilidades lhe permite superar, amplamente, a seu
antecessor, RSC, e situa ao RSCII na vanguarda dos programas assembla-
dores deste padrão.
Dentre suas inúmeras melhoras e inovações, merece especial atenção
o comando LK (LinK=Unir) que permite unir diferentes arquivos de código
fonte, simplificando ainda mais a programação. Por outro lado, também
se destacam os novos comandos do assemblador e do simulador, que
proporcionam uma boa ajuda na hora de assemblar ou depurar um
programa. Então, leia este manual atentamente e, por favor, não
deixe de contactar com a RSC SOFTWARE para qualquer informação e/ou
esclarecimento que for preciso. Obrigado.
Ainda que os computadores MSX pertençam a um sistema padrão,
existem algumas diferenças entre eles. Por este motivo, e com a
finalidade de que o RSC II obtenha o máximo partido da sua máquina,
deve-se instalar previamente nela, utilizando-se o programa que
acompanha o disquete: INSTALAR. Este programa irá criar o RSC II,
adaptando-no a seu computador MSX. Portanto, siga ATENTAMENTE todas as
instruções com detalhe no capítulo 1 (INSTALAÇÃO E CARREGAMENTO DO
PROGRAMA) e seu Macro-Assemblador/Linkador funcionará sem problema algum.
NOTA: O disquete está garantido contra defeitos de origem.
Capítulo 1 - INSTALAÇÃO E CARREGAMENTO DO PROGRAMA
Seu Macro-Assemblador RSC II não pode funcionar diretamente sem uma
prévia instalação dentro de seu computador. Não se assuste, pois se
observa que no disquete não tem nenhum programa RSC II. Siga correta-
mente e passo a passo as instruções que seguem, para que o programa
possa ser criado.
1.- Não faça a instalação em nenhum outro computador que não seja o
seu.
2.- Assegure-se que o disquete RSC II possa ser gravado, ou seja,
não esteja protegido.
3.- Ligue a unidade de disco (o computador ainda não) e intruduza
o disquete RSC II.
4.- Ligue seu computador MSX e mantenha pressionada a tecla CTRL até
que apareça a tela do BASIC.
5.- Tecle: BLOAD"INSTALAR",R <RETURN>. Este programa fará a instala-
ção e, ao finalizar, mostrará a mensagem: RSC II ya está instalado.
Observe como o programa RSC II já existe e está pronto para funcionar.
Agora, tire o disquete e proteja-o contra gravação para que ele não seja
apagado. Seu programa RSC II funcionará perfeitamente em seu computador,
a não ser que, muito provavelmente, não funcione em outros computadores
MSX. Não se preocupe, isto se deve ao fato do programa ser adequado a
sua máquina.
A partir de agora, para carregar o programa, você deve fazer sempre o
seguinte: Se partir do sistema operacional MSX-DOS, passe para o BASIC.
Escolha a cor de letra e fundo (comando COLOR) que desejar. Se possuir
um MSX-2, troque a largura da tela para 80 colunas (comando WIDTH). Em
seguida, carregue o programa com: BLOAD"RSCII",R <RETURN>.
NOTA: Se em alguma ocasião você trocar seu computador por outro MSX,
envie sua cópia do programa a RSC SOFTWARE e ela será trocada
GRATUITAMENTE.
Capítulo 2 - COMANDOS DO EDITOR
Uma vez posto para funcionar o programa, aparecerá a seguinte tela:
Macro-Ensamblador/Linkador RSC II
Versión MSX 1.0 por Ramón Sala
(C) RSC SOFTWARE - 1990
16255 bytes libres
Vale
Para poder realizar todas as funções de que é capaz, o RSC II
dispõe de uma série de comandos a serem digitados, em MODO DIRETO,
que serão estudados a seguir. Você irá observar que em sua sintaxe,
alguns parâmetros aparecem entre colchetes. Isto significa que são
opcionais e, por tanto, podem ser omitidos de acordo com a situação.
Obviamente, quando forem utilizados, devem vir sem os colchetes.
Ao contrário, as partes do comando que não estão entre colchetes,
são indispensáveis para o funcionamento normal do mesmo.
Se você conhece o Assemblador/Desassemblador RSC, será bem fácil
familiarizar-se com os comandos e pseudo-comandos desta nova versão,
porque seguem a mesma linha. O RSC II possui alguns comandos novos
que, junto aos antigos são 33 no total, serão explicados
detalhadamente a partir das próximas páginas. Estude-os a fundo e
você descobrirá a enorme quantidade de funções que podem ser
realizadas com este programa.
ATENÇÃO: Se você possuía o Assemblador/Desassemblador RSC e deseja
utilizar os arquivos de texto que gravou com o No.1 no novo RSC II ,
veja o capítulo 6 para a utilização do programa CONVERT.
*********************************************************************
Comando: &B
Sintaxe: &B[(]x1[)] <RETURN>"
Efetua a conversão do número x1 ao sistema decimal, se x1 for
binário, conversão para binário, se x1 for decimal ou hexadecimal,
neste caso entre parêntesis.
Exemplo 1: &B01110011 <RETURN>
Indica o equivalente no sistema decimal do número binário 01110011.
Exemplo 2: &B(50000) <RETURN>
Indica o equivalente no sistema binário do número decimal: 50000.
Exemplo 3: &B(&HFFFF) <RETURN>
Indica o equivalente no sistema binário do número hexadecimal: HFFFF.
NOTA: Em todos os casos, o número x1 deverá ser de no máximo 16 bits
(65535 ou &HFFFF).
*********************************************************************
Comando: &H
Sintaxe: &H[(]x1[)]"
Efectua a conversão do número x1 para decimal, se x1 for hexadecimal,
converte para hexadecimal, se x1 for decimal ou binário, devendo
estar entre parêntesis.
Exemplo 1: &HFFFF <RETURN>
Indica o equivalente no sistema decimal do número hexadecimal: FFFF.
Exemplo 2: &H(50000) <RETURN>
Indica o equivalente no sistema hexadecimal do número decimal: 50000.
Exemplo 3: &H(&B01110011) <RETURN>
Indica o equivalente no sistema hexadecimal do número binário 01110011.
NOTA: Em todos os casos, o número x1 deverá ser de no máximo 16 bits
(65535 ou &HFFFF).
*********************************************************************
Comandos: A: e B:
Sintaxe: A: <RETURN>
Sintaxe: B: <RETURN>
Em caso de dispor de duas unidades de disco, este comando ativa
uma ou outra unidade de disco como a principal, isto é, será a
unidade de salvar ou carregar dados.
Exemplo 1: A: <RETURN>
Ativa a unidade de disco: A, como unidade principal.
Exemplo 2: B: <RETURN>
Ativa a unidade de disco: B, como unidade principal.
NOTA: Estes dois comandos são somente válidos para o RSC II versão
disco.
*********************************************************************
Comando: BA (BAsic)
Sintaxe: BA <RETURN>
Permite voltar ao BASIC e trabalhar nesta linguagem, mantendo o RSC
II na memória para voltar a utilizá-lo, quando necessário. Se quando
foi utilizado o RSC II, nenhum dos endereços que afetam ao BASIC foi
usado, ele estará intacto na memória.
Exemplo: BA <RETURN>
Se uma vez no basic você desejar voltar ao RSC II, tecle o seguinte:
DEFUSR=&HF980:X=USR(0) <RETURN>. O programa RSC II e o código fonte
(caso houver) não haverão sofrido modificação alguma.
É aconselhável gravar os endereços compreendidos entre &HF980 e
&HF9A8 (que contêm a rotina que permite o retorno ao RSC II), visto
que se encontram no buffer utilizado pela instrução do BASIC: PLAY e
poderiam ser midificadas. Portanto, uma vez carregado RSC II e
devolvido o controle ao BASIC (comando BA), tecle o seguinte:
BSAVE "VOLVER",&HF980,&HF9A8 <RETURN>
Visto que a rotina é sempre a mesma, somente será preciso gravar
uma vez. Deste modo, se houver uma suspeita de que ela foi
alterada, podemos recuperá-la com: BLOAD"VOLVER" <RETURN>
NOTA: Se tiver que trabalhar no BASIC e ao mesmo tempo utilizar o
Macro-Assemblador, deve-se primeiro carregar o RSC II, devolver o
controle ao BASIC e começar o trabalho nesta linguagem. Desta
maneira, RSC II já está na memória (sem afetar nada no BASIC) e
pode ser chamado, quando precisar dele, da maneira antes indicada.
*********************************************************************
Comando: BL (Bytes Livres)
Sintaxe: BL <RETURN>"
O Macro /Assemblador RSC II dispõe de 16255 bytes para a introdução
do código fonte. Através do comando BL, você poderá saber, a todo
instante, a quantidade de bytes livres que restam.
Exemplo: BL <RETURN>
Retorna a quantidade de memória disponível (em bytes) que resta
para a introdução de texto.
NOTA: Não é possível utilizar a totalidade de memória (16255 bytes)
para armazenar um arquivo fonte, porque o assemblador necessita de
uma certa quantidade para colocar as etiquetas. Esta quantidade,
depende do tamanho (e número de etiquetas) que possui o arquivo a
assemblar, e oscila entre 800 e 2000 bytes.
*********************************************************************
Comando: BO (BOrrar = apagar)
Sintaxe: BO x1[-x2] <RETURN>
Apaga o bloco de código fonte compreendido entre as linhas x1 e x2.
Se x2 for omitido, somente a linha x1 é apagada.
Exemplo 1: BO 100 <RETURN>
Apaga a linha número 100 do arquivo de texto (listagem).
Exemplo 2: BO 50-150 <RETURN>
Apaga o bloco de texto compreendido entre as linhas 50 e 1500 (ambas
inclusive).
Além do comando BO, é possível apagar qualquer linha, simplesmente
teclando seu número, seguido de <RETURN>.
NOTA: Quando uma das duas linhas indicadas em x1 e x2 não existir, se
provoca um erro 2.
*********************************************************************
Comando: BR (BoRrar = apagar)
Sintaxe: BR "nome.ext" <RETURN>
Apaga do disco o arquivo: nome.ext. Se o arquivo indicado não
existir, provoca-se um erro 16.
Exemplo: BR "EXEMPLO.ASM" <RETURN>
Apaga o arquivo que tem o nome EXEMPLO.ASM.
NOTA: Este comando somente é válido para RSC II versão disco.
*********************************************************************
Comando: BU (BUscar = procurar)
Sintaxe: BU[#] x0,x1,x2,...xn <RETURN>
Procura uma sucessão de bytes composta por: x1, x2, ..., xn (tantos
quantos couber em uma linha), a partir do endereço x0. Quando o
encontra (se é que existe) emite um BEEP e mostra o endereço que
começa. Do contrário, a busca termina ao alcançar o endereço &HFFFF
(65535).
Exemplo 1: BU &H8000,&H76 <RETURN>
Busca, a partir do endereço &H8000 (no slot que estiver ativo neste
momento), um byte que contenha o valor &h76 (118).
Exemplo 2: BU 50000,&HCD,&H10,&H40 <RETURN>
Busca, a partir do endereço 50000 (no slot que estiver ativo neste
momento), três bytes consecutivos contendo os valores &HCD, &H10 e
&H40.
Exemplo 3: BU &HC000,"A","B" <RETURN>
Busca a partir do endereço &HC000 (no slot que estiver ativo neste
momento), a cadeia constituída por "AB" (&H41 e &H42 respectivamente).
Quando utilizar a opção [#], siga as instruções dada para o mesmo, no
capítulo 4.5.
Exemplo 4: BU# &H3F00,&HCD,"A",&H76 <RETURN>
Ao ter utilizado a opção [#], você indicará o slot em que será feito
a busca. Supondo que você tenha respondido: 3-2, a busca será feita
no subslot 2 do slot 3, por um bloco de três bytes consecutivos,
contendo: &HCD, "A" (&H41) e &H76.
NOTA: Este comando mostra a todo instante o endereço que está sendo
procurado. A busca pode ser interrompida, pressionando-se <CONTROL+
STOP>.
*********************************************************************
Comando: CB (Cargar Bytes = carregar bytes)
Sintaxe: CB "nome[.ext]" <RETURN>
Carrega o programa em linguagem de máquina que tenha o nome
indicado entre aspas. Quando terminar a carga, três endereços
em hexadecimal são mostrados, que são, respectivamente, endereço
inicial, final e de partida e execução do programa carregado. Se
desejas carregar a partir do cassete (unicamente quando se utiliza a
unidade de disco), acrescente a letra "C" ao comando (CBC).
Exemplo 1: CB "EXEMPLO" <RETURN>
Carrega o programa que tem o nome EXEMPLO.BIN.
Exemplo 2: CBC "TESTE" <RETURN>
Carrega do cassete o programa que tenha o nome TESTE.
Em ambos os casos, quando o arquivo solicitado não for encontrado,
provoca-se o erro 16.
O comando CB, carregará todos os programas que foram gravados com
GB ou do BASIC com BSAVE.
NOTA: Quando se omite a extensão, o programa a coloca automaticamente
(BIN neste caso. Para mais informação, vá para o capítulo 5.2).
*********************************************************************
Comando: CC (Cargar COM = carregar COM)
Sintaxe: CC "nome[.ext]" <RETURN>
Carrega o programa com o nome indicado entre aspas (e com extensão
COM ou SYS) e o coloca a partir do endereço &H8100. Ao final do
carregamento, são mostrados os endereços inicial e final (em hexade-
cimal) aonde foi colocado o programa.
Exemplo 1: CC "COMMAND.COM" <RETURN>
Carrega o programa com o nome de COMMAND.COM.
Exemplo 2: CC "MSXDOS.SYS" <RETURN>
Carrega o programa com o nome de MSXDOS.SYS.
Exemplo 3: CC "EXEMPLO" <RETURN>
Carrega o programa com o nome de EXEMPLO.COM.
Este comando unicamente será valido para RSC II na versão disco.
NOTA: Quando se omite a extensão (exemplo 3), esta é colocada pelo
programa automaticamente (neste caso COM. Ir ao capítulo 5.2).
*********************************************************************
Comando: CT (Cargar Texto = carregar texto)
Sintaxe: CT "nome[.ext]" <RETURN>
Carrega o arquivo de texto com o nome que é indicado entre aspas.
Em caso de haver algum arquivo na memória ao utilizar este comando,
ele será carregado depois do corrente e todo o programa será
renumerado. Deste modo, é possível unir arquivos distintos e
convertê-los a um só. Se não houver memória suficiente para alojar
o programa solicitado, provoca-se um erro 6.
Exemplo 1: CT "EXEMPLO.RSC" <RETURN>
Carrega na memória o arquivo de texto com o nome EXEMPLO.RSC.
Exemplo 2: CT "EXEMPLO" <RETURN>
Carrega na memória o arquivo de texto com o nome EXEMPLO.ASM.
Quando se omite a extensão, o programa a coloca automaticamente
NOTA: O comando CT carregará UNICA E EXCLUSIVAMENTE os arquivos
gravados com GT.
*********************************************************************
Comando: DE (DEsensamblar)
Sintaxe: DE[#] x1-x2[,I][,G] <RETURN>
Desassembla (converte em código fonte) o bloco de memória compreen-
dido entre os endereços x1 e x2 (ambas inclusive). Ao utilizar este
comando, aparece a seguinte mensagem:
Modo (H/D):
Que solicita se a lista deve ser feita em Hexadecimal ou Decimal.
Responda H ou D de acordo com sua vontade e tecle <RETURN>. A seguir,
aparece a mensagem:
DEFB:
Que solicita os endereços que não devem ser tratados como código
objeto, se não como zona de dados. Se há alguma zona que deva ser
tratada desta maneira, introduza os endereços inical e final
separados por um hífen. Do contrário, simplesmente tecle <RETURN>.
Exemplo 1: DE &H8000-&HA000 <RETURN>
Desassembla a parte da memória compreendida entre os endereços
&H8000 e &HA000.
Quando for utilizada a opção [#], siga as instruções dadas para
a mesma no capítulo 4.5.
O comando DE dispõe ainda da opção [,G] que permite gravar o
código fonte que gera como um arquivo texto (com o mesmo formato
que faz o comando GT). Deste modo, o arquivo assim criado poderá
ser carregado a qualquer momento com CT.
Exemplo 2: DE &H100-&H1A00,G <RETURN>
Desassembla o bloco de memória compreendido entre os endereços
&H100 e &H1A00, gravando-o como um arquivo texto.
Além de todas as mensagens vistas anteriormente, com a opção
[,G] aparecerá a seguinte:
Nombre:
Que solicita o nome que será dado à gravação. Coloque-o entre aspas
(se for omitida a extensão, esta será ASM). Por exemplo
"TESTE" e tecle <RETURN>.
Neste momento, deverá estar no ponto o disco ou o cassete.
A opção [,G] é a única que coloca o código fonte (antes de
gravá-lo) na parte de memória utilizada pelo Assemblador para arma-
zenar o código fonte e, portanto, apagar qualquer arquivo que tenha
ali. Se houver algum, deverá salvá-lo previamente se não quiser
perdê-lo.
Quando se utiliza a opção [,I], a listagem é passada para a
impressora.
NOTA: Quando o código fonte que é gerado é grande demais para caber
em uma só gravação, o programa efetuará todas que sejam necessárias
e irá solicitando o nome das mesmas. Entre cada gravação, aparecerá
o último endereço desassemblado que foi gravado, com seus códigos
objeto e fonte correspondentes.
*********************************************************************
Comando: EN (ENsamblar)
Sintaxe: EN [x1] <RETURN>
Assembla o código fonte (converte em linguagem de máquina) começando
pela linha x1. Se x1 for omitido, começa-se a assemblar desde a
primeira linha. Quando não há nenhum arquivo fonte na memória, o
comando fica sem efeito, mas não provoca erro.
Exemplo 1: EN <RETURN>
Assembla o arquivo fonte que está na memória, começando pela primeira
linha do mesmo.
Exemplo 2: EN 100 <RETURN>
Assembla o arquivo fonte que está na memória, somente a partir da
linha 100.
Em ambos os casos, aparecerá a seguinte mensagem:
No. de Opción:
Que solicita o tipo de assembler que deve ser feito. Dispõe-se das
seguintes opções:
0= (ou simplesmente teclando <RETURN>). Assembla o arquivo sem
mostrar nenhuma lista (opção rápida).
1= Assembla o código fonte mostrando a listagem por tela.
2= Igual a opção 1, mas mandando a listagem para a impressora.
3= Assembla o código fonte, mostrando uma listagem por tela e
listando ao final todas as etiquetas e macros.
4= Igual a opção 3, mas mandando a listagem para a impressora.
Em todas estas opções, o Assemblador vigia para que o código
fonte nunca chegue a alcançar, ou ultrapassar, a zona de
memória utilizada pelo SP (cujo endereço depende de diversos
fatores). De todas as formas, se desejar assemblar em algum
endereço acima, some 10 ao número de opção. Isto é, as opções
10, 11, 12, 13 e 14, realizam a mesma função, respectivamente,
que as 0, 1, 2, 3 e 4, mas sem se preocupar aonde coloca o código
objeto. Se acrescentar um "M" a opção (p.e.: 1M, 12M, etc), serão
listadas o conteúdo das macros ao chamá-las.
Ao final do desassemblado, se não houverem erros, será mostrada
uma lista com as etiquetas ausentes (não definidas). Quando o
arquivo assemblado contiver o arquivo completo, NÃO deverá haver
nenhuma etiqueta sem ser definida. Por outro lado, deve-se linkar
com outros, logicamente que apareçam ausentes, as etiquetas que,
encontradas em outros arquivos, são chamadas desde o mesmo que se
assembla.
IMPORTANTE: Veja o capítulo 5.1 para o assemblado em endereços
inferiores a &H8000.
NOTA: Com o fim de poder armazenar as etiquetas, não de esqueça de
deixar entre 800 e 2000 bytes livres (segundo as etiquetas e tamanho
que tenha o arquivo).
*********************************************************************
Comando: FU (FUnciones S/N)
Sintaxe: FU x <RETURN>
Faz aparecer (quando x=S), ou desaparecer, (quando x=N) a última
linha da tela que mostra o conteúdo das teclas de função.
Exemplo 1: FU N <RETURN>
Desaparece a última linha da tela que contêm as teclas de função.
Exemplo 2: FU S <RETURN>
Aparece a última linha da tela que contêm as teclas de função.
*********************************************************************
Comando: GB (Grabar Bytes)
Sintaxe: GB "nome[.ext]",x1,x2,[x3]
Grava o programa em código de máquina, com o nome que é indicado
entre aspas, onde x1 será o endereço inicial, x2 o final e x3 o de
execução. Se se omite x3, será tomado como endereço de execução o mesmo
que o inicial. Se quiseres gravar em cassete (somente quando se utiliza
a unidade de disco), acrescente a letra "C" ao comando (GBC.)
Exemplo 1: GB "EJEMPLO.RSC",&H8010,&HC0B0,&HC000
Grava o programa contido entre os endereços &h8010 e &HC0B0, com o nome
de EXEMPLO.RSC, colocando como endereço de execução em &HC000.
Exemplo 2: GB "EXEMPLO",&H8010,&HC0B0
Grava o programa contido entre os endereços &h8010 e &HC0B0, com o nome
de EXEMPLO.BIN, colocando como endereço de execução em &H8010.
Exemplo 3: GBC "TESTE",&H8010,&HC0B0
Grava o programa igualmente ao exemplo anterior, mas no cassete e com
o nome de TESTE.
Todos os programas gravados com o comando GB podem ser carregados do
BASIC com o BLOAD.
NOTA: Quando se omite a extensão, o programa a coloca automaticamente
(BIN neste caso. Para mais informação, consulte o capítulo 5.2).
*********************************************************************
Comando: GC (Grabar COM)
Sintaxe: GC "nome[.ext]",x1,x2
Grava o programa em código de máquina com o nome que é indicado entre
aspas, compreendido entre os endereços x1 e x2. A diferênça para o GB é
que este comando grava os programas no formato .COM (ou SYS) para que
possam ser carregados pelo D.O.S..
Exemplo 1: GC "EXEMPLO",&H8100,&HA000
Grava o programa contido entre os endereços &H8100 e &HA000, com o nome
de EXEMPLO.COM
Exemplo 2: GC "MSXDOS.SYS",&H8100,&HA000
Grava o programa contido entre os endereços &H8100 e &HA000 com o nome
de MSXDOS.SYS.
ATENÇÃO: Leia o capítulo 5.1 para a gravação de programas no formato
.COM (endereços inferiores a &H8000).
Este comando somente será válido para RSC II em versão disco.
NOTA: Quando se omite a extensão, o programa a coloca automaticamente
(COM neste caso. Para mais informação, consulte o capítulo 5.2).
*********************************************************************
Comando: GT (Grabar Texto)
Sintaxis: GT "nome[.ext]"[,x1][,x2]
Grava o bloco de texto que compreendem as linhas x1 a x2 (ambas
inclusive), com o nome que é indicado entre aspas. Se se omite x2,
somente a linha x1 é gravada. Se se omitem x1 e x2, todo o arquivo
é gravado.Se não houver nenhum arquivo na memória, o comando se
torna sem efeito.
Exemplo 1: GT "EXEMPLO",100 <RETURN>
Grava a linha 100 do arquivo que está na memória, com o nome de
EXEMPLO.ASM.
Exemplo 2: GT "EXEMPLO",100-500 <RETURN>
Grava o bloco de texto compreendido entre as linhas 100 e 500
(ambas inclusive), do arquivo que está na memória, com o nome de
EXEMPLO.ASM.
Exemplo 3: GT "EXEMPLO" <RETURN>
Grava todo o arquivo de texto que está na memória com o nome de
EXEMPLO.ASM.
NOTA: Quando se omite a extensão, o programa a coloca automaticamente
(ASM neste caso. Para mais informação, consulte o capítulo 5.2).
*********************************************************************
Comando: IM (IMpresora)
Sintaxe: IM x1 <RETURN>
Indica o número de linhas por página na hora de listar na impressora.
Quando x1=0, as linhas são impressas uma atrás da outras sem dar saltos
de página (esta opção, é a que se encontra ativa ao iniciar o programa).
Exemplo 1: IM 62 <RETURN>
Indica ao programa que efetue um salto de página a cada 62 linhas.
Exemplo 2: IM 0 <RETURN>
Desliga a opção IM e não são dados saltos de página.
NOTA: Este comando atua corretamente sempre que o total de linhas de
uma listagem não seja maior que o total de linha de uma impressora.
*********************************************************************
Comando: IN (INtroducir)
Sintaxe: IN [x1][,x2] <RETURN>
Numera automaticamente as linha de texto, facilitando sua digitação,
onde x1 é o primeiro número de linha e x2 o incremento. Quando x1 e x2
são mitidos, seu valor por default é 10.
Exemplo 1: IN <RETURN>
Dá a primeira linha o número 10, incrementando as seguintes de 10 em
10 (10, 20, 30, etc).
Exemplo 2: IN 100 <RETURN>
Dá a primeira linha o número 100, incrementando as seguintes de 10 em
10 (100, 110, 120, etc).
Exemplo 3: IN 100,2 <RETURN>
Dá a primeira linha o número 100, incrementando as seguintes de 2 em
2 (100, 102, 104, etc).
Além do comando IN, podem ser introduzidas linhas diretamente,
simplesmente teclando seu número, seguido do texto correspondente e
<RETURN>.
NOTA: Dentro do modo IN, as linhas que já estão ocupadas, aparecerão
seguidas de um asterisco (*). Para sair de IN, tecle <CTRL+C> ou
<CTRL+STOP>.
*********************************************************************
Comando: LE (Listar Etiquetas)
Sintaxe: LE[,I] <RETURN>
Lista todas as etiquetas e macros que são produzidas depois de uma
assemblada (ou link) com seus valores em decimal e hexadecimal. As
etiquetas permanecem na memória, até que se produza alguma variação
do código fonte (carregar um arquivo e modificar, adicionar ou apagar
uma linha). No caso de não haver nem etiquetas e nem macros, o
comando fica sem efeito, mas não provoca erro.
Exemplo: LE <RETURN>
Lista todas as etiquetas e macros com seus respectivos valores em
decimal e hexadecimal.
Quando se utiliza a opção [,I], a lista sai na impressora.
NOTA: Mesmo que as macros sejem listadas junto com as etiquetas,
são distinguidas destas por não levarem ponto final. Visto que o
valor de uma macro não pode ser fixo, já que varia cada vez que
é chamada, o valor que aparece associado a ela é simplesmente o
endereço que ocupa dentro do arquivo de texto.
*********************************************************************
Comando: LK (LinKar)
Sintaxe: LK "nome[.ext]",["nome[.ext]"],..."
Linka os arquivos de texto entre aspas e separados por vírgulas (se
a extensão for omitida, assume-se ASM).
Por motivos de compatibilidade com todas as máquinas MSX, o comando
LK dispõe de 16 K de memória para armazenar as etiquetas de todos os
arquivos fontes que são linkados. Portanto, é possível linkar tantos
arquivos quanto seja desejável, sempre e enquanto o espaço permitir.
Ainda assim, com 16 K podem linkar-se de 15 a 20 arquivos fonte (valor
mais que respeitável) que contenham uma quantidade de etiquetas
"normal". De outra forma, se for o caso de que haja tantas etiquetas
que se ultrapasse a memória disponível, provoca-se o erro 6.
O comando LK funciona igual ao EN e, além das informações deste,
solicita a seguinte:
Bytes Macros:
Para que lhe indique a quantidade de bytes que deverá ser reservada
paras as macros. Se os arquivos a serem linkados não tiverem macro
alguma, tecle <RETURN>. Do contrário, introduza uma quantidade de
bytes que seja proporcional ao número de macros que haja (para
calcular a quantidade de bytes que ocupa uma linha, conte os
caracteres que fazem parte dela, exceto o número da linha e os
espaços em branco e some 6).
Exemplo: LK "PARTE1","PARTE2","PARTE3","PARTE4"
Linka os arquivos fonte: PARTE1.ASM, PARTE2.ASM, PARTE3.ASM e
PARTE4.ASM.
Ao contrário do EN, LK interrompe o linkado, mostrando o erro 3,
se em alguns dos arquivos uma etiqueta é chamada e não for definida
em nehum deles.
Visto que, por questões de espaço, não é possível colocar todos
os arquivos na memória, LK dispõe de um buffer para ir depositando,
por partes, os arquivos que deve fazer o enlace (link). Na primeira
passada, atua da mesma forma que o comando EN. Ao contrário,
durante o segundo passo, carrega (no buffer) pequenas partes do
código fonte e as assembla, porque, fora os 16 K para armazenar as
etiquetas, não há nenhum limite na quantidade de arquivos a linkar.
O resultado de tudo isto, é que LK está constantemente acendendo
o disco (e o cassete) e, mesmo dependendo da velocidade de acesso
da unidade de disco, o linkado se efetua praticamente a mesma
velocidade que o assemblado.
Conseqüentemente, é aconselhável que todos os arquivos que
tiverem de ser linkados de uma só vez (no exemplo: PARTE1, PARTE2,
etc), se encontrem no mesmo disquete. Do contrário, o programa se
encarrega de dar o aviso correspondente:
Cambie el disco y pulse una tecla.
Podendo efetuar a troca de disquete, sem intrerromper o linkado,
tantas vezes quanto for preciso.
NOTA: Quando se omite a extensão, o programa a coloca automaticamente
(ASM neste caso. Para mais informação, consulte o capítulo 5.2).
*********************************************************************
Comando: LT (Listar Texto)
Sintaxe: LT [x1][-][x2][,I] <RETURN>
Lista a parte do arquivo fonte que está na memória, compreendida
entre as linhas x1 e/ou x2, ambas inclusive. Se x1 e x2 forem omitidos,
o arquivo será totalmente listado. No caso da emória estar vazia, o
comando fica sem efeito e nenhum erro é provocado.
Exemplo 1: LT 100-500 <RETURN>
Lista desde a linha 100 até a linha 500 (ambas inclusive).
Exemplo 2: LT 100- <RETURN>
Lista desde a linha 100 (inclusive) até a última linha do arquivo.
Exemplo 3: LT -100 <RETURN>
Lista desde a primeira linha do arquivo até a linha 100 (inclusive).
NOTA: Se for acrecida a opção [,I], em todos os casos, a listagem
correspondente será feita na impressora.
*********************************************************************
Comando: MV (MoVer)
Sintaxe: MV x1,x2,x3 <RETURN>
Move o bloco de arquivo de texto que está na memória, compreendido
entre as linhas x1 e x2 (ambas inclusive) e o coloca imediatamente
na continuação da linha x3. Seguidamente, o arquivo será totalmente
renumerado. Se não houver código fonte na memória ou algum dos números
indicados não existir, provoca-se um erro 2.
Exemplo 1: MV 100,500,1000 <RETURN>
Move o bloco de texto compreendido entre as linhas 100 e 500 e o
coloca na continuação da linha 1000.
Exemplo 2: MV 500,1000,100 <RETURN>
Move o bloco de texto compreendido entre as linhas 500 e 1000 e o
coloca na continuação da linha 100.
*********************************************************************
Comando: NU (NUevo)
Sintaxe: NU <RETURN>
Ao finalizar a introdução de um arquivo de texto e depois gravá-lo
com o comando GT, o comando NU apaga por completo os 16255 bytes que
dispõe o Assemblador. Desta maneira, a memória fica pronta para receber
um arquivo de texto novo.
Se a memória já estiver vazia, este comando não tem efeito algum e
não provoca erro algum.
Exemplo: NU <RETURN>
Apaga os 16255 bytes de memória do Assemblador.
NOTA: Não se esqueça de gravar o arquivo que está na memória antes
de utilizar o comando NU, já que depois da sua execução, não se
pode recuperar o que havia nela.
*********************************************************************
Comando: PO (POkear)
Sintaxe: PO x1,x2 <RETURN>
Coloca o valor x2 (máximo 255) no endereço de memória x1 (máximo
65535). Se um (ou ambos) dos parâmetros exceder os valores indicados,
provoca-se o erro 5.
Exemplo 1: PO &H8000,&H76 <RETURN>
Coloca o valor &H76 no endereço de memória No. &H8000 (32768).
Exemplo 2: PO 50000,"A" <RETURN>
Coloca o valor ASCII da letra A (&H41 ¢ 65) no endereço de memória
50000.
*********************************************************************
Comando: PR (PRobar)
Sintaxe: PR[#] x1 <RETURN>
Executa um programa em código de máquina, onde x1 é o endereço de
partida. Logicamente, o código objeto deve encontrar-se na memória,
seja carregando ele (comando CB) ou assemblando arquivos fontes a
partir do RSC II.
Exemplo: PR &H8000 <RETURN>
Põe para rodar um programa, cujo endereço de execução é &H8000.
Para poder executar todo tipo de programa, o comando PR configura
a memória desta maneira:
Páginas 0 e 1 = ROM (BIOS e ROM BASIC)
Páginas 2 e 3 = RAM acessível ao BASIC
O qual permite colocar em execução os programas (comerciais ou não)
que são carregados a partir do BASIC.
A opção [#] não modifica a configuração dos slots e é utilizada
para testar rotinas ou programas que estejam em outro slot ou
subslot. Quando utilizares esta opção, siga as instruções dada para
a opção [#] no capítulo 4.5
NOTA: Se o programa executado com PR em qualquer modo, não modificar
o SP e finalizar com um RET, o editor RSC II volta ao controle.
*********************************************************************
Comando: RE (REnumerar)
Sintaxe: RE [x1][,x2][,x3] <RETURN>
Renumera linhas de texto, onde x1 é o novo número de linha, x2 é o
numero de linha antigo e x3 o incremento. O valor default dos
parâmetros são: x2=1, x1 e x3=10. Quando algumas das linhas indicadas
(x1, x2, x3) não existir, provoca-se o erro 2.
Exemplo 1: RE <RETURN>
Renumera todo o arquivo, dando a primeira linha o número 10 e
incrmentando as seguintes de 10 em 10 (10, 20, 30, etc).
Exemplo 2: RE 100 <RETURN>
Renumera todo o arquivo, dando a primeira linha o número 100 e
incrmentando as seguintes de 10 em 10 (100, 110, 120, etc).
Exemplo 3: RE 1000,100 <RETURN>
Renumera o arquivo somente a partir da linha 100, que passa a ser
a 1000, e incrementa as seguintes de 10 em 10 (1000, 1010, 1020, etc).
Exemplo 4: RE 1000,100,2 <RETURN>
Renumera o arquivo somente a partir da linha 100, que passa a ser
a 1000, e incrementa as seguintes de 2 em 2 (1000, 1002, 1004, etc).
*********************************************************************
Comando: RN (ReNombrar)
Sintaxe: RN "nome1.ext","nombre2[.ext]"
Renomeia o arquivo NOME1.EXT que passa a se chamar NOME2.EXT. Quando
o arquivo solicitado não é encontrado no disco, provoca-se o erro 16.
Exemplo 1: RN "EXEMPLO1.BIN","EXEMPLO2.RSC"
Renomeia o arquivo chamado EXEMPLO1.BIN, que passa a se chamar
EXEMPLO2.RSC.
Exemplo 2: RN "EXEMPLO1.ASM","EXEMPLO2"
Renomeia o arquivo chamado EXEMPLO1.ASM, que passa a se chamar EXEMPLO2
(sem extensão).
NOTA: Quando o programa que se deseja renomear, tiver extensão (nos
exemplos anteriores EXEMPLO1.BIN e EXEMPLO2.ASM), este deverá ser
posto OBRIGATORIAMENTE de acordo do nome atual do programa, isto é,
o que segue ao comando RN.
*********************************************************************
Comando: SI (SImular)
Sintaxe: SI[#] x1[,I] <RETURN>
Simula um programa em linguagem de máquina, começando pelo endereço
x1.
Exemplo: SI &H8800 <RETURN>
Começa a simulação do programa, situado no slot que estiver ativo
neste momento, pelo endereço &H8800.
Ao utilizar este comando, a seguinte tela é mostrada:
Slot: 11111111 I R P C
10101010 004A 8000
A B C D E H L I X I Y SZ H PNC
00 . 0000 0000 0000 0000 0000 00000000
00 . 0000 0000 0000 00000000
SP: FAE0
00 . 00 . 00 . 00 . 00 . 0000
00 . 00 . 00 . 00 . 00 . 0000
00 . 00 . 00 . 00 . 00 . 0000
00 . 00 . 00 . 00 . 00 . 0000
00 . 00 . 00 . 00 . 00 . 0000
00 . 00 . 00 . 00 . 00 . 0000
00 . 00 . 00 . 00 . 00 . 0000
00 . 00 . 00 . 00 . 00 . 0000
41 A 41 A 41 A 41 A 41 A 0000
55 U 55 U 55 U 55 U 55 U FAE0
32768 C9 RET
Na primeira linha aparece a configuração atual dos slots.
Imediatamente, é mostrada a configuração atual dos subslots (se
seu computador não tiver eles, esta informação é inútil) e os valores
dos registradores I, R e PC. Em seguida, aparece os registradores
restantes do Z-80, primeiro os que estão em uso (A, BC, DE, HL e F),
logo após os de reserva (A', B'C', D'E', H'L' e F') e o valor do SP.
Finalmente, é mostrado o conteúdo da posição de memória indicada
por cada registro (e as nove posições seguintes), o dez últimos
dados depositados na pilha (SP) e o endereço de memória que se
encontra o PC, com seu código objeto e fonte correspondente.
A partir deste momento, são dispostos nove comandos, representados
por uma letra, que permitem realizar diversas funções, que são as
seguintes:
E = Executa, REALMENTE, o passo atual (o que está na tela) e passa
ao seguinte. Muito cuidado com as instruções do tipo OUT (&HA8),A.
S = Passa (salta) ao passo seguinte sem executar o atual. Este
comando não produz nenhum efeito e se limita a desassemblar por
passos.
C = Troca (cambia) o conteúdo de uma ou várias posições de memória.
Ao teclar este comando, aparecerão dois pontos (:) que indicam que
o Simulador se encontra a disposição para receber dados. Você pode
trocar o conteúdo de uma posição de memória, seja introduzindo
diretamente o código objeto, ou por meio do código fonte. Por
exemplo: Vamos introduzir a partir do endereço &H8000 o comando
CALL 50000 (cojo código de máquina corresponde a CD, 50, C3).
Teclamos a letra "C", aparecem os dois pontos e escrevemos:
&H8000 CALL 50000 <RETURN>, ou &H8000 &HCD,&H50,&HC3 <RETURN>.
Vejamos outro exemplo: vamos trocar este mesmo endereço pelo
comando RET 9código de máquina &HC9). Ao aparecer os dois pontos,
teclamos: &H8000 RET <RETURN>, ou: &H8000 &HC9 <RETURN>. Qualquer
que seja o modo que ultilizar, NÃO COLOQUE mais espaços em branco
do que os que aparecem nos exemplos anteriores ou provocarás erro
e se interrompe a simulação.
L = Chama (llama) uma rotina e a executa de uma só vez. Este
comando é útil quando uma rotina é muito grande e não se deseja
executála por passos. NÃO utilize o comando L para instruções de
salto (JR, DJNZ ou JP) se não quiser travar o computador.
B = Permite trocar os bancos (slots) de memória. Tecle B e
aparecerão dois pontos (:). Introduza a nova configuração (de
preferência em binário) e tecle <RETURN> (p.e.: &B11111100-
&B10101000). Procure NUNCA trocar a página 1 (bits 2 e 3), já
que é aonde está situado o RSC II, nem a página 3 (bits 6 e 7),
que deve estar em contato permanente com a ROM, porque travará
o computador (os bits são numerados de 0 a 7, começando pela
direita).
I = Coloca uma interrupção em qualquer parte do programa. Deste
modo, é possível executar de uma só vez, um certo número de
instruções. Tecle I e aparecerão dois pontos (:). Introduza,sem
deixar espaços, o endereço de memória onde deverá ser feita a
interrupção e tecle <RETURN>. Tenha muito cuidado onde você coloca
a interrupção, já que se esta não é colocada no inicio de uma
instrução, os resultados são imprevisíveis.
R = Este comando permite chamar uma rotina que se situa em outro
slot, sem ter que trocar a configuração do mesmo, com o comando B.
O programa solicitará o slot e/ou subslot, em que está a rotina em
questão (com a mensagem Slot:). Responda seguindo as instruções
dadas no capítulo 4.5 (opção [#]). NÃO utilize o comando R para
instruções que não sejam do tipo CALL ou RST.
M = Permite modificar o conteúdo dos registradores do Z-80, mais
IX e IY. Ao teclar "M", o cursor irá para a primeira linha de
registradores (os atuais). Procure não se enganar e nem sair dos
limites que marcam os próprios registros, ou provocará erro e a
simulação será interrompida. Tanto se for feita uma modificação
como não, finalize com <RETURN> e passarás a linha seguinte
(registradores de reserva). Faça do mesmo jeito.
O = Permite modificar os registradores restantes, ou seja, PC e
SP (os valores de I e R são meramente informativos e não podem ser
modificados). Tecle "O" e aparecerão dois pontos (:). Em função do
registro que se deseja trocar, introduza (sem espaços) uma das
seguintes expressões:
PC=x1 <RETURN>
SP=x1 <RETURN>
Em qualquer caso, x1 tem que ser o valor que se deseja dar ao
registrador em questão. Seja cuidadoso ao modificar SP.
NOTA: Quando a opção [,I] é utilizada, a listagem é feita na
impressora.
ATENÇÃO: Ao utilizar o comando I (Interrupção) do simulador,
quando o número de instruções a serem simuladas (antes da
interrupção) for muito grande, cai no caso em que o programa
demorará bastante para executá-las. Ele pode dar a impressão de que
o computador está travado. Nestes casos, tem que ter um pouco de
paciência e esperar que termine.
*********************************************************************
Comando: TR (TRasladar)
Sintaxe: TR[#] x1,x2,x3 <RETURN>
Move o bloco de bytes, compreendido entre os endereços x1 e x2
(ambos inclusive) e o coloca a partir do endereço x3.
Exemplo 1: TR &H8000,&H9000,&HA000 <RETURN>
Move o conteúdo do bloco compreendido entre os endereços &H8000 e
&H9000, colocando-o no endereço &HA000 e seguintes.
Quando for utilizada a opção [#], siga as instruções dada para a
mesma no capítulo 4.5.
Exemplo 2: TR# &H4000,&H7FFF,&H8000 <RETURN>
Move o bloco de bytes, compreendido entre os endereços &H4000 e
&H7FFF (do slot que foi indicado), e o coloca a partir do endereço
&H8000 do slot que esteja ativo, ou seja, o slot que contem a
memória RAM. Quando a opção [#] é utilizada com este comando, a
movimentação é retardada em vários segundos (dependendo do tamanho
do bloco a mover). Isto poderia, a princípio, dar a impressão que o
computador travou.
*********************************************************************
Comando: VD (Ver Directorio)
Sintaxe: VD[,I] <RETURN>
Mostra todos os arquivos que se encontram no disco, com seu tamanho
em bytes e a data e hora de gravação.
Exemplo 1: VD <RETURN>
Lista na tela o direório do disco que se encontra na unidade.
Exemplo 2: VD,I <RETURN>
Lista na impressora o direório do disco que se encontra na unidade.
NOTA: Este comando é somente válido para RSC II em versão disco.
*********************************************************************
Comando: VE (VErificar)
Sintaxe: VE "nome"[,x1][-x2] <RETURN>
Este comando é executado junto do comanto GT e verifica se o bloco
de texto compreendido entre as linhas x1 e x2 (ambas inclusive) é
o mesmo que foi acabado de ser gravado com GT, no cassete. Se x1 e
x2 forem omitidos, a verificação é feita em todo o arquivo.
Exemplo 1: VE "TESTE" <RETURN>
Verifica se o arquivo que está na memória é idêntico ao que acabou
de ser gravado no cassete, com o comando GT "TESTE".
Exemplo 2: VE "TESTE",100-500 <RETURN>
Verifica se o bloco de texto, compreendido entre as linhas 100 e 500
(ambas inclusive) do arquivo que está na memória, é igual ao que
acabou de ser gravado no cassete, com GT "TESTE",100-500.
*********************************************************************
Comando: VM (Volcar Memoria)
Sintaxe: VM[#] x1[-x2][,I] <RETURN>
Efetua uma listagem de memória hexadecimal (com seus correspondentes
valores ASCII) das posições de memória, compreendidas entre x1 e x2
(ambas inclusive).
Exemplo 1: VM &HC000 <RETURN>
Faz uma listagem somente com a posição de memória &HC000.
Exemplo 2: VM &H8000-&HC000 <RETURN>
Faz uma listagem desde a posição de memória &H8000 até a &HC000 (ambas
inclusive)
Ao utilizar a opção [#], siga as instruções dada para a mesma no
capítulo 4.5.
NOTA: Quando se utiliza a opção [,I], a listagem é feita na impressora.
*********************************************************************
Capítulo 3 - INTRODUÇÃO DE LINHAS DE TEXTO
A introdução do código fonte é feita através de linhas numeradas
(igual ao BASIC). Uma linha pode conter até quatro campos distintos:
NÚMERO ETIQUETA INSTRUÇÃO COMENTÁRIO
10 SOMA: LD A,B ;Carrega A com B
20 LD C,20 ;Carrega C com 20"
30 ADD A,C ;Soma A e C"
40 RET NZ ;Retorna se A<>0"
50 JR SOMA "
NÚMERO = É imprescindível colocá-lo, pois é o que indica que se trata
de uma linha.
ETIQUETA = É opcional e pode ser colocada sempre que seja preciso.
Quando se define uma etiqueta, quer dizer que quando tiver no
princípio da linha (p.e.: SOMA:) esta deve ser finalizada
OBRIGATORIAMENTE com dois pontos (:). Poderá conter no máximo de
8 caracteres que, exceto o primeiro que deverá ser uma letra, podem
ser números, letras ou a combinação de ambos. Ao chamar uma etiqueta,
ou seja, quando fizer parte da instrução (p.e.: JR SOMA), não deve ter
nunca dois pontos finais. É importante destacar, que não há palavras
reservadas para as etiquetas, portanto, é possível utilizar nomes
dos comandos do assemblador do Z-80 e seus pseudos-comandos.
INSTRUÇÃO = Se divide em duas partes: o COMANDO (p.e.: RET ou JR) e
o OPERANDO (p.e.: NZ e SOMA). O comando é imprescindível (a menos que
a linha seja formada unicamente por comentário) e pode ser qualquer
um dos permitidos para Z-80, e um dos 11 pseudos-comandos que é
permitido no RSC II (ver capítulo 4.1). O operando, quando houver
(algumas instruções não levam), pode ser formado por registradores,
condições, endereços, etc. Quando se tratar de algum valor numérico,
este pode ser dado mediante uma etiqueta ou em um dos três sistemas
numéricos que são admitidos (decimal, hexadecimal e binário). Quando
se tratar de valores hexadecimais ou binários, estes deverão ser
precedidos de: &H e &B, respectivamente.
COMENTÁRIO = É opicional e pode ser posto quando for desejado. Deve
ser precedido de ponto e vírgula (;), seguido (ou não) do texto
correspondente.
No instante de introduzir uma linha, não é necessário deixar
nenhum espaço em branco (mesmo ainda que possível colocar os que
deseja) para separar os distintos campos que a compõe, EXCETO o
espaço que separa o comando do operando (se houver), dentro do
campo de instrução, que deverá ser respeitado SEMPRE.
Quando se deseja que uma linha se componha simplesmente por uma
etiqueta, acrescente ao final um ponto e vírgula. Por exemplo:
ETIQUETA: ;
Capítulo 4 - OUTROS COMANDOS E FUNÇÕES
4.1 - PseudoCOMANDOS
O RSC II admite até 11 pseudo-comandos que realizam diversas
funções e são de grande utilidade na hora de programar na linguagem
do assemblador. Os pseudos-comandos somente funcionam em uma linha
(modo programa) e não devem ser introduzidos no modo direto. Os
parâmetros que acompanham alguns deles (x1, x2, etc), podem se dar
mediante um valor numérico, uma etiqueta ou uma expressão matemática
(ver seção 4 deste capítulo).
*********************************************************************
Comando: ORG
Sintaxe: ORG x1
Marca o endereço onde deve ser posto o código objeto que é gerado ao
assemblar um arquivo. O Assemblador dispõe de um contador que marca
o endereço onde deve colocar o código objeto ou linguagem de máquina.
Este contador toma como valor default o valor &H8000 (32768) ao
começar a assemblar. Se em uma linha se encontra um ORG, o contador
toma o valor a que ele é indicado (x1) e começa a colocar o código
objeto neste endereço.
*********************************************************************
Comando: DEFB
Sintaxe: DEFB x1,x2,x3,....xn
Define desde 1 até n valores (tantos quantos couberem em uma linha)
de um byte, que serão colocados a partir do endereço que marca o
contador no momento de passagem por esta linha, durante a montagem
(assemble) do programa.
*********************************************************************
Comando: DEFM
Sintaxe: DEFM "<cadeia>"
Define uma <cadeia> com tantos caracteres alfanuméricos (entre
aspas) enquanto couber em uma linha. Os respectivos valores ASCII
são colocados a partir do endereço de memória que marca o contador a
partir deste momento.
NOTA: Note a diferença entre DEFB 9 e DEFM "9".
*********************************************************************
Comando: DEFW
Sintaxe: DEFW x1,x2,x3,....xn
Define desde 1 até n valores (tantos quanto couberem em uma linha)
de dois bytes, que são colocados a partir do endereço de memória
que marca o contador neste momento.
*********************************************************************
Comando: DEFS
Sintaxe: DEFS x1
Reserva uma zona de memória. Quando o assemblador encontra o
comando DEFS, preenche com 0 (zero) tantos bytes como indica x1 (quer
dizer, o contador incrementa x1 bytes) e segue assemblando o
restante.
*********************************************************************
Comando: EQU
Sintaxe: EXEMPLO: EQU x1
Permite definir uma etiqueta com um valor concreto, onde EXEMPLO é
um nome de etiqueta (máx. 8 caracteres) e x1 é o valor atribuído a
ela.
Visto que as etiquetas recebem seus valoes, dependendo da posição
que ocupam dentro do código fonte, e o endereço em que é assemblado,
o comando EQU é muito útil para assegurar a uma etiqueta um valor
fixo, independemente do endereço que é indicado em ORG.
*********************************************************************
Comando: END
Sintaxe: END
O Assemblador RSC II efetua duas passagens. Durante a primeira, o
comando END é ignorado. Na segunda passagem, END indica o final do
assemblado e todas as linhas em seguida deverão ser ignoradas (não
assembladas). Ao contrário, ao linkar (comando LK), END é ignorado em
ambas as passagens.
*********************************************************************
Comando: MAC
Sintaxe: EXEMPLO: MAC
Define uma MACro, onde EXEMPLO será o nome que lhe assegura (máx. 8
caracteres). Todas as macros devem começar com uma etiqueta e o
comando MAC.
*********************************************************************
Comando: ENDM
Sintaxe: ENDM
Marca o final de uma macro. As macros devem ser finalizadas SEMPRE
com ENDM.
NOTA: Podem se unir entre si até 16 macros (ao chamá-las, NÂO ao
definí-las). Isto significa que dentro de uma macro, pode chamar
outra e outras.
*********************************************************************
Comando: IF
Sintaxe: IF x1
Condiciona o assemblado ao resultado da expressão x1. Quando x1 for
igual a zero, as linhas que seguem adiante não são assembladas. Do
contrário, se x1 for diferente de zero, a condição IF é ignorada e o
assemblado prosegue normalmente.
*********************************************************************
Comando: ENDI
Sintaxe: ENDI
Dá por finalizada uma condição IF, qualquer que seja, e as linhas
seguintes são assembladas com toda a normalidade. As condições IF,
sempre tem que ser finalizadas com ENDI.
NOTA: Não é possível linkar entre si as condições IF/ENDI
*********************************************************************
4.2 Comandos do Assemblador
O Assemblador admite até três comando que, sem exercer nenhuma
influência sobre o código objeto, proporcionam certas utilizades na
hora de fazer listagens. Este comando tem que ser precedidos de "^"
e são os seguintes:
*********************************************************************
Comando: ^C
Sintaxe: ^C "<cadeia>"
Permite definir uma <cadeia> alfanumérica (que deve vir entre aspas)
de até 45 caracteres, que será acrescentada no cabeçário da
apresentação.
*********************************************************************
Comando: ^P
Sintaxis: ^P
Efetua um salto de página imediatamente a partir da próxima linha
ao qual se encontra.
*********************************************************************
Comando: ^S
Sintaxis: ^S
Pára a listagem e o assemblado, até que se aperte uma tecla.
*********************************************************************
4.3 - Macros
Uma macro, abreviação de macro-instrução, é um conjunto de instru-
ções que devem ser utilizadas repetidas vezes ao decorrer do programa.
Vejamos um exemplo simples:
10 MOVE: MAC
20 LD HL,&H0100
30 LD DE,&H8000
40 LD BC,&H3F00
50 LDIR
60 ENDM
Quando em algum programa fore utilizadas várias vezes instruções
como estas, se poupará tempo e memória definindo uma macro. Deste
modo, cada vez que for necessário assemblar o texto de que é
composto, não será necessário repetí-lo. Simplesmente se chama a
macro pelo seu nome. Por exemplo:
4800 MOVE
Quando o Assemblador encontrar uma linha aonde se chama uma
macro, assemblará (no endereço que marca o contador neste momento)
todas as instruções do qual é composta pela macro. Mas observe
que os valores que contém (&H0100, &H8000 etc) são sempre os
mesmos. Para que as macros possam ser ainda mais úteis, é possível
substituir qualquer valor numérico por uma variável, representada
por um ponto de interrogação. O Exemplo anterior ficaria assim:
10 MOVE: MAC
20 LD HL,?
30 LD DE,?
40 LD BC,?
50 LDIR
60 ENDM
Neste caso, cada vez que se chama a macro, o nome da mesma deve
ser seguido de tantos valores numéricos, separados cor vírgulas,
como variáveis (ou pontos de interrogação) haja dentro dela.
Deste modo, é possível dar-lhe em cada caso o valor que mais
convenha. Por exemplo:
4800 MOVE &H6F00,&H9E40,&H2A80
O valor &H6F00 tomaria o lugar do primeiro ponto de interrogação
&H9E40 o do segundo e assim sucessivamente. Estes valores poderiam
se dar mediante uma etiqueta ou expressão matemática.
NOTA: Uma macro não pode conter nenhuma etiqueta a mais, a não ser
o nome que a define.
4.4 - Sinais aritméticos
Em certas ocasiões, é interessante poder realizar operações
matemáticas entre etiquetas e/ou valores numéricos. O Assemblador
pode efetuar oito destas operações (dentro de uma linha) que são:
+ SOMA
- SUBTRAÇÃO
* MULTIPLICAÇÃO
/ DIVISÃO INTEIRA
! AND
$ OR
% XOR
# MOD
Vejamos alguns exemplos:
10 LD A,8+4$2*ETIQUETA-10
20 SUB ETIQUETA/4*2
NOTA: Nenhum sinal tem preferência sobre os demais, portanto,
serão calculados na ordem em que forem encontrados.
4.5 - Slots/subslots
Todos os comando que dispuserem da opção [#], agem nos
endereços pertencentes ao slot ou slots que estejam ativos (e
que variam de acurdo com o computador). Mas RSC II permite
verificar qualquer slot (ou subslots, se houver) da máquina.
Então, ao utilizar a opção [#], aparece:
Slot:
Introduza o número de slot e tecle <RETURN>. Se se tratar de um
subslot, indique-o depois do slot (separado deste por um hífen,
p.e.: 3-2) e tecle <RETURN>.
5 - INFORMAÇÃO IMPORTANTE
5.1 - Endereços inferiores a &H8000
Quando se assembla (ou se linka) em endereços inferiores a
&h8000, o código objeto ou linguagem de máquina que é gerada
não podem ser colocadas nestes endereços, porque ali se encontra
o RSC II e o arquivo texto (ou código fonte) introduzido, e se
assim o fizer, o programa desaparecerá da memória. Por isso,
o Assemblador e/ou linkador, agem do seguinte modo:
Quando o endereço indicado pelo ORG for inferior a &h4000 (de 0
a &h3FFF), o código objeto correspondente será colocado no
endereço indicado + &H8000. Por exemplo, se um programa começar
no endereço &H100 e termina em &H2000, o código objeto gerado
será colocado nos endereços &H8100 (&H100+&H8000) e &HA000
(&H2000+&H8000).
Quando o endereço incado por ORG for compreendido entre &H4000
e &H7FFF, o código objeto correspondente será posto no endereço
indicado + &H4000. Por exemplo, se um programa começa no
endereço &H4000 e termina em &H7FFF, o código objeto será
colocado entre os endereços &H8000 (&H4000+&H4000) e &HBFFF
(&H7FFF+&H4000).
Sem dúvidas, o programa será assemblado para funcionar no
endereço indicado por ORG e a listagem e etiquetas (se houver)
farão referências a estes endereços.
Esta particularidade, longe de ser um incoveniente, é uma
vantagem, já que igualmente o código objeto deverá ser movido a
partir de &H8000 para ser gravado e posteriormente carregado
pelo BASIC.
Mesmo na hora de gravar o código objeto, deve-se ter em mente
o endereço em que este se localiza, com finalidade de dar o
endereço inicial, final, etc nos comandos de gravação GB ou GC.
Se por exemplo, for gravado um programa COM, que sempre começa
no endereço &H100 e o código objeto se encontrar a partir de
&H8100, este deve ser o endereço inicial que deve ser indicado
ao gravá-lo.
5.2 - Gravação e carregamento de programas
Quando nos comandos CB, CC, CT, GB, GC e GT for omitido a
extensão, esta é colocada automaticamente pelo RSC II (BIN para
CB e GB, COM para GC e CC, e ASM para CT e GT). Para gravar ou
carregar algum programa sem extensão, deve-se por unicamente o
ponto dentro do nome do programa. Por exemplo:
GT "EXEMPLO1.", CB "EXEMPLO2.", etc..
5.3 - Conselhos e notas finais
- Quando vários arquivos fonte são linkados, é aconselhável, a
fim de evitar erros, que somente o primeiro deles marque (com o
pseudo-comando ORG) o endereço inicial. Desta maneira, por mais que
se modifique os diferentes arquivos, não será necessário se
preocupar em mudar o endereço que deve começar cada um deles, uma
vez que serão alinhados um atrás do outro.
- Todas as listagens podem ser paradas, apertando a tecla <STOP>
(neste caso poderá ser dado seqüência, apertando-se qualquer
tecla) ou abandonadas totalmente pressionando-se <CTRL+STOP>.
- É possível dar boot a partir do RSC II, teclando o seguinte:
PR 0 <RETURN>.
- Por razões de segurança, não pode DEsensamblar, BUscar,
SImular, TRasladar, VOlcar memória, etc nos endereços compreen-
didos entre &h4000 e &h7FFF do slot em que se encontra o RSC II.
- O uso de ENsamblar e DEsensamblar, Volcar Memória, SImular,
etc, não afeta nada no código fonte ou código objeto que haja na
memória. EXCETO quando se utiliza a opção [,G] do comando DE, que
apaga todo o arquivo texto (se houver) da memória do Assemblador.
- As etiquetas podem ter no máximo oito caracteres (sem contar
os pontos). No caso de se exceder esta quantidade, o programa irá
absorver os oito primeiros e ignorar o restante.
- Uma macro, ao contrário de uma etiqueta, NÃO poderá nunca ser
definida com o mesmo nome de um comando do Z-80 ou de um pseudo-
comando.
- Apesar de, costumeiramente, as macros serem definidas no
inicio do texto, elas podem ser definidas em qualquer parte do
mesmo. O único cuidado a se ter, é que devem ser definidas antes
de serem chamadas.
- Os saltos relativos (JR e DJNZ) e os deslocamentos nos
registros de índice (IX e IY), podem ser dados mediante uma
etiqueta, ou até mesmo, indicando-se o número de bytes
diretamente. Neste último caso, os saltos e os deslocamentos
positivos (até adiante) e negativos (até atrás), tem que ser
precedidos dos sinais "+" e "-", respectivamente. Nos saltos
positivos, pode-se omitir o sinal "+".
- Em todos os comandos que afetam algum tipo de listagem,
aparece a mensagem:
Modo (H/D):
que solicita se a listagem deve ser feita em Hexadecimal ou
Decimal. Responda H ou D, de acordo com a preferência.
- Durante a simulação (comando SI), o programa utiliza a
zona compreendida entre &HF959 e &HFAF4.
- Os números binários e hexadecimais, deverão ser precedidos
de &HB e &H respectivamente. Todo número que não é precedido de
nenhum destes símbolos, será tratado como decimal.
- Observe que através do comando PR, pode-se executar qualquer
rotina da B.I.O.S..
5.4 - Erros
Erro 01 = Erro de sintaxe. Foi cometido algum erro na hora de
escrever algum comando.
Erro 02 = Função ilegal. Foi utilizado um ocmando de maneira
não autorizada.
Erro 03 = Foi chamada alguma etiqueta que não está definida.
ERRO 04 = Foi definida duas etiquetas em duas ocasiões (já
estava definida anteriormente).
Erro 05 = Valor excessivo. Foi atribuído algum valor acima de
65535 (&HFFFF), ou maior que 255 (&HFF) em lugares onde somente
é permitido valores de um byte.
Erro 06 = Memória completa. A memória foi completamente ocupada
(16255 bytes) quando se carregou ou introduziu o código fonte.
Também aparece este erro quando ao assemblar ou linkar, não se
dispõe de espaço suficiente para colocar as etiquetas.
Eroo 07 = Impressora desconectada. Foi utilizado a opção [,I] e
não há impressora ou não se encontra ON LINE.
Erro 08 = Foi definido um salto relativo fora dos limites
permitidos (de -128 a +127 bytes).
Erro 09 = Erro de E/S no disco. Foi gerado algum erro ao acessar
a unidade de disco.
Erro 10 = Interrompido. Foi interrompido um comando que fazia
qualquer tipo de listagem.
Erro 11 = Uma tentativa de se dividir um número por zero.
Erro 12 = Foi encontrado um comando ENDM ou ENDI sem que
previamente fosse definida uma macro com MAC ou uma condição com
IF, respectivamente.
Erro 13 = Disco não pronto. Foi acessada a unidade de disco sem
que esta se encontre pronta ou não haja nenhum disquete dentro
dela. Na versão cassete: Verificar fita. A gravação feita com GT
foi problemática.
Erro 14 = Foi definido uma MACro (ou um IF) dentro de outra, ou
a MACro não foi terminada com ENDM.
Erro 15 = O espaço reservado para macros com o comando LK é
insuficiente.
Erro 16 = Arquivo inexistente. Tentou-se carregar um arquivo que
não existe no disco.
Erro 17 = Disco protegido. Tentou-se gravar em um disco protegido
contra a escrita.
Erro 18 = Disco cheio. Tentou-se gravar em um disco que está
totalmente cheio.
Erro 19 = ORG incorreto. O código objeto adentra a zona de memória
utilizada por SP e o RSC II (veja o comando EN).
Erro 20 = Nome errado. O nome dado a um arquivo contém caracteres
não permitidos.
5.5 - Comandos permitidos para Z-80
ADC ADD AND BIT CALL CFF CP
CPD CPDR CPI CPIR CPL DAA DEC
DI DJNZ EI EX EXX HALT IM
IN INC IND INDR INI INIR JP
JR LD LDD LDDR LDI LDIR NEG
NOP OR OTDR OTIR OUT OUTD OUTI
POP PUSH RES RET RETI RETN RL
RLA RLC RLCA RLD RR RRA RRC
RRCA RRD RST SBC SCF SET SLA
SRA SRL SUB XOR
5.6 - Um programa exemplo
10 ;=================
20 ;Programa de teste
30 ;=================
40 ;
50 ORG &HC000
60 VALOR: EQU 4
70 SINAL: DEFM "$"
80 LD HL,0 ;HL=Inicio VRAM
90 INICIO: LD A,(SINAL) ;A=ASC("$")
100 CALL &H4D ;Rotina VPOKE (BIOS)
110 INC HL
120 LD 1,VALOR ;A=4 (linha 60)
130 CP H ;H=4?
140 JR NZ,INICIO ;Se não for, repete
150 CALL &H9F ;Perssione uma tecla
160 RET ;Retorna ao RSC II
Se você tiver um MSX-2 e estiver trabalhando com 80 colunas,
troque o número 4 da linha 60 por um 8.
Quando você acabar de digitar o programa, teste o comando LT.
Se quiser gravar o código fonte, utilize o comando GT (por ex.
GT "TESTE" <RETURN>). Agora assemble-o (EN <RETURN>), utilizando
a opção 1. Utilize o comando LE para listar as etiquetas. Se
não houverem erros e nem etiquetas ausentes, você pode gravar o
código objeto com GB (para poder carregá-lo do BASIC com
BLOAD). Para isto, digite:
GB "TESTE",&HC000,&HC013,&HC001 <RETURN>"
E agora você pode testá-lo (PR &HC001 <RETURN>). O programa
preenche toda a tela com o sinal "$". Aperte uma tecla, e o
programa voltará ao editor do RSC II. Desassemble (comando DE)
a parte que compreende os endereços &HC002 e &HC013 e aparecerá
o código fonte que você digitou anteriormente (mas logicamente,
sem pseudo-comandos e nem etiquetas). Digite: LT <RETURN> e
você verá como o código fonte (se você não o apagou) continua
intacto na memória. Tente apagá-lo (NU <RETURN>). Se agora você
listar o texto com LT, não vai aparecer nada. Volte a carregar
o texto com: CT "TESTE" <RETURN>. Se você dispuser de unidade
de disco, utilize o comando VD para verificar as gravações que
você fez. Trate de utilizar todos os comandos do editor do
RSC II, para se familiarizar com eles.
5.7 - Exemplo de macros linkadas
10 ;===========================
20 ;Programa que linka 3 macros
30 ;===========================
40 ;
50 MACRO1: MAC
60 LD A,?
70 ENDM
80 MACRO2: MAC
90 MACRO1 20
100 LD C,10
110 ENDM
120 MACRO3: MAC
130 MACRO2
140 ADD A,C
150 ENDM
160 ;
170 ORG &HC000
180 MACRO3
190 RET
200 FINAL: END
Este pequeno programa (muito pouco útil, por outro lado) é um
pequeno de como linkar as macros. Veja que não pode haver uma
macro dentro de outra ao defini-la, ou seja, antes de escrever
outra macro, é preciso encerrar a anterior com ENDM.
A linha 180 chama a MACRO3. Ao executá-la, esta chama a MACRO2,
que por sua vez, chama a MACRO1. Visto que esta última contém
uma variável (?), deve acompanhar o nome da macro um valor de
byte (já que o registrador A somente pode conter até o numero
255). Uma vez executada a MACRO1, volta-se a MACRO2, que dá um
valor a C e retorna a MACRO3 que soma A e C. Ao finalizar esta,
volta-se a linha 190, que marca o final do programa.
6 - O PROGRAMA CONVERT
O novo Macro-Assemblador/Linkador RSC II modifica, ligeira-
mente, o formato com que ele grava os arquivos de texto (código
fonte). Deste modo, acelera-se a velocidade de assemble e os
arquivos podem ser linkados. Por isto, é incluído o programa
CONVERT, que converte qualquer arquivo gravado com o Assembla-
dor RSC, ao novo formato do RSC II (em menos de um segundo).
Assim, podem ser aproveitados todos os arquivos fontes
anteriores, sem ter que reescrevê-los.
CONVERT pode trabalhar a partir do BASIC ou a partir do RSC
II. Para carregá-lo do BASIC, digite: BLOAD "CONVERT.BIN",R.
Se você desejar carregar do RSC II, utilize o comando
CB "CONVERT" e, quando estiver carrgado, execute-o com:
PR &HC000
Uma fez posto a funcionar, o programa pedirá o nome do
arquivo que você deseja converter. Introduza-o (ENTRE ASPAS)
e tecle <RETURN>. Se você omitir a extensão, esta será ASM.
Quando terminar a conversão, CONVERT pedirá o nome que deseja
dar ao arquivo convertido. Introduza-o da mesma maneira que
você fez antes (entre aspas) e lembre-se que se você omitir a
extensão, esta será ASM. No caso de você querer colocar uma
extensão diferente, coloque-a separada do nome por um ponto
(p.e.: "TESTE.RSC").
Finalmente, o programa perguntará se você quer converter
algum outro arquivo. Em caso afirmativo, poderás repetir a
operação tantas vezes como seja necessário. Do contrário,
CONVERT irá finalizar e devolver o controle ao BASIC ou ao
RSC II.
Quando houver erro de disco, CONVERT ira finalizar,
devolvendo o controle para onde foi chamado (BASIC OU RSC II).
*********************************************************************
INDICE
*********************************************************************
INTRODUÇÃO
CAPÍTULO 1
INSTALAÇÃO E CARREGAMENTO DO PROGRAMA
CAPÍTULO 2
COMANDOS DO EDITOR
Comando: &H
Comando: &B
Comando: A:
Comando: B:
Comando: BA
Comando: BL
Comando: BO
Comando: BR
Comando: BU
Comando: CB
Comando: CC
Comando: CT
Comando: DE
Comando: EN
Comando: FU
Comando: GB
Comando: GC
Comando: GT
Comando: IM
Comando: IN
Comando: LE
Comando: LK
Comando: LT
Comando: MV
Comando: NU
Comando: PO
Comando: PR
Comando: RE
Comando: RN
Comando: SI
Comando: TR
Comando: VD
Comando: VE
Comando: VM
CAPÍTULO 3
INTRODUÇÃO DE LINHAS DE TEXTO
CAPÍTULO 4
OUTROS COMANDOS E FUNÇÕES
4.1 - Pseudo-comandos
4.2 - Comandos do Assemblador
4.3 - Macros
4.4 - Sinais aritméticos
4.5 - Slots/subslots
CAPÍTULO 5
INFORMAÇÃO IMPORTANTE
5.1 - Endereços inferiores a &H8000
5.2 - Gravação e carregamento de programas
5.3 - Conselhos e notas finais
5.4 - Erros
5.5 - Comandos permitidos para Z-80
5.6 - Um programa exemplo
5.7 - Exemplo de macros linkadas
CAPÍTULOS 6
O PROGRAMA CONVERT
RSC software agradece a sua confiança e lhe felicita pela compra
de RSC II. Por favor, preencha o seguinte cupom, dando sua
opinião sobre o programa e envie para o endereço que é indicado
abaixo.
---------------------------------------------------
Nome:_____________________________________________
Endereço:_________________________________________
Cidade:__________________________ U.F.:__________
Estado:_______________________ Tel.:_____________
Computador:_______________ Modelo:_______________
Opinião que merece o programa RSC II
---------------------------------------------------
Envie este cupom para:
RSC SOFTWARE
Av. Princep d'Astúries, 62-64 3r,5a.
08012 - BARCELONA
Tel.: (93) 218.17.52.
Não hesite em contactar a RSC SOFT, por carta ou por telefone,
para qualquer informação que você precisar.
Obrigado.
================================================================
Manual original digitado por: RSC SOFTWARE
Lingua original: Espanhol
Tradução ao português: Marcelo Silveira (flamar98@hotmail.com)
Data: 21/02/2003
|