Tp d'assembleur (avec emu8086)

Alors d'abord comment on représente une matrice à une dimension.
En voici une:

[0, 1, 2, 5]

Sous 8086 les entiers sont codés sur 16 bits puisque les registres ont cette taille.
Chacun de ces nombres sera codé sur deux octets donc. Si le premier élément est à l'adresse 0, alors le second est à l'adresse 0 + 2 (car 16 bits ça fait deux octets). Le troisième élément est à 0 + 4 etc...

adresse i + 6 |  5  |
adresse i + 4 |  2  |
adresse i + 2 |  1  |
adresse i     |  0  |

Donc mettons que l'adresse de la matrice (donc l'adresse du premier élément soit dans bx), si tu veux mettre la valeur du deuxième élément dans ax, tu fais comme ça:

mov ax, [bx + 2]

En gros là règle c'est: pour accéder à l'élément i, je prends son adresse de base et j'y ajoute i * 2, sachant que l'indice de la matrice i commence à 0 dans cet exemple:

adresse_element[i] = adresse_base + (i * 2)

Maintenant prenont une matrice à 3 dimensions:

[0, 1]
[2, 3]
[4, 5]

Impossible de représenter ça réellement en mémoire, puisqu'elle se présente comme une longue ligne de case à un seul étage.
Alors du coup on transforme notre matrice 3 dimensions en une matrice 1 dimension. Comment me diras-tu? Eh bien on fait comme si les lignes qui suivent la première étaient mises à sa suite.
Tout bonnement ça donne ça:

[0, 1, 2, 3, 4, 5]

Donc si l'indice de la ligne est i, que l'indice de la colonne est j, et que ces indices commencent à 0, et que le nombre d'éléments dans une ligne est de N, alors l'adresse d'un élement de ta matrice est:

adresse_element[i][j] = adresse_base + (i * N * 2) + (j * 2)

Valà!