bag.c

#include "MonDallas.h"

// getchar() et printf().
#include <stdio.h>

// srand(), rand(), init_mempool()
// malloc() et free().
#include <stdlib.h>

// isdigit().
#include <ctype.h>

// assert().
#include <assert.h>

// Echange le contenu pour deux
// indexes d'un tableau sans utiliser de
// variable temporaire (avec des
// "OU exclusifs").
#define ASWAP(i, j) do { \
  array[i] ^= array[j]; \
  array[j] ^= array[i]; \
  array[i] ^= array[j]; \
} while (0);

// Reserve 256 bytes de SRAM interne.
UC xdata malloc_mempool[0x100];

// Tableau a visibilite globale utilisant la
// SRAM interne.
xdata UC * array = NULL;

// Melange recursivement le contenu
// d'un tableau de taille n.
void shuffle(UC n);

// Gere la recuperation des entrees,
// leur validation, leur conversion,
// puis fournit un nombre entre 0 et 100,
// le tout simplement et recursivement.
UC get_number(UC i, UC accum, UC input);

void main(void) {
  UI entropy = 0; // Source de hasard.
  UC i = 0; // Compteur multi-usages.
  UC size; // Input (taille du tableau).

  // Blabla...
  SCON0 = 0x50;
  TMOD |= 0x20;
  TH1 = 0xFF;
  PCON = 0x80;
  TR1 = 1;
  TI_0 = 1;

  // Donne acces au 1K SRAM interne.
  PMR |= 0x01;

  // Initialisation de la memoire
  // dynamique.
  init_mempool(&malloc_mempool, sizeof(malloc_mempool));

  printf("Pese sur P3.3...\n");

  // Incremente le compteur tant que
  // le bouton n'est pas pese.
  while (P3_3) entropy++;

  // Initialisation "aleatoire"
  // du generateur.
  srand(entropy);

  while (1) { // Boucle infinie.

    printf("Entre un nombre entre 0 et 100 et pese sur \"Enter\"...\n");

    size = get_number(0, 0, getchar());
    assert(size < 101);

    // Cree un tableau d'unsigned chars
    // dynamiquement.
    array = malloc(sizeof(UC) * size);

    // Erreur si on manque de memoire.
    assert(array);

    // Initialise chaque valeur du
    // a son propre index.
    for (i = 0; i < size; i++) array[i] = i;

    // Melange le tableau.
    shuffle(size);

    // Imprime le tableau a l'ecran.
    printf("Indexes melanges:\n[%d", (UI)(array[0]));
    for (i = 1; i < size; i++) printf(", %d", (UI)(array[i]));
    printf("]\n\n");

    // Libere la memoire allouee
    // dynamiquement au tableau.
    free(array);
  }
}

// Algorithme recursif pour melanger le
// contenu d'un tableau:
// n = "taille du tableau".
// Echange les variables aux indexes
// (n - 1) et (nombre aleatoire entre
// 0 et (n - 1)) jusqu'a (n == 1).
void shuffle(UC n) {
  UC m = n - 1; // Decrementation.
  if (n > 1) { // Condition de terminaison.
    // n = (nombre aleatoire entre 0 et m)
    do { n = (UC)(rand() % (m + 1));
    // tant que n n'est pas different de m.
    } while (n == m);
    ASWAP(m, n); // Brassage.
    shuffle(m); // Recursion(n = n - 1).
  }
}

// Initialisation:
// get_number(0, 0, getchar());
// Accumule les nombres entres en
// multipliant la valeur accumulee
// par 10 a chaque recursion tout en
// testant la validite des entrees.
UC get_number(UC i, UC accum, UC input) {
  if ((i > 2) || (input == '\n')) return accum;
  else {
    assert(isdigit(input));
    return get_number(i + 1, (accum * 10) + (input - '0'), getchar());
  }
}