Linux slogan
Visite também: BR-Linux.org · Dicas-L · Doode · NoticiasLinux · SoftwareLivre.org · UnderLinux



» Screenshot
Linux: Openbox com novo visual + GIMP.
Por chronos
» Login
Login:
Senha:

Se você ainda não possui uma conta, clique aqui.

Esqueci minha senha



Scripts

Linux user

Publicado por Listeiro 037 em (última atualização em 25/02/2013)   [ 2639 hits ]

Login: Listeiro 037, 195748 pontos

Download:

Versão 2:

Versão 3:


Descrição

Este programa utiliza-se da pilha por causa da reordenação dos dígitos após a divisões.

Do modo como foi escrito, trabalha com variáveis locais. Não são tão adequadas ou elegantes como algum tipo de variável local ou pilha, mas facilita a compreensão para se ter uma visão intuitiva do programa.

Conforme os restos são obtidos, são empilhados e ao término são desempilhados conforme vai sendo feita a impressão de cada dígito.

O último item a ser desempilhado é o endereço de um "new line", ponteiro para '\n' definido antecipadamente no código.

A interrupção de escrita trabalha com endereços de memória do que se deseja que seja enviado para uma saída, no caso a tela.

Este caractere identifica o final da escrita dos dígitos.



[ Download: binario001.s ]   [ Enviar nova versão ]

Versões atualizadas deste script (NOVO)
Linux user

Publicado por Listeiro 037 em 01/07/2012

Changelog: Esta segunda implementação usa deslocamento para a direita (shr) e operação "E" (and) para encontrar os valores da conversão ao invés de dividir o número por 2.

Revisando o primeiro código:

Os valores encontrados eram armazenados numa pilha. O primeiro valor a ser armazenado na pilha é o de impressão de nova linha.

Quando os valores forem desempilhados, este marcará o fim da pilha e então cessará a impressão.

A pilha é necessária devido ao modo de como os valores são obtidos na divisão.

Sendo o primeiro resto considerado o último dígito a ser impresso, este deverá entrar primeiro na pilha, de modo que será o último depois que todos os que entraram depois deles forem desempilhados.

No primeiro código, o número era dividido por dois e ao resto da divisão era acrescido o endereço de uma string que continha os possíveis caracteres de impressão: 0 e 1.

Este valor é armazenado na pilha e será retirado no momento de impressão de caracteres, que será o desempilhamento.

De modo que será passada à interrupção de kernel o valor desempilhado, o endereço para a impressão de um caracter na posição da string deslocado tantas posições de memória quanto fosse o resultado do resto da divisão.

O quociente era então dividido novamente e segue-se repetidamente até que todas as divisões sejam feitas.

A partir deste ponto, os valores serão desempilhados e passados à chamada de kernel, que imprimirá o caracter um a um.

Diferença entre a primeira e a segunda implementação:

* Na primeira o que se efetua são divisões por 2, trabalhando-se com os restos como sinais a serem impressos e os quocientes divididos novamente.

* Na segunda implementação usa-se uma operação "E" (and) para saber apenas o valor do último bit do número. Após isto o bit é descartado com a operação de deslocamento à direita. O valor encontrado na operação "E" é acrescido do endereço da string e empilhado, sendo desempilhado quando for feita a impressão de dígitos.

Quociente de divisão por 2 = Deslocamento de uma casa à direita.
Resto de divisão por 2 = O bit que some no deslocamento de uma casa à direita.

(versão 2)

 

Linux user

Publicado por Listeiro 037 em 31/07/2012

Changelog: Este terceiro método de escrita não usa mais a string com os caracteres a serem usados na impressão.

É feita normalmente a sequência de divisões por 2 e acumulados os restos para impressão de caracteres.

Ao invés disso os caracteres são colocados diretamente na pilha.

Daí o endereço da pilha com o caracter é enviado ao registrador para ser usado na impressão de um único caracter.

Sendo repetido isto em loop, até ser encontrado por comparação o valor que identifica o final da série de caracteres, que é o ' \ 0 ', o mesmo da linguagem C.

(versão 3)

 

[ Esconder código-fonte ]

############################################################################################
#      Comentários:
############################################################################################
#
#    as binario001.s -o binario001.o
#    ld -s binario001.o -o binario001
#    a opção -s no linkeditor faz
#     "strip -s" automaticamente
#
############################################################################################

.section      .rodata

   digit:   .ascii   "01"
   nl:   .ascii   "\n"
   valor:   .long   4952488

.section   .text         
.globl       _start         

_start:   

   pushl   $nl
   movl   valor,   %eax

_empilha:

   xorl    %edx,   %edx
   movl   $2,   %ecx
   divl   %ecx
   addl   $digit,   %edx
   pushl   %edx
   cmpl    $0,    %eax
   jg    _empilha

_escreve:

   movl    $4,    %eax         
   movl    $1,    %ebx         
   popl    %ecx
   movl    $1,    %edx
   int    $0x80

   cmpl   $nl,   %ecx
   jne   _escreve

_fim:

   movl    %eax,    %ebx
   movl    $1,    %eax
   int    $0x80



Scripts recomendados
   Script Linux recomendado ToUpperCase em Assembler 8086
   Script Linux recomendado Escrita de um número em hexadecimal na tela em Assembly Puro para Linux x86 (GNU Assembly)
   Script Linux recomendado Escrita de número em binário em Assembly Puro para Linux 64 bits (Nasm - Netwide Assembler)
   Script Linux recomendado GAS Bubblesort
   Script Linux recomendado Hora do sistema

Comentários
Nenhum comentário foi encontrado.

Contribuir com comentário


  
Para executar esta ação você precisa estar logado no site, caso contrário, tudo o que for digitado será perdido.
Responsável pelo site: Fábio Berbert de Paula - Conteúdo distribuído sob licença GNU FDL
Site hospedado por:

Viva o Linux

A maior comunidade Linux da América Latina! Artigos, dicas, tutoriais, fórum, scripts e muito mais. Ideal para quem busca auto-ajuda em Linux.