program Bubble // Input: N<10 nombres donnes par stdin termines par un nombre qui // produit un debordement lorsque multiplie par 2: {-2^14..2^14 -1} // Aucun element a l'exterieur de cet ensemble n'est accepte. // Un nombre a l'exterieur de l'ensemble indique la fin de la liste. // Output: les nombre tries en memoire a partir de la memoire 00, les // valeurs en ordre croissant sont donnees sur le stdout. // Remarks: // En hexadecimal, l'intervalle est xC000...x3FFF // pour ne pas creer de debordements et fausser les comparaisons. // ATTENTION: lorsqu'aucun element n'est donne, l'entier utilise // pour terminer la liste vide est retourne. Joue le role // d'un message d'erreur. // CE PROGRAMME FONCTIONNE EN SUPPOSANT QUE R[A]=R[F]=0 AU DEPART. // POUR L'UTILISER COMME FONCTION, IL FAUT L'APPELER AVEC R[A]=R[F]=0. // ----------------------------------------------------------------------------- //Initialisations de constantes et variables 10: 7101 R[1] <- 1 (la constante 1) // Debut de la lecture des entiers sur stdin 11: 8BFF read(R[B]) (NEXT mot a lire) 12: BB0A mem[R[A]] <- R[B] 13: 1AA1 R[A] <- R[A]+R[1] 14: 1DBB R[D] <- R[B]+R[B] 15: 4DDB R[D] <- R[D]^[B] verifie si le signe a change:deborde //Les deux tests suivants detectent si un entier trop petit ou trop grand est //en entree. Si tel est le cas alors la liste est terminee. 16: DD11 if (R[D]>0) goto READ NEXT (goto read next si le signe est stable) 17: CD11 if (R[D]==0) goto READ NEXT (goto read next aussi si R[B]==0) //Fin de la lecture des entiers. //Mettre les pointeurs a jour: //R[A] contient le nombre d'elements a trier //R[F] est le pointeur gauche. Il est initialise a 0, completement a gauche 18: 2AA1 R[A] <- R[A] - R[1] //R[C] est l'emplacement du dernier entier, celui le plus a droite. //On recommence un balayage en partant de la droite R[C]=R[A]-1. 19: 2CA1 R[C] <- R[A] - R[1] (extremite droite a droite toute!) //Teste si le pointeur droit R[C] a rejoint le pointeur gauche R[F] //Si non alors il y a des comparaisons a faire: 24 //Si oui alors nous avons le prochain plus petit en mem[R[F]] // et celui-ci est envoye sur stdout. 1A: 2DCF R[D] <- R[C] - R[F] (R[D]>0 si on doit encore comparer) 1B: DD22 if (R[D]>0) goto 22 (cherche l0 alors nous sommes pret a commencer la recherche //du prochain plus petit: 1B //Si R[D] <= 0 alors l'algo a termine. 1F: 2DAF R[D] <- R[A] - R[F] 20: DD19 if (R[D]>0) goto 19 (C revient au bout) 21: 0000 HALT //Cette section est responsable pour pour echange Mem[R[C]] et Mem[R[C]-1] 22: 2EC1 R[E] <- R[C] - R[1] (element mem[R[C]-1] pret.) 23: A70C R[7] <- mem[R[C]] 24: A60E R[6] <- mem[R[E]] 25: 2876 R[8] <- R[7]-R[6] 26: D829 if(R[8]>0) goto 29 OK 27: B60C mem[R[C]] <- R[6] (switch) 28: B70E mem[R[E]] <- R[7] (fin switch) //Nous venons de terminer l'inversion si elle avait lieu //Nous passons maintenant au prochain entier en position R[C] <- R[C]-1 29: 2CC1 R[C] <- R[C] - R[1] :OK (ok, R[C] suivant a gauche) 2A: C01A goto 1A (goto execute prochain R[C]) //On recommence la meme chose apres s'etre deplace d'une case memoire vers //la gauche. La destination est 1C.