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 |