+--------------+
 ASSEMBLY XIV 
+--------------+

    Aqui  estou  eu   novamente!!!    Nos  textos  de  "SoundBlaster
Programming" a gente vai precisar  entender  um  pouquinho  sobre  o
TURBO ASSEMBLER, ento  disso que vou tratar aqui, ok?

    Well...     O   TURBO   ASSEMBLER   'compila'   arquivos   .ASM,
transformando-os em  .OBJ  (sorry  "C"zeiros,  mas os "PASCAL"zeiros
talvez no estejam familiarizados  com  isso!).   Os  arquivos  .OBJ
devem  ser linkados com os demais mdulos para formar o arquivo .EXE
final.   Precisamos  ento conhecer como criar um .OBJ que possa ser
linkado com cdigos em "C" e  "PASCAL".  Eis um exemplo de um mdulo
em ASSEMBLY compatvel com as duas linguagens:

 +----------------------------------------------------------------+
   IDEAL               ; Poe TASM no modo IDEAL                  
   MODEL LARGE,PASCAL  ; Modelo de memria...                    
   LOCALS                                                        
   JUMPS                                                         
                                                                 
   GLOBAL  ZeraAX : PROC   ; ZeraAX  pblico aos outros mdulos 
                                                                 
   CODESEG     ; Inicio do (segmento de) cdigo                  
                                                                 
   PROC    ZeraAX          ; Inicio de um PROCedimento.          
           sub     ax,ax                                         
           ret                                                   
   ENDP                    ; Fim do PROCedimento.                
                                                                 
   END     ; Fim do mdulo .ASM                                  
 +----------------------------------------------------------------+

    As duas linhas iniciais  informam  ao  TURBO ASSEMBLER o modo de
operao (IDEAL), o modelamento de memria (LARGE -  veja  discusso
abaixo!) e o  mtodo  de  passagem  de  parametros  para  uma funo
(PASCAL).

    O modo IDEAL   um  dos  estilos  de  programao  que  o  TURBO
ASSEMBLER suporta (o outro  o  modo  MASM), e  o meu preferido por
um certo nmero de razes.  O modelo LARGE e a parametrizao PASCAL
tambm so minhas preferidas  porque  no  modelo  LARGE    possvel
termos  mais  de  um  segmento  de  dados e de cdigo (podemos criar
programas  realmente  GRANDES   e   com   MUITA   informao  a  ser
manipulada!).   PASCAL  deixa  o  cdigo  mais  limpo com relao ao
contedo dos registradores  aps  o  retorno  de  uma funo (alguns
compiladores C, em algumas circunstancias, tm a mania de  modificar
o  contedo  de  CX  no  retorno!).  Fora isso PASCAL tambm limpa a
pilha ANTES do retorno da  procedure/funo.  Mas, isso tudo tem uma
pequena desvantagem: Usando-se PASCAL, no podemos passar um  nmero
varivel  de  parametros pela pilha (os trs pontos da declarao de
uma funo C: void f(char *, ...); )!

    Ahhh...   Voc  deve  estar  se  perguntando  o que  o LOCALS e
JUMPS.  LOCALS diz ao compilador  que qualquer label comeado por @@
 local ao PROC  atual  (no    visivel em outros PROCs!)...  Assim
podemos usar labels com mesmo  nome  dentro  de  vrias  PROCs,  sem
causar nenhuma confuso:

 +----------------------------------------------------------------+
   ; modelamento, modo, etc...                                   
   LOCALS                                                        
                                                                 
   PROC    F1                                                    
           mov cx,1000                                           
   @@Loop1:                                                      
           dec cx                                                
           jnz @@Loop1                                           
           ret                                                   
   ENDP                                                          
                                                                 
   PROC    F2                                                    
           mov cx,3000                                           
   @@Loop1:                                                      
           dec cx                                                
           jnz @@Loop1                                           
           ret                                                   
   ENDP                                                          
   ;... O resto...                                               
 +----------------------------------------------------------------+

    Repare  que  F1 e F2 usam o mesmo label (@@Loop1), mas o fato da
diretiva LOCALS estar  presente  informa  ao  assembler que elas so
diferentes!

    J   JUMPS   resolve   alguns  problemas  para  ns:  Os  saltos
condicionais  (JZ, JNZ, JC, JS, etc..) so relativos a posio atual
(tipo: salte para frente tantas posies a partir de onde  est!)...
Em  alguns  casos  isso  pode causar alguns erros de compilao pelo
fato do salto no poder  ser  efetuado  na faixa que queremos...  ai
entra  o  JUMPS...   Ele resolve isso alterando o cdigo para que um
salto incondicional seja efetuado.   Em  exmplo: Suponha que o label
@@Loop2 esteja muito longe do ponto atual e o salto abaixo no possa
ser efetuado:

 +----------------------------------------------------------------+
       JNZ     @@Loop2                                           
 +----------------------------------------------------------------+

    O assembler substitui, caso JUMPS esteja presente, por:

 +----------------------------------------------------------------+
       JZ      @@P1                                              
       JMP     @@Loop2     ; Salto absoluto se NZ!               
   @@P1:                                                         
 +----------------------------------------------------------------+

    A linha seguinte do exemplo inicial informa ao assembler  que  o
PROCedimento  ZeraAX    pblico, ou GLOBAL (visvel por qualquer um
dos mdulos que o queira!).  Logo aps, a diretiva CODESEG informa o
inicio de um segmento de cdigo.

    Entre  as  diretivas  PROC  e  ENDP vem o corpo de uma rotina em
assembly.  PROC precisa apenas do  nome da funo (ou PROCedimento).
Mais detalhes sobre PROC abaixo.

    Finalizamos a listagem com END, marcando  o  fim  do  mdulo  em
.ASM.

    Simples, n?!  Suponha agora que voc queira passar um parametro
para um PROC. Por exemplo:

 +----------------------------------------------------------------+
   ; Equivalente a:                                              
   ;   void pascal SetAX(unsigned v) { _AX = v; }                
   ;   PROCEDURE SetAX(V:WORD) BEGIN regAX := V; END;            
   IDEAL                                                         
   MODEL LARGE,PASCAL                                            
   LOCALS                                                        
   JUMPS                                                         
                                                                 
   GLOBAL SetAX : PROC                                           
                                                                 
   PROC    SetAX                                                 
   ARG     V : WORD                                              
           mov     ax,[V]                                        
           ret                                                   
   ENDP                                                          
                                                                 
   END                                                           
 +----------------------------------------------------------------+

    Hummmm...   Surgiu uma diretiva nova.  ARG especifica a lista de
parametros que dever  estar  na  pilha  aps  a  chamada  de  SetAX
(ARGumentos de SetAX).  Note que V est entre colchetes na instruo
'mov'...   isso porque V , na verdade, uma referncia  memria (na
pilha!)  e  toda  referncia    memria  precisa  ser  cercada  com
colchetes (seno  d  um  baita  erro  de  sintaxe  no modo IDEAL!).
Depois da compilao o assembler substitui V pela referncia certa.

    Os  tipos,  bsicos,  vlidos  para o assembler so: BYTE, WORD,
DWORD...  No existe INTEGER,  CHAR  como  em PASCAL (INTEGER = WORD
com sinal; assim como CHAR = BYTE com sinal!).

    Para  finalizar:  Em um nico mdulo podem existir vrios PROCs:

 +----------------------------------------------------------------+
   IDEAL               ; modo IDEAL do TASM                      
   MODEL LARGE, PASCAL ; modelamento de memria...               
   LOCALS                                                        
   JUMPS                                                         
                                                                 
   ; ... aqui entra os GLOBALS para os PROCs que vc queira que   
   ;     sejam pblicos!                                         
                                                                 
   CODESEG     ; Comeo do segmento de cdigo...                 
                                                                 
   PROC    P1                                                    
       ; ... Corpo do PROC P1                                    
   ENDP                                                          
                                                                 
   PROC    P2                                                    
       ; ... Corpo do PROC P2                                    
   ENDP                                                          
                                                                 
   ;... outros PROCs...                                          
                                                                 
   END     ; Fim da listagem                                     
 +----------------------------------------------------------------+

    Existem MUITOS outros detalhes  com  relao do TASM...  mas meu
objetivo no curso de ASM   a  mixagem  de  cdigo...   pls,  alguma
dvida, mandem mensagem para c ou via netmail p/ mim em 12:2270/1.

