Search the Community

Eu estou a desenvolver um programa que verifica se o número introduzido pelo utilizador é igual ou diferente ao número guardado em memória. Independentemente do número introduzido pelo utilizador a solução é sempre a mesma, diz que está mal mesmo introduzindo o número correto. Programa: .data pergunta: .asciiz "Introduza um numero\n" n_utilizador: .space 5 numero_secreto: .asciiz "1234" falhou: .asciiz "Falhou, o numero era 1234" acertou: .ascii "\nAcertou em " tentativas: .asciiz "tentativas" .text main: #Faz o display da pergunta li $v0, 4 la $a0, pergunta syscall #Guarda o numero introduzido li $v0, 8 la $a0, n_utilizador addi $a1, $a1, 5 syscall la $a0, n_utilizador la $a1, numero_secreto jal Passagem_enderecos beqz $v0, Iguais bnez $v0, Falhanco Iguais: #Faz o display da mensaguem acertou li $v0, 4 la $a0, acertou syscall #Termina o programa li $v0, 10 syscall Falhanco: #Faz o display da mensagem falhou li $v0, 4 la $a0, falhou syscall #Termina o programa li $v0, 10 syscall Passagem_enderecos: move $t0, $a0 move $t1, $a1 Verifica_b_por_b: lb $t2($t0) lb $t3($t1) beqz $t2, Verifica_numero_secreto beqz $t3, Diferente slt $t4, $t2, $t3 bnez $t4, Diferente addi $t0, $t0, 1 addi $t1, $t1, 1 j Verifica_b_por_b Diferente: addi $v0, $zero, 1 j Fim_do_procedimento Verifica_numero_secreto: bnez $t4, Diferente addi $v0, $zero, 0 Fim_do_procedimento: jr $ra Podem-me dizer o que está errado?

Bom dia, a todos. Tendo me deparado com uma grande lacuna no que toca ao Assembly para P3, venho abrir este tópico para que quem enfrenta aprendizagem desta linguagem. Dada a falta de exemplos solicito a todos os que possam contribuir a publicação dos programas e se possível comentados. Seria interessante ver programas para somar, subtrair, multiplicar, dividir, comparar, etc. Obrigado a todos

Boas a todos! Estou perante um exercicí, em que tenho de prucurar um numero, dentro de uma cadeira de dados em Assembly P3 (input/linha2/linha3). Existem algumas condicionantes. Nomeadamente retornar em R1 o endereço onde foi encontrado o numero em causa. Como estou a iniciar-me em Assembly e o material didático para esta linguagem é bastante, coloco-Vos este pedido de ajuda. Eis o que tenho feito, mas que por motivos que desconheço, o simulador não retorna qualquer dado... ; Conjunto de dados ORIG 8000h Input STR 60385, 8536, 7627, 24376, 49543, 13210, 9866, 53798 linha2 STR 60526, 42549, 27769, 25234, 60984, 49533, 45468, 26128 linha3 STR 56370, 34983, 13129, 62576, 62248, 63856, 57035, 20429 Tamanho EQU 24 ;Localizar Localizar WORD 62576 ;Código MOV R2, 1 MOV R4, 62576 Find: CMP R4, M[R2] BR.Z Step2 INC R2 MOV R3, 0 BR Find Step2: MOV R3, 1 MOV R1, M[R2] FIM: JMP FIM ; fim programa Abrigado pela ajuda que me puderem dar, a perceber porque não retorna quaisquer dados... NEm do R1, nem R2 e nem o R3 Obrigado!

Caros programadores Recentemente recebi uma proposta de trabalho sobre uma matéria nunca dada na escola. O enunciado é o seguinte: "Pretende-se o desenvolvimento de um programa em assembly que implemente uma stack de números inteiros e suporte as operações de Push (inserir) e Pop (retirar) de números bem como da listagem dos números da pilha. A stack poderá acomodar, no máximo, 20 números. Um menu com as seguintes opções deve ser implementado para suportar a respetiva manipulação: 1- Push 2- Pop 3- Listar 4- Sair A opção de Push deve resultar na solicitação do número inteiro a inserir na stack bem como na respetiva inserção. Caso a stack esteja cheia deve ser impressa uma mensagem indicativa desta ocorrência. A opção de Pop deve resultar na retirada do elemento da stack e na respetiva impressão no ecrâ. Caso a stack esteja vazia deve ser impressa uma mensagem indicativa desta ocorrência. A opção de listar deve mostrar todos os números que estão na stack, um por linha, a começar no topo. A opção Sair, como o nome indica, deve resultar na conclusão do programa." Conseguem ajudar-me?

Ando com um certo interesse no Z80 e queria saber se existe algum compilador de ASM de Z80 para uma linguagem de alto nível (C, BASIC; Pascal, qualquer coisa serve.). Encontrei apenas uma solução cujo preço nem sequer é divulgado (o que me leva logo a pensar que não tenho carteira para tal :D) e tendo em conta que tudo isto é por "carolice" minha, não queria fazer grande investimento financeiro na coisa.

Olá, tenho de resolver dois exercícios de assembly, mas não percebo nada. Ainda só tive uma aula e foi teórica. Se alguém me pudesse ajudar: escreva um programa em ASM P3 (ou altere o programa anterior) que tenha numa variável em memória o lado de um quadrado e calcule o respetivo perímetro e área, colocando o resultado em R1 e R2, respetivamente. escreva um programa em ASM P3 que calcule: x = 20 – m + (n + 40). Onde x, m e n são registos do processador P3 (por exemplo, R1, R2, e R3).

Bom dia, estou a fazer um projeto para a cadeira de arquitetura de computadores, que consiste em guardar uma letra especifica que apareça na string e caso ela não apareça devolver null. Não tenho ideia de como faço para que o programa saiba que é aquela letra que tem que guardar. Alguém me pode ajudar sff. Obrigada

Atualmente qual é o valor do maior salário de programador Assembly em Portugal e no mundo? Qual é o local que paga o valor do maior salário de programador Assembly em Portugal e no mundo? Qual é a porcentagem atual da demanda de Assembly no mundo?

Qual é a quantidade provável de programadores que atualmente programam em linguagem de máquina? Qual é a provável porcentagem dos programadores que programam atualmente em linguagem de máquina? Qual é a quantidade provável de programadores que atualmente programam em linguagem de Assembly? Qual é a provável porcentagem dos programadores que programam atualmente em Assembly?

gostaria se alguem pode me dar uma ajuda de como criar o jogo da velha em assembly no mips .data cabecalho: .asciiz "Jogo da Velha " espaco: .asciiz " " bl: .asciiz "n" um: .asciiz "1" dois: .asciiz "2" tres: .asciiz "3" barra: .asciiz "|" jog1: .asciiz "JOGADOR 1:n" jog2: .asciiz "JOGADOR 2:n" posicao: .asciiz "Digite linha e coluna (xy): " erro: .asciiz "Posicao Invalida.n" victory1: .asciiz "Parabens JOGADOR 1, voce ganhou." victory2: .asciiz "Parabens JOGADOR 2, voce ganhou." empat: .asciiz "Empatou, chora." .text .globl main main: addi $t0 $zero 45 #Inicializa os registradores em ‘-’ addi $t1 $zero 45 addi $t2 $zero 45 addi $t3 $zero 45 addi $t4 $zero 45 addi $t5 $zero 45 addi $t6 $zero 45 addi $t7 $zero 45 addi $t8 $zero 45 la $a0 cabecalho #Imprime o cabeçalho li $v0 4 syscall #comeca a diversao j print1 j fim print1: #Imprime a grade do jogo. la $a0 bl #linha branco li $v0 4 syscall la $a0 espaco syscall la $a0 espaco syscall la $a0 espaco syscall la $a0 um syscall la $a0 espaco syscall la $a0 dois syscall la $a0 espaco syscall la $a0 tres syscall la $a0 bl #linha branco syscall la $a0 espaco #comeco primeira linha syscall la $a0 um syscall la $a0 barra syscall move $a0 $t0 li $v0 11 syscall la $a0 barra li $v0 4 syscall move $a0 $t1 li $v0 11 syscall la $a0 barra li $v0 4 syscall move $a0 $t2 li $v0 11 syscall la $a0 barra li $v0 4 syscall la $a0 bl #fim primeira linha li $v0 4 syscall la $a0 espaco #comeco segunda linha syscall la $a0 dois syscall la $a0 barra syscall move $a0 $t3 li $v0 11 syscall la $a0 barra li $v0 4 syscall move $a0 $t4 li $v0 11 syscall la $a0 barra li $v0 4 syscall move $a0 $t5 li $v0 11 syscall la $a0 barra li $v0 4 syscall la $a0 bl #fim segunda linha li $v0 4 syscall la $a0 espaco #comeco terceira linha syscall la $a0 tres syscall la $a0 barra syscall move $a0 $t6 li $v0 11 syscall la $a0 barra li $v0 4 syscall move $a0 $t7 li $v0 11 syscall la $a0 barra li $v0 4 syscall move $a0 $t8 li $v0 11 syscall la $a0 barra li $v0 4 syscall la $a0 bl #fim terceira linha li $v0 4 syscall j testejog2 #Chama teste para jogador 2 print2: la $a0 bl #linha branco li $v0 4 syscall la $a0 espaco syscall la $a0 espaco syscall la $a0 espaco syscall la $a0 um syscall la $a0 espaco syscall la $a0 dois syscall la $a0 espaco syscall la $a0 tres syscall la $a0 bl #linha branco syscall la $a0 espaco #comeco primeira linha syscall la $a0 um syscall la $a0 barra syscall move $a0 $t0 li $v0 11 syscall la $a0 barra li $v0 4 syscall move $a0 $t1 li $v0 11 syscall la $a0 barra li $v0 4 syscall move $a0 $t2 li $v0 11 syscall la $a0 barra li $v0 4 syscall la $a0 bl #fim primeira linha li $v0 4 syscall la $a0 espaco #comeco segunda linha syscall la $a0 dois syscall la $a0 barra syscall move $a0 $t3 li $v0 11 syscall la $a0 barra li $v0 4 syscall move $a0 $t4 li $v0 11 syscall la $a0 barra li $v0 4 syscall move $a0 $t5 li $v0 11 syscall la $a0 barra li $v0 4 syscall la $a0 bl #fim segunda linha li $v0 4 syscall la $a0 espaco #comeco terceira linha syscall la $a0 tres syscall la $a0 barra syscall move $a0 $t6 li $v0 11 syscall la $a0 barra li $v0 4 syscall move $a0 $t7 li $v0 11 syscall la $a0 barra li $v0 4 syscall move $a0 $t8 li $v0 11 syscall la $a0 barra li $v0 4 syscall la $a0 bl #fim terceira linha li $v0 4 syscall j testejog1 #Chama teste para jogador 1 jogador1: la $a0 jog1 #Imprime chamada para jogador 1 li $v0 4 syscall la $a0 posicao #Le a posição syscall li $v0 5 syscall move $16 $v0 beq $16 11 umum beq $16 12 umdois #switch para por X na posicao digitada beq $16 13 umtres beq $16 21 doisum beq $16 22 doisdois beq $16 23 doistres beq $16 31 tresum beq $16 32 tresdois beq $16 33 trestres la $a0 erro #Teste para posição invalida li $v0 4 syscall j jogador1 umum: bgt $t0 45 jogador1 #se ja estiver valor nesta posicao chama de novo addi $t0 $zero 88 #senao poe valor na posicao j print2 #…os demais casos são testados da mesma maneira… umdois: bgt $t1 45 jogador1 addi $t1 $zero 88 j print2 umtres: bgt $t2 45 jogador1 addi $t2 $zero 88 j print2 doisum: bgt $t3 45 jogador1 addi $t3 $zero 88 j print2 doisdois: bgt $t4 45 jogador1 addi $t4 $zero 88 j print2 doistres: bgt $t5 45 jogador1 addi $t5 $zero 88 j print2 tresum: bgt $t6 45 jogador1 addi $t6 $zero 88 j print2 tresdois: bgt $t7 45 jogador1 addi $t7 $zero 88 j print2 trestres: bgt $t8 45 jogador1 addi $t8 $zero 88 j print2 jogador2: la $a0 jog2 #Chamada para jogador 2 li $v0 4 syscall la $a0 posicao #Lê a posição syscall li $v0 5 syscall move $16 $v0 beq $16 11 umum2 beq $16 12 umdois2 beq $16 13 umtres2 beq $16 21 doisum2 #switch para por O na posicao digitada beq $16 22 doisdois2 beq $16 23 doistres2 beq $16 31 tresum2 beq $16 32 tresdois2 beq $16 33 trestres2 la $a0 erro #Teste de posição inválida li $v0 4 syscall j jogador2 umum2: bgt $t0 45 jogador2 #se ja estiver valor nesta posicao chama de novo addi $t0 $zero 79 #senao poe valor na posicao j print1 #…os demais casos de teste são iguais… umdois2: bgt $t1 45 jogador2 addi $t1 $zero 79 j print1 umtres2: bgt $t2 45 jogador2 addi $t2 $zero 79 j print1 doisum2: bgt $t3 45 jogador2 addi $t3 $zero 79 j print1 doisdois2: bgt $t4 45 jogador2 addi $t4 $zero 79 j print1 doistres2: bgt $t5 45 jogador2 addi $t5 $zero 79 j print1 tresum2: bgt $t6 45 jogador2 addi $t6 $zero 79 j print1 tresdois2: bgt $t7 45 jogador2 addi $t7 $zero 79 j print1 trestres2: bgt $t8 45 jogador2 addi $t8 $zero 79 j print1 fim: jr $ra testejog2: #Testa se jogador 2 ganhou add $a0 $t0 $t1 #Testa se o jogo termina empatado add $a0 $a0 $t2 add $a0 $a0 $t3 add $a0 $a0 $t4 add $a0 $a0 $t5 add $a0 $a0 $t6 add $a0 $a0 $t7 add $a0 $a0 $t8 beq $a0 756 empate add $a0 $t0 $t1 add $a0 $a0 $t2 #linha 1 beq $a0 237 jog2ganhou add $a0 $t3 $t4 add $a0 $a0 $t5 #linha 2 beq $a0 237 jog2ganhou add $a0 $t6 $t7 add $a0 $a0 $t8 #linha 3 beq $a0 237 jog2ganhou add $a0 $t0 $t3 add $a0 $a0 $t6 #coluna 1 beq $a0 237 jog2ganhou add $a0 $t1 $t4 add $a0 $a0 $t7 #coluna 2 beq $a0 237 jog2ganhou add $a0 $t2 $t5 add $a0 $a0 $t8 #coluna 3 beq $a0 237 jog2ganhou add $a0 $t0 $t4 add $a0 $a0 $t8 #diagonal 1 beq $a0 237 jog2ganhou add $a0 $t2 $t4 add $a0 $a0 $t6 #diagonal 2 beq $a0 237 jog2ganhou j jogador1 #Chama jogador 1 jog2ganhou: #Imprime que jogador dois ganhou e sai la $a0 victory2 li $v0 4 syscall j fim testejog1: #Testa se jogador 1 ganhou add $a0 $t0 $t1 #Testa se o jogo terminou empatado add $a0 $a0 $t2 add $a0 $a0 $t3 add $a0 $a0 $t4 add $a0 $a0 $t5 add $a0 $a0 $t6 add $a0 $a0 $t7 add $a0 $a0 $t8 beq $a0 756 empate add $a0 $t0 $t1 add $a0 $a0 $t2 #linha 1 beq $a0 264 jog1ganhou add $a0 $t3 $t4 add $a0 $a0 $t5 #linha 2 beq $a0 264 jog1ganhou add $a0 $t6 $t7 add $a0 $a0 $t8 #linha 3 beq $a0 264 jog1ganhou add $a0 $t0 $t3 add $a0 $a0 $t6 #coluna 1 beq $a0 264 jog1ganhou add $a0 $t1 $t4 add $a0 $a0 $t7 #coluna 2 beq $a0 264 jog1ganhou add $a0 $t2 $t5 add $a0 $a0 $t8 #coluna 3 beq $a0 264 jog1ganhou add $a0 $t0 $t4 add $a0 $a0 $t8 #diagonal 1 beq $a0 264 jog1ganhou add $a0 $t2 $t4 add $a0 $a0 $t6 #diagonal 2 beq $a0 264 jog1ganhou j jogador2 #Chama jogador 2 jog1ganhou: #Imprime que jogador 1 ganhou e sai la $a0 victory1 li $v0 4 syscall j fim empate: #Imprime EMPATE e sai la $a0 empat li $v0 4 syscall j fim

Boa noite a todos. Nao sei se esse é o sitio certo. Sera que algum colega tem o disquete que acompanha o livro -- assembly puro e simples de vasco correia veloso. Qual o conteudo desse disco ?? Eu tenho o livro, mais o software em disquete foi pro saco. Gostava de praticar assembly e seguir as instruções do livro e disco. Se algum colega puder me dar essa ajuda. Agradecia. Julio praiaclube@msn.com

resolvido

Boas tardes, estou a ter algumas dúvidas para converter meu código C para Assembly. Aqui esta o meu código C #include<stdio.h> int pares(int numeros[], int x) { int y=0; int i; for(i = 0; i < x; i++) if(numeros[i]%2 == 0) y++; return y; } int main(){ int numeros[30]; int i, z, w; for(i = 0; i < 30; i++) numeros[i] = i + 1; printf("Insira X: "); scanf("%d", &z); w = pares(numeros, z); printf("pares: %d\n", w); } Ja tentei varias horas a tentar converter o programa e por enquanto tenho isto: Input Store array load tr subt array skipcond 800 halt LoopXpositive, Load array Subt Y Skipcond 800 / ac>0 Jump Finish Store array ElseIf, Load Z Add One Store Z Jump LoopXpositive Finish, load Z output Halt dec 1 / a[1] dec 4 / a[2] dec 7 / a[3] dec 10 / a[4] dec 13 / a[5] dec 16 / a[6] dec 19 / a[7] dec 22 / a[8] dec 25 / a[9] dec 28 / a[10] dec 31 / a[11] dec 34 / a[12] dec 37 / a[13] dec 40 / a[14] dec 43 / a[15] dec 46 / a[16] dec 49 / a[17] dec 52 / a[18] dec 55 / a[19] dec 58 / a[20] dec 61 / a[21] dec 64 / a[22] dec 67 / a[23] dec 70 / a[24] dec 73 / a[25] dec 76 / a[26] dec 79 / a[27] dec 82 / a[28] dec 85 / a[29] dec 88 / a[30] tr, dec 31 array, dec 0 X, Dec 0 Y, Dec 2 Z, Dec 0 One, Dec 1 Zero, Dec 0 i, dec 1 Preciso de ajuda. Obrigado =)

Bom dia, foi-me proposto um trabalho em assembly, o qual tem que percorrer um texto e no fim apresentar o número total de caracteres que compõem esse texto; número de letras minúsculas (sem acentos, ASCII puro); e por fim, número total de caracteres ASCII não representáveis. Agradeço desde já quem puder ajudar.

Boa tarde, quero guardar carateres do ecrã num ficheiro. O tamanho é 20 linhas e 40 colunas. Desenvolvi código, mas ele só está a guardar 14 linhas. Alguém me consegue ajudar? Mov bx,0 mov si,0 mov ax,0 mov di,si mov cx, 80 lab_ciclo: mov al, es:[bx] mov buffer[si], al inc si add bx,2 loop lab_ciclo add di,82 mov si,di mov cx,82 cmp si, 2050 jne lab_ciclo

Olá pessoal eu estou a tentar fazer um jogo do labirinto em codigo assembly no dosbox (é um trabalho da minha faculdade) e o professor disponibilizou-nos codigos para nos ajudar mas estou a ver-me á rasca para por exemplo guardar o labirinto que fiz, fazer a interface (NOVO JOGO, FAZER UM LABIRINTO, SAIR), por o avatar no labirinto... alguem me pode ajudar qualquer ajuda é otima

Boa Tarde...... Como faço um programa em Mips que faz o seguinte........ Adicionar as seguintes letras no Alfabeto após cada uma das vogais (exemplo: após cada a, adicionar um b)

Boas pessoal. Sou completamente novo nesta linguagem, ando a aprender na fac, mas não me ando a dar muito bem com ela. Preciso de criar um programa de codificação de mensagens, onde o utilizar mete a mensagem, e sempre que aparecer uma vogal, adiciona a consoante próxima à vogal. Por exemplo: A > B E > F I > J O > P U > V Então, se a minha mensagem fosse: "Hello World", depois da encriptação seria: "Hefllop Woprld". Já tenho o código do input da mensagem aqui: .data #let processor know we will be submitting data to program now insert: .word 4 #make a 4 byte (32 bit) space in memory for a word with address insert_into input: .asciiz "\Please Enter a String to Print\n" #in unused memory store this string with address Ask_Input output: .asciiz "\You typed in: " #in unused memory store this string with address Tell_Output .text #enables text input / output, kind of like String.h in C++ main: #main function is always called in any mips program, so the program will start here with actual assembly code la $a0, input #load address input from memory and store it into arguement register 0 li $v0, 4 #loads the value 4 into register $v0 which is the op code for print string syscall #reads register $v0 for op code, sees 4 and prints the string located in $a0 la $a0, insert #sets $a0 to point to the space allocated for writing a word la $a1, insert #gets the length of the space in $a1 so we can't go over the memory limit li $v0, 8 #load op code for getting a string from the user into register $v0 syscall #reads register $v0 for op code, sees 8 and asks user to input a string, places string in reference to $a0 la $a0, output #load address output from memory and store it into arguement register 0 li $v0, 4 #loads the value 4 into register $v0 which is the op code for print string syscall #reads register $v0 for op code, sees 4 and prints the string located in $a0 la $a0, insert #load address insert_into from memory and store it into arguement register 0 li $v0, 4 #loads the value 4 into register $v0 which is the op code for print string syscall #reads register $v0 for op code, sees 4 and prints the string located in $a0 li $v0, 10 #loads op code into $v0 to exit program syscall #reads $v0 and exits program Porém, já não sei como/o que fazer a partir daqui.

Boa tarde, Eu estou com dificuldades em criar um trabalho em assembly na arquitetura mips que codifique um texto. O programa tem de ''andar'' 5 vezes para a frente em cada letra do texto escrito. Exemplo: Ontem fui a Lisboa ter com a minha mae e aproveitei para comprar um gelado ->Tsyjr kzn f Qnxgtf yjw htr f rnsmf rfj j fuwtajnyjn ufwf htruwfw zr ljqfit Será que alguém consegue dar uma ajuda? Peço desculpa pelo incomodo e obrigado desde ja pela disponibilidade. Cumprimentos

Boas malta, Alguém me pode dizer como faço um delay em assembly no PIC16F627? A idea é no pressionar um botão executar o código, e ao fim de x segundos voltar tudo ao inicio thanks!! Cumpz!

Ola, Estou a realizar um projecto em que recebe dois numeros passado pelo cliente e realiza diversas operações no entanto no factorial e na Potencia os resultados não estão correctos. Na Potencia o primeiro numero é a base e o segundo expoente no factorial apenas é feito o factorial do primeiro numero. Podem ajudar-me ? Obrigado desde já pela possibilidade. ;Factorial FAT: cmp al,'F' jne potencia lodsb cmp al,'A' jne ERROR ;Factorial do 1 numero mov bx, [num1] call proc_fact add ax, 30h mov [result], ax jmp fim_operacao proc_fact: cmp bl, 1 jg do_calculation mov ax, 1 ret do_calculation: dec bl call proc_fact inc bl mul bl ;ax = al * bl jo fim_operacao ret ;Potencia potencia: cmp al,'P' jne funcao_S lodsb cmp al, 'O' jne ERROR call proc_fact mov eax, [num1] mov ebx, [num2] add edx, eax call potenc potenc: mul jo fim_operacao sub ebx,1 cmp ebx,0 jnz potenc mov [result], al jmp fim_operacao

Bem, tenho um projecto pra terminar e no entanto enquanto o fazia deparei-me com certas situações limitantes no qual impediram a perfeição total do trabalho. O objectivo é criar uma calculadora que faça operações aritméticas (+, -, *, /), lógicas (XOR, AND, OR) e também SL, SR, RL e RR. Consegui fazer a calculadora com as operações aritmeticas e mais o SL e SR. Falta XOR, AND, OR; RL, RL. Para facilitar a vossa compreensão, vou enumerar as dúvidas: 1- Adicionar as operações XOR, AND, OR; RL, RL. 2- Fazer com que o programa detecte e indique no ecrã as situações de overflow. 3- O programa produz resultado em Hexa, como faço para po-lo em inteiro? Se alguém pudesse ajudar agradecia imenso. Caso prefiram, aqui têm o programa feito até agora: section .data MAX_PALAVRA equ 40 s1 db 0xa,"Introduza num: " ts1 equ $ - s1 s3 db 0xa,"Resultado: " ts3 equ $ - s3 s4 db 0xa,"Introduza o operador (+,-,*,/,&,SL,SR): " ts4 equ $ - s4 s5 db 0xa,"Operador inválido",0xA ts5 equ $ - s5 linha db 0xa,0xa tlinha equ $ - linha num1 dd 0 num2 dd 0 result dd 0 tamstr dd 0 section .bss strnum resb MAX_PALAVRA section .text global _start _start: ; Pede num1 call pedeNumero mov [num1], ebx ; Pede num2 call pedeNumero mov [num2], ebx ; Pede operador mov edx,ts4 mov ecx,s4 mov ebx,1 mov eax,4 int 0x80 mov edx,MAX_PALAVRA mov ecx,strnum mov ebx,0 mov eax,3 int 0x80 mov esi, strnum cld lodsb cmp al, '+' jne subtrai call fsoma jmp escreve subtrai: cmp al, '-' jne multiplica call fsubtrai jmp escreve multiplica: cmp al, '*' jne divide call fmultiplica jmp escreve divide: cmp al, '/' jne op_and call fdivide jmp escreve op_and: cmp al, '&' jne op_SL call fop_and jmp escreve op_SL: cmp al, 'S' jne erro_operador lodsb ; Carrega 2º byte do operador no al cmp al, 'L' jne op_SR call fop_SL jmp escreve op_SR: cmp al, 'R' jne erro_operador ;call fop_SR jmp escreve erro_operador: ; Mensagem operador inválido mov edx,ts5 mov ecx,s5 mov ebx,1 mov eax,4 int 0x80 jmp acabou escreve: ; Transforma resultado em string mov ecx, 8 mov edi, strnum mov ebx, [result] cld xor eax, eax cicloresult: rol ebx, 4 mov eax, ebx and eax, 0x0000000F cmp eax, 10 jl algarismo add al, 'A'-10 jmp fim3 algarismo: add al, '0' fim3: stosb loop cicloresult ; Imprime resultado mov edx,ts3 mov ecx,s3 mov ebx,1 mov eax,4 int 0x80 mov edx,8 mov ecx,strnum mov ebx,1 mov eax,4 int 0x80 mov edx,tlinha mov ecx,linha mov ebx,1 mov eax,4 int 0x80 acabou: ; Sair do programa passando o controlo ao sistema operativo mov ebx,0 mov eax,1 int 0x80 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;Funções fsoma: mov ebx, [num1] add ebx, [num2] mov [result], ebx ret fsubtrai: mov ebx, [num1] sub ebx, [num2] mov [result], ebx ret fmultiplica: mov eax, [num1] mov ebx, [num2] mul ebx mov [result], eax ret fdivide: xor edx, edx mov eax, [num1] mov ebx, [num2] div ebx mov [result], eax ret fop_and: mov ebx, [num1] and ebx, [num2] mov [result], ebx ret ; É necessário melhorar, pois o 'num2' pode ser maior que 'cl' fop_SL: mov ebx, [num1] mov ecx, [num2] shl ebx, cl mov [result], ebx ret pedeNumero: mov edx,ts1 mov ecx,s1 mov ebx,1 mov eax,4 int 0x80 mov edx,MAX_PALAVRA mov ecx,strnum mov ebx,0 mov eax,3 int 0x80 sub eax, 1 mov [tamstr],eax xor eax, eax xor ebx, ebx mov esi, strnum cld mov ecx, [tamstr] ciclonum1: lodsb cmp al, '9' jg letra1 and al, 0xF jmp fim1 letra1: and al, 0xF add al, 9 fim1: shl ebx,4 add ebx, eax loop ciclonum1 ret