Questo sito utilizza cookies, anche di terze parti, per mostrare pubblicità e servizi in linea con il tuo account. Leggi l'informativa sui cookies.
Username: Password: oppure
Altri Linguaggi - Assembly Mips - problema
Forum - Altri Linguaggi - Assembly Mips - problema

Avatar
Ste4OS (Normal User)
Newbie


Messaggi: 1
Iscritto: 03/07/2010

Segnala al moderatore
Postato alle 11:33
Sabato, 03/07/2010
Ciao a tutti! Avrei bisogno di una mano con questo piccolo programma assembly. Il programma deve fare questo: l'utente può inserire un numero (da 0 a 5) che indica il numero di oggetti da permutare, quindi se ad esempio viene inserito 3 il programma stamperà:

123
213
231
...
...

Prima di "buttarmi" nella programmazione assembly ho codificato questo algoritmo in Java. Vi posto il codice:
Codice sorgente - presumibilmente C++

  1. public class perm {
  2.  
  3.  
  4.  static void permutazioni(int anagramma[], int elementiMancanti[]){
  5.   if (elementiMancanti.length == 0){
  6.    print(anagramma);
  7.    return;
  8.   }
  9.  
  10.   int[] anag = new int[anagramma.length + 1];
  11.   for (int i=0; i<anagramma.length; i++)
  12.    anag[i]=anagramma[i];
  13.  
  14.   for (int i=0; i<elementiMancanti.length; i++){
  15.    anag[anag.length-1] = elementiMancanti[i];  //in assembler anag.length - 1 = anagramma.length
  16.    
  17.    int[] manc = new int[elementiMancanti.length-1];
  18.    int k=0;
  19.    for (int j=0; j<elementiMancanti.length; j++){
  20.     if (j!=i){
  21.      manc[k]=elementiMancanti[j];
  22.      k++;
  23.     }
  24.    }
  25.    
  26.    
  27.    permutazioni(anag, manc);
  28.   }
  29.  }
  30.  
  31.  
  32.  static void print(int[] anagramma){
  33.   for (int i=0; i<anagramma.length; i++)
  34.    System.out.print(anagramma[i]);
  35.   System.out.println();
  36.  }
  37.  
  38. }



L'ho fatto in java perchè è l'unico linguaggio che conosco.
Ora vi posto il codice .asm, non è completo ma una parte della codifica. Il problema è che non so se quello che sto scrivendo è esatto. Non posso provarlo finchè non è finito visto che sfrutta al 100% la ricorsione.
Codice sorgente - presumibilmente Plain Text

  1. .data
  2.  
  3. elemMancanti: .space 16
  4. anagramma: .space 16
  5. anag: .space 20
  6.  
  7. string1: .asciiz "Inserisci elementi: "
  8.  
  9. .text
  10.  
  11. .globl main
  12.  
  13. main:
  14.  
  15.         addi $t2, $zero, 0                              #dimensione iniziale anagramma
  16.         addi $t3, $zero, 1                              #dimensione anag al primo giro
  17.  
  18. acquis:
  19.  
  20.         li $v0, 4                                               #Seleziona print_string
  21.         la $a0, string1                                 #$a0 = indirizzo dell'etichetta string1
  22.         syscall                                         #chiama la procedura per stampare una stringa
  23.  
  24.         li $v0, 5                                               #seleziona read_int
  25.         syscall                                         #chiama la procedura per leggere un intero
  26.        
  27.         add $s0, $zero, $v0                             #$s0 = oggetti da utilizzare
  28.        
  29.         la $s1, elemMancanti                            #uso $s1 per memorizzare la base dell'array
  30.         la $s2, anagramma                                       #uso $s2 per memorizzare la base dell'array
  31.         la $s3, anag                                    #uso $s3 per memorizzare la base dell'array
  32.                
  33.         li $t0, 0                                               #uso $t0 per memorizzare l'indice (in questo caso 0)
  34.  
  35. riempi_elemMancanti:
  36.        
  37.         slt $t4, $t0, $s0
  38.         beq $t4, $zero, elabora
  39.  
  40.         move $a0, $t0                                   #carico in $a0 il valore dell'indice
  41.         sll $t1, $t0, 2                                         #$t1 = t0 * 4
  42.         add $t1, $s1, $t1                               #$t1 = inizio_elemMancanti + i*4
  43.         sw $a0, 0($t1)                                  #elemMancanti[i]= i
  44.        
  45.         addi $t0, $t0, 1                                        #incremento contatore
  46.         j riempi_elemMancanti                           #goto riempi_elemMancanti
  47.  
  48.         move $a0, $s1                                   #$a0 = base di elemMancanti
  49.         move $a1, $s2                                   #$a1 = base di anagramma
  50.         move $a2, $s0                                   #$a2 = dimensione di elemMancanti
  51.         move $a3, $t2                                   #$a3 = dimensione di anagramma
  52.  
  53.         jal permutazioni                                        #vai alla procedura permutazioni
  54.  
  55. permutazioni:
  56.  
  57.         bne $s0, $zero, calcola                         #se la "dimensione" del vettore elemMancanti != 0 goto calcola
  58.  
  59.         li $t0, 0                                               #uso $t0 per memorizzare l'indice (in questo caso 0)
  60.  
  61. stampa_anagramma:
  62.  
  63.         slt $t1, $t0, $t2                                       #se i < dimensione Anagramma allora $t1 = 1
  64.         beq $t0, $t2, ritorna
  65.         beq $t1, $zero, calcola                         #se $t1 == 0 allora goto calcola, else stampo vettore
  66.        
  67.         move $a0, $t0                                   #carico in $a0 il valore dell'indice
  68.         sll $t1, $t0, 2                                 #$t1 = $t0 * 4
  69.         add $t1, $s2, $t1                                       #$t1 = inizio_anagramma + i*4
  70.         lw $a0, 0($t1)                                  #$a0 = anagramma[i]
  71.        
  72.         li $v0, 1                                               #Seleziona print_int
  73.         syscall                                         #chiama la procedura per stampare un intero
  74.        
  75.         addi $t0, $t0, 1                                        #incremento contatore
  76.         j stampa_anagramma                              #goto stampa_anagramma
  77.  
  78. ritorna:
  79.        
  80.         j $ra
  81.        
  82. calcola:       
  83.        
  84.         li $t0, 0                                               #uso $t0 per memorizzare l'indice (in questo caso 0)
  85.  
  86. step1:
  87.  
  88.         slt $t1, $t0, $t2                                       #se i < dimensione anagramma allora $t1 = 1
  89.         beq $t1, $zero, step2                           #se $t1 == 0 allora goto step2, else elabora calcoli
  90.        
  91.         move $a0, $t0                                   #carico in $a0 il valore dell'indice
  92.         sll $t1, $t0, 2                                 #$t1 = $t0 * 4
  93.         add $t1, $s2, $t1                                       #$t1 = inizio_anagramma + i*4
  94.         lw $a0, 0($t1)                                  #$a0 = anagramma[i]
  95.         sll $t1, $t0, 2                                 #$t1 = $t0 * 4
  96.         add $t1, $s3, $t1                                       #$t1 = inizio_anag + i*4
  97.         lw $a1, 0($t1)                                  #$a1 = anag[i]
  98.         sw $a0, 0($a1)                                  #anag[i] = anagramma[i]
  99.  
  100.         addi $t0, $t0, 1                                        #incremento contatore
  101.         j step1                                         #goto step1
  102.  
  103. step2:
  104.  
  105.         li $t0, 0                                               #uso $t0 per memorizzare l'indice (in questo caso 0)
  106.  
  107.         slt $t4, $t0, $s0
  108.         beq $t4, $zero, elabora
  109.  
  110.         move $a0, $t0                                   #carico in $a0 il valore dell'indice
  111.         sll $t1, $t0, 2                                         #$t1 = t0 * 4
  112.         add $t1, $s1, $t1                               #$t1 = inizio_elemMancanti + i*4
  113.         move $a1, $t1                                   #preservo il contenuto in $a1, cosi riutilizzo $t1
  114.         sll $t1, $t3, 2                                 #$t1 = $t3 * 4, ho settato $t3 = 1 all'inizio perche anag parte con length = 1
  115.         add $t1, $s3, $t1                                       #$t1 = inizio_anag + i*4
  116.         addi $t1, $t1, -4                                       #$t1 = anag - 1
  117.         sw $a1, 0($t1)                                  #anag[anag.length-1] = elementiMancanti[i]
  118.        
  119.        
  120.         addi $t0, $t0, 1                                        #incremento contatore
  121.         j riempi_elemMancanti
  122.        
  123.        
  124.        
  125.        
  126.        
  127.        
  128.         li $v0, 10
  129.         syscall



Grazie mille in anticipo!

Ultima modifica effettuata da Ste4OS il 03/07/2010 alle 11:35
PM Quote