+-------------+
 ASSEMBLY XV 
+-------------+

    Continuando o  papo  sobre  o  TASM,  precisaremos aprender como
manipular tipos de dados mais complexos do que WORD, BYTE ou  DWORD.
Eis a descrio das estruturas!

    Uma  estrutura   o agrupamento de tipos de dados simples em uma
nica classe de armazenamento, por exemplo:

 +-----------------------------------------------------------------+
   STRUC   MyType                                                 
       A   DB  ?                                                  
       B   DW  ?                                                  
   ENDS                                                           
 +-----------------------------------------------------------------+

    A estrutura MyType acima,  delimitada pelas palavras-chava STRUC
e ENDS, foi construida com dois tipos de dados simples (BYTE e WORD)
com os nomes de A e B. Note que as linhas acima  apenas  declaram  a
estrutura,  sem  alocar  espao  na  memria  para  ela.   Criar uma
'instancia' dessa estrutura  to  simples quanto criar uma varivel
de tipo simples:

 +-----------------------------------------------------------------+
   MyVar   MyType  <0,0>                                          
 +-----------------------------------------------------------------+

    A sintaxe    basicamente  a  mesma  de  qualquer  declarao de
varivel em assembly, com a diferena de que o 'tipo' do  dado    o
nome  (ou  TAG)  da  estrutura  -  MyType  - e os dados iniciais dos
elementos da estrutura esto localizados entre os simbolos < e >. Na
linha acima criamos a  varivel  MyVar,  cujos  elementos so 0 e 0.
Vamos a um exemplo de uso desse novo tipo:

 +----------------------------------------------------------------+
   ;... Aqui entra o modelamento,...                             
                                                                 
   DATASEG                                                       
                                                                 
   MyVar   MyType  <0,0>                                         
                                                                 
   CODESEG                                                       
                                                                 
   PROC    SetA        ; Poe valor em A na estrutura.            
   ARG     V : Byte                                              
           mov     al,[V]                                        
           mov     [MyVar.A],al                                  
           ret                                                   
   ENDP                                                          
                                                                 
   PROC    SetB        ; Poe valor em B na estrutura.            
   ARG     V : Word                                              
           mov     ax,[V]                                        
           mov     [MyVar.B],ax                                  
           ret                                                   
   ENDP                                                          
                                                                 
   ;... Aqui entra o fim do cdigo...                            
 +----------------------------------------------------------------+

    Simples, no?

    Mas, e se quisermos trabalhar  com  um  vetor  do  tipo  MyType?
Vetores de tipos mais simples  facil:

 +----------------------------------------------------------------+
   DATASEG                                                       
                                                                 
   MyVar1  dw  10 DUP (0)                                        
                                                                 
   CODESEG                                                       
                                                                 
   PROC    Fill1                                                 
       mov     cx,10                                             
       sub     bx,bx                                             
   @@FillType1:                                                  
       mov     [bx+MyVar1],0FFh                                  
       add     bx,2                                              
       dec     cx                                                
       jnz     @@FillType1                                       
       ret                                                       
   ENDP                                                          
 +----------------------------------------------------------------+

    Aqui fiz da  maneira  mais  dificil  apenas para exemplificar um
mtodo de preenchimento  de  vetores.   No  caso,  BX  contm o item
desejado do vetor.  MyVar1  o  deslocamento  do  primeiro  item  do
vetor  na  memria  e  CX  a quantidade de itens do vetor.  Note que
temos um vetor de WORDS  e  precisaremos  adicionar 2 (tamnho de uma
WORD) para cara item do vetor.  No caso da estrutura, isso  fica  um
pouco mais complicado porque ela pode ter um tamanho no mltiplo de
2  (o que complica o clculo.  Por exemplo, MyType (a estrutura) tem
3 bytes de  tamanho.   Eis  a  implementao  (no otimizada) para a
rotina FillType para preenchimento de um  vetor  de  MyType  com  10
itens:

 +-----------------------------------------------------------------+
   DATASEG                                                        
   MyVar   MyType  10 dup (<0,0>)                                 
                                                                  
   CODESEG                                                        
   PROC    FillType                                               
           mov     cx,10                                          
           sub     bx,bx   ; indice para localizar itens.         
   @@FillLoop:                                                    
           mov     [bx+MyVar.A],0FFh   ; * Instruo destacada... 
           mov     [bx+MyVar.B],0FFFFh                            
           add     bx,3                                           
           dec     cx                                             
           jnz     @@FillLoop                                     
           ret                                                    
   ENDP                                                           
 +-----------------------------------------------------------------+

    Essa rotina merece ser observada mais de perto:

    Vejamos a  instruo  destacada  na  listagem  acima...  MyVar.A
fornece o deslocamento de A, do primeiro item do vetor, na  memria,
enquanto isso BX fornece o indice do item desejado no vetor.  Assim,
BX+MyVar.A  fornecer  o  offset  do elemento A do item da estrutura
desejado.

    Well...  isso...

