.
|
ProDOS
|
Download Assembleur mode d'emploi 1 side 1
(gzipped)
|
|
ProDOS
|
Download Assembleur mode d'emploi 1 side 2
(gzipped)
|
|
ProDOS
|
Download Assembleur mode d'emploi 2 (gzipped)
|
Sommaire
| Lien |
Information |
 |
Introduction Assembleur Mode d'Emploi 1. |
|
Assembleur Mode d'Emploi 1 partie 1. |
|
Assembleur Mode d'Emploi 1 partie 2. |
|
Assembleur Mode d'Emploi 1 partie 3. |
|
Assembleur Mode d'Emploi 1 partie 4. |
|
Doc Merlin : full screen editor. |
|
Doc Merlin : full screen editor command summary. |
|
Doc Merlin : Sourceror. |
|
Infos CRACKWARE. |
|
Introduction Assembleur Mode d'Emploi 2. |
|
Assembleur Mode d'Emploi 2 partie 1. |
|
Assembleur Mode d'Emploi 2 partie 2. |
|
Assembleur Mode d'Emploi 2 partie 3. |
|
Assembleur Mode d'Emploi 2 partie 4. |
|
Cours sur le mode graphique HGR. |
|
Publicité de freewares de l'underground. |
Introduction Assembleur Mode d'Emploi 1
INTRODUCTION,
Ces cours d'assembleur sont
(je le pense assez clairs pour quelqu'un
qui n'y connait rien)
réservés en particulier aux débutants.
Un grand programmeur n'y
trouvera pas son bonheur.
Si vous vous posez des
questions posez-les aussi dans la bal
HACKERFORCE (36-14
code:135060318*RTEL) et nous vous aiderons.
Big HELLLLLLLLOOOOOOO TO:
THE BRAIN TRUST (je sais qu'il sont encore dans les parages)
THE WARRIORS OF DESTINY
THE LYON'S GANG
W.O.R.P.
MV GANG
DOX A GAZ'S TEAM
$FF59 CONNECTION
R.P.C.B.
VISUAL EYES
GODFATHER
BIIIIIIIIIIIGS SHIIIIIIIIIIIITS TO:
CCCC RRRR
AAA ZZZZZ Y
Y
BBBB OOO
Y Y
C R
R A A
Z Y
Y -----
B B O O
Y Y
C RRRR
AAAAA
Z
Y -----
BBBB O
O Y
C R
R A A
Z
Y
B B O
O Y
CCCC R R A
A ZZZZZ
Y
BBBB OOO Y
Retour sommaire
Assembleur Mode d'Emploi 1 partie 1
-------------------------------------------------------------------------------
! PART1 ASSEMBLEUR MODE
D'EMPLOI THE WHITE MAN FROM
HACKERFORCE !
-------------------------------------------------------------------------------
Tout d'abord, que les choses
soient claires. Dans ce cours d'assembleur
pour Apple, il n'est pas question de faire référence
à des langages évolués
comme le Cobol ou le Pascal. La plupart de ces programmes ont
été écrits eux-
memes en assembleurs et ne nous intéressent pas pour le moment.
Supposez que
vous souhaitiez apprendre l'espagnol et que vous ayez
déjà des notions d'
anglais, vous ne ferez pas appel à la première langue
pour apprendre la
seconde.Ceci étant dit, passons au vif du sujet. L'assembleur
est en fait un
traducteur. Votre Apple ne connait en fait qu'une seule langue, c'est
l'
électricité. Elle passe ou ne passe pas. Cependant,
l'Apple sans l'adjonction
du Basic ne connait pas le décimal. On ne peut lui parler qu'en
binaire ou en
puissances de 2. Mais vous avouerez qu'un groupe de bits de ce genre:
00101001,
01001001 ou 01011101 n'est pas très lisible. Il y a quelques
années, on
utilisait le système octal (base 8). Nous sommes passés
au système hexadécimal
pour plus de commodité, car il permet de représenter une
suite de 16 états sur
4 chiffres.
--------------------------
! HEXACHLORURE D'APPLE !
--------------------------
Le système
hexadicimal (que j'appelerai hexa pour aller plus
vite)
comporte 16 chiffres. Les 10 premiers sont communs à la notation
décimale et
les 6 suivants sont les caractères alphabétiques A, B, C,
D, E et F. Voici un
tableau montrant les correspondances binaire-décimal-hexa.
BINAIRE
DECIMAL
HEXA
-------
-------
----
00000000
0
0
00000001
1
1
00000010
2
2
00000011
3
3
00000100
4
4
00000101
5
5
00000110
6
6
00000111
7
7
00001000
8
8
00001001
9
9
00001010
10
A
00001011
11
B
00001100
12
C
00001101
13
D
00001110
14
E
00001111
15
F
00010000
16
10
00010001
17
11
00010010
18
12
etc.....
Il est plus facile de
convertir de binaire en hexa que de décimal en
hexa. Par exemple, si vous avez la suite 11101111 11100100, vous
pouvez
traduire ceci en EFE4. En effet, en partant de la droite, 0100 est
égal à 4 en
hexa. 1110 correspond à E 1111, à F et 1110 à E.
On fera toujours précéder un
nombre en hexa de $ pour éviter les confusions. Par exemple, si
vous avez le
nombre 100, il peut correspondre à 100 en décimal,
à 4 en binaire ou à 256 en
hexa. Les nombres binaires seront précédés du
caractère %. L'assembleur vous
parait peut-etre assez difficile à comprendre, mais vous
avouerez que c'est
plus clair qu'un listing hexa.
---------------------------------
! L'ASSEMBLEUR: LANGAGE TURBO !
---------------------------------
L'assembleur est une aide
à la programmation en hexadécimal. C'est le
langage le plus proche de la machine qui n'est ni
interprété ni compilé, mais
assez compréhensible pour l'homme, cette bete qu'on dit sauvage
(excusez-moi).
Pourquoi programmer en assembleur? Parce qu'un programme
assemblé va très vite,
beaucoup plus vite que n'importe quel autre langage, et parce qu'en
général, il
prend beaucoup moins de place qu'un programme écrit en langage
évolué. Il
permet aussi de communiquer directement avec la machine et de lui
faire
exécuter des choses qu'on croyait impossibles: essayer d'obtenir
un curseur en
forme d'étoile en Basic, je vous souhaite bien du courage.
Avant de se promener dans le
mémoire, voyons de quoi elle a
l'air.
Voici un tableau qui vous aidera à vous y reconnaitre
FFFF ---------------
!
!
! ROM !
!
!
D000 ---------------
!
!
---------------
C000
!
!
! RAM !
!
!
!
!
!
!
!
!
!
!
!
!
!
!
0000 ---------------
---------------
! TABLEAU 1 !
---------------
L'Apple ne sait compter que
jusqu'à 65535, ce qui correspond à $FFFF en
hexa. On dira que $0000 est l'adresse la plus basse et $FFFF la plus
haute.
C'est simple comme bonjour. Le tableau est divisé en deux
parties. La première
est appelée RAM et la seconde ROM. La ROM est l'endroit de la
mémoire qui ne
s'efface pas lorsque que l'on éteint l'ordinateur et où
l'on ne peut pas
écrire. La RAM s'efface et on peut la modifier. La ROM contient
le BASIC et le
moniteur, c'est à dire le programme qui conduit la plupart des
opérations. Vous
ne vous etes jamais demandé pourquoi lorsque vous tapez ABC sur
votre clavier,
la meme chose s'inscrit sur votre écran? Eh bien la
réponse est simple: c'est
le moniteur qui s'en occupe. Sans lui vous ne pourriez pas faire grand
chose et
le Basic lui-meme y fait appel. La RAM, comme indiqué sur le
tableau va de l'
adresse $0000 jusqu'à $BFFF. La ROM va de $D000 à $FFFF.
Qu'est-ce qu'il y a de
$C000 à $CFFF? Ni ROM ni RAM, nous n'en parlerons pas
maintenant, vous le
découvrirez plus tard. Alors passons aux actes et promenons-nous
dans l'Apple
pour voir ce qui s'y trouve.
Tapez CALL-151
<RETURN> et le prompt se trouve transformé en *
(le
prompt, c'est le crochet gauche en français, c'est le signe
paragraphe) que
vous obtenez lorsque vous allumez l'ordinateur. Il vous indique alors
que vous
etes en Basic et que la machine attend un ordre de votre part. Dans
notre cas,
il nous prévient que nous sommes en mode moniteur, ce qui veut
dire que nous
sommes en communication directe avec la machine et que nous ne lui
parlons qu'
en hexadécimal. Tapez alors E000L (en clair: faire le listing
sur 24 lignes de
ce qui se trouve en mémoire à partir de l'adresse $E000
en hexa). Vous devez
voir ceci:
*E000L
E000- 4C 28 F1 JMP $F128
E003- 4C 3C D4 JMP $D43C
E006- 89 20 BIT #$20
E008- B1 00 LDA ($00),Y
E00A- 90 05 BCC $E011
E00C- 20 7D E0 JSR $E07D
E00F- 90 0B BCC $E01C
E011- AA TAX
E012- 20 B1 00 JSR $00B1
E015- 90 FB BCC $E012
E017- 20 7D E0 JSR $E07D
E01A- B0 F6 BCS $E012
E01C- C9 24 CMP #$24
E01E- D0 06 BNE $E026
E020- A9 FF LDA #$FF
E022- 85 11 STA $11
E024- D0 10 BNE $E036
E026- C9 25 CMP #$25
E028- D0 13 BNE $E03D
E02A- A5 14 LDA $14
1e COL. 2e COL. 3e COL.
---------------
! TABLEAU 2 !
---------------
(Notez que nous n'avons pas
fait précéder l'adresse du signe $, car l'
Apple ne parle qu'hexa en mode moniteur. Il n'est donc pas
nécessaire de lui
préciser). La première colonne correspond aux adresses.
La deuxième est le
programme en hexadécimal, la troisième est la
correspondance en assembleur du
programme.
Nous avons dit plus haut
qu'il n'était pas possible de modifier
le
contenu d'une adresse placée en ROM (car si l'on fait
référence au tableau 1,
on s'aperçoit que l'adresse $E000 se trouve en ROM). Pour le
vérifier, il
suffit de taper l'adresse suivie de deux points puis ce que l'on veut y
mettre
et voir si le contenu a changé. Pour cela tapez E000:40 (sans $,
car l'Apple ne
parle qu'hexa en mode moniteur). Normalement, l'adresse $E000 devrait
etre
modifiée. En tapant E000L comme tout à l'heure, on
s'aperçoit que le contenu
n'a pas changé. Donc la ROM n'est pas modifiable. Maintenant
passons à la RAM.
Nous allons essayer de modifier l'adresse $0000. Mais auparavant,
voyons voir
ce qu'il y a à cette adresse. Tapez 0000L et vous y trouvez le
nombre 4C. Pour
changer le contenu, écrivez 0000:F4 (F4 est pris comme exemple,
vous pouvez y
mettre ce que vous voulez). Regardez à nouveau ce qui se passe
en $0000 par la
meme opération que tout à l'heure, et vous voyez devant
vos yeux ébahis que le
contenu a effectivement changé.
Donc, voilà pourquoi
nous pourrons écrire des programmes en hexadécimal
sur l'Apple directement sans passer par un assembleur, chose que nous
ferons
plus tard. Je vous sens pris d'une irrésistible envie de
regarder ou de
modifier une adresse comprise entre $C000 et $CFFF, je vous laisse le
faire,
mais à vos risques et périls.
Retour sommaire
Assembleur Mode d'Emploi 1 partie 2
-------------------------------------------------------------------------------
! PART2 ASSEMBLEUR MODE
D'EMPLOI THE WHITE MAN FROM
HACKERFORCE !
-------------------------------------------------------------------------------
La dernière fois,
nous nous sommes promenés dans la mémoire. Pour cela,
nous avons tapé CALL-151 suive de <RETURN>, ce qui nous
permettait d'entrer
dans le moniteur. Désormais et à partir de maitenant tout
de suite, je ne
repréciserai plus la façon d'y entrer, car je pense que
cela ne vous est pas
trop difficile à mémoriser.
Nous avons sur le tableau 1
le listing de la mémoire allant de $E000 à
$E02B. Comme je l'ai montré la fois précédente,
chers petits amis, la troisième
colonne est une représentation en assembleur des codes
hexadécimaux de la
deuxième colonne.
---------------
! TABLEAU 1 !
---------------
*E000L
E000- 4C 28 F1 JMP $F128
E003- 4C 3C D4 JMP $D43C
E006- 89 20 BIT #$20
E008- B1 00 LDA ($00),Y
E00A- 90 05 BCC $E011
E00C- 20 7D E0 JSR $E07D
E00F- 90 0B BCC $E01C
E011- AA TAX
E012- 20 B1 00 JSR $00B1
E015- 90 FB BCC $E012
E017- 20 7D E0 JSR $E07D
E01A- B0 F6 BCS $E012
E01C- C9 24 CMP #$24
E01E- D0 06 BNE $E026
E020- A9 FF LDA #$FF
E022- 85 11 STA $11
E024- D0 10 BNE $E036
E026- C9 25 CMP #$25
E028- D0 13 BNE $E03D
E02A- A5 14 LDA $14
1e COL. 2e COL. 3e COL.
Pour etre plus clair, car je
sens que vous vous embrouillez,
je
parlerai de la troisième colonne en tant que listing assembleur.
Or, ce listing
assembleur est lui-meme composé de deux colonnes dont la
première contient
toujours trois lettres, elles-memes appelées "code
mnémonique" et la deuxième
contient les opérandes, c'est à dire les adresses
affectées par les mnémoniques
qui les précèdent.
Nous allons vite
écrire un petit exemple car je sens
qu'une
irrésistible envie de bailler vous tourmente. Entrons donc dans
le moniteur (je
pense que vous savez comment). La petite étoile et le curseur
clignotant vous
indiquent que l'ordinateur attend un ordre: nous allons donc commencer
par un
programme complètement idiotnulcon et dénué
d'intéret. A la fin de
chaque
ligne, ne jamais oublier de taper <RETURN>.
*300:00
*301:A9 01 8D 00 03 60
Tapez ensuite 300L et vous
devez voir ce qui suit sur votre écran (si
ce n'est pas le cas, vous vous etes planté quelque part et notez
que le signe #
correspond au signe dièse au clavier américain). Ce qui
suit notre programme ne
nous intéresse pas pour le moment, je ne l'indique donc pas
ci-dessous.
300- 00
301- A9 01 LDA
#$01
303- 8D 00 03 STA $300
306-
60 RTS
Ce programme ne fait rien
d'autre que de ranger à l'adresse $300
le
chiffre 01. Pour etre sur de notre résultat, nous avons d'abord
stocké en
commande directe un 00 à cette adresse (300:00). Pour faire
tourner le
programme, tapez 301G et en retapant 300L, vous pourrez apercevoir que
l'
adresse $300 a effectivement changé. Génial, non?
--------------------
! SALADE DU CHEF !
--------------------
Le code A9 en hexa
correspond au mnémonique LDA, et STA est
la
traduction du code 8D. LDA veut dire en clair et sans décodeur:
LoaD
Accumulator ou en français: charger l'accumulateur avec la
valeur suivante. L'
accumulateur est un registre avec l'aide duquel s'effectuent pas mal
de
transferts de données ou d'opérations comme l'addition et
la soustraction. On y
met un nombre compris entre 0 et 255 et on peut alors en faire ce qu'on
veut (
sauf de le donner à sa grand-mère comme cadeau de Noel).
Dans notre cas, l'
accumulateur nous a servi d'intermédiaire pour ranger une valeur
à l'adresse
$300. Cette valeur était $01, nous aurions très bien pu
en prendre une autre.
Le dernier mnémonique
(RTS) est une instruction de retour de sous-
programme. Cette instruction nous servira beaucoup. Sans elle, on ne
peut en
général pas reprendre le controle de la machine, ce qui
est assez genant.
Nous allons traduire en
français ce que nous venons d'expliquer
en
suivant pas à pas le déroulement du programme.
LDA #$01: Charger le registre accumulateur avec la valeur $01
STA $300: Ranger le contenu de l'accumulateur à l'adresse $300
RTS: Retour à l'utilisateur
Nous reparlerons plus tard
de la signification du signe # qui se trouve
juste après l'instruction LDA.
------------------------
! PLUS D'INSTRUCTION !
------------------------
Le mnémonique LDA
n'est pas tout seul. Il en existe deux autres
qui
transportent des données: LDX et LDY. Leurs correspondances en
hexa sont
respectivement A2 et A0 et les instructions de rangement STX et STY.
Dans notre
programme, nous pouvons donc remplacer les deux premières
instructions par ces
nouvelles venues et nous obtiendrons le meme résultat.
Nous avons vu que nous
pouvions charger un registre avec une valeur
quelconque comprise entre 0 et 255 ($FF). Cependant, nous pouvons aussi
mettre
dans ce registre une valeur contenue dans une adresse
spécifiée. Par exemple,
si je veux charger le regitre A avec la valeur contenue à
l'adresse numero $30,
il me suffit d'écrire LDA $30, sans faire précéder
le signe $ du signe #. C'est
là que nous nous apercevons de l'utilité de ce signe, qui
nous permet d'indiquer
à l'ordinateur quel type d'instruction nous désirons
utiliser. Ces deux façons
d'agir sont appelées "mode d'adressage". Dans notre programme
nous avions utilisé
le mode "immédiat", et dans l'autre exemple le mode "absolu". Il
existe d'autres
modes d'adressages, mais je pense que vous devez d'abord ingurgiter
tout cela avant
de vous enfoncer dans les profondeurs modales (quelle poésie!).
Voici un deuxième
programme commençant à l'adresse $300 et
utilisant
les instructions que nous venons de décrire, qui range aux
adresses $2000 à
$2002 les valeurs 1,2 et 3 et en $2003 la valeur contenue à
l'adresse $21.
300:A9 01 8D 00 20 A2 02 8E 01 20 A0 03 8C 02 20 A5 30 8D 03 20
60<RETURN>
Le programme en
mémoire doit ressembler à ceci:
300- A9 01 LDA
#$01
302- 8D 00 20 STA $2000
305- A2 02 LDX
#$02
307- 8E 01 20 STX $2001
30A- A0 03 LDY
#$03
30C- 8C 02 20 STY $2002
30F- A5 30 LDA $21
311- 8D 03 20 STA $2003
314-
60 RTS
Si vous tapez 2000L
après l'exécution du programme, vous remarquerez qu'
il y a effectivement les valeurs 1, 2 et 3 en $2000, $2001 et $2002 et
qu'en
$2003 nous avons le nonbre qui se trouve à l'adresse $21. Les
codes
hexadécimaux correspondants aux différents types de modes
d'adressages
différent bien entendu selon le mode utilisé.
---------------------
! REGISTRE D'ETAT !
---------------------
En plus des registres que
nous venons de décrire, il existe
un
quatrième registre qui n'est pas utilisé pour ranger des
nombres mais pour
indiquer dans quel état (d'où le nom) se trouvent divers
bits (s'ils sont à 1
ou à 0) qui nous donneront de précieux renseignements sur
le déroulement du
progranmme.
En effet, ce registre
contient 8 bits (comme tous les autres registres
d'ailleurs) dont sept sont utilisés. Comme vous pouvez le voir
sur le tableau 2
ils sont numérotés de 0 à 7 de droite à
gauche.
---------------
! TABLEAU 2 !
---------------
7 6 5 4
3 2 1 0
---------------------------------
! N ! V ! - ! B ! D ! I ! Z ! C !
---------------------------------
Le bit 1 (appelé bit
zéro ou bit Z) est celui qui nous intéresse
en
premier. Ce sera un des plus utilisés dans nos prochains
programmes. Il est mis
à un par le microprocesseur lorsque le résultat d'une
opération n'est pas égal
à zéro, et est mis à zéro dans le cas
contraire. Mais attention, j'entends par
résultat d'opération le fait que:
1: le chiffre résultant de l'opération soit 0
2: l'opération donne un résultat vrai. Par exemple, si
vous comparez deux
chiffres qui sont égaux, le résultat de la comparaison
sera vrai, donc le bit 1
sera mis à zéro.
Retour sommaire
Assembleur Mode d'Emploi 1 partie 3
-------------------------------------------------------------------------------
! PART3 ASSEMBLEUR MODE
D'EMPLOI THE WHITE MAN FROM
HACKERFORCE !
-------------------------------------------------------------------------------
Nous avons vu la
dernière fois à quoi correspondait le registe
d'état
et nous avons expliqué la fonction du bit Z. Mais que ce bit se
mette à un ou
à zéro nous fait une belle jambe si on ne peut pas en
tirer profit. C'est pour
cele que je vais introduire deux nouvelles instructions qui
tiennent
précisément compte de ce bit.
-------------------
! BRANCHEZ-VOUS !
-------------------
BEQ VRAI effectue toujours
un branchement au programme VRAI si le bit
Z est à zéro. Sinon, le programme continue son
déroulement normal. BNE FAUX
effectue comme vous pouvez le deviner aisément un branchement au
programme FAUX
si le bit Z est à 1. Voici un petit programme illustrant ce que
je viens de
vous décrire ci-dessus.
ORG $300
LDA #$01
BNE FAUX
BRK
FAUX RTS
Ce programme est très
simple. Nous mettons dans le registre A la valeur
01, le bit Z se positionne donc automatiquement à 1 et
l'instruction BNE
effectue le branchement au programme FAUX. L'instruction ORG n'est pas
une
instruction du 6502, mais est spécifique à l'assembleur
et lui indique que je
désire commencer mon programme à l'adresse $300.
---------------------------------
! MAIS OU SONT LES ADRESSES ? !
---------------------------------
Vous remarquerez que dans ce
programme je n'utilise pas d'adresses
comme dans les programmes précédents. La raison est
simple, ce programme est
écrit à l'aide d'un assembleur qui calcule lui même
les adresses et vous vous
rendez compte plus loin pourquoi cette aide est vraiment primordiale
pour
écrire de vrais programmes. Voici le meme exemple écrit
directement sans
assembleur: entrez dans le moniteur et tapez 300:A9 01 D0 01 00
60 <RETURN>.
Après avoir tapé ceci suivit de 300L, vous devez voir ce
listing:
0300- A9 01 LDA #$01
0302- D0 01 BNE $305
0304- 00 BRK
0305- 60 RTS
Si vous comparez les deux
listings, vous remarquerez que le mot FAUX a
été remplacé par l'adresse $305. Vous comprendrez
qu'il est plus facile de lire
un listing qui admet des étiquettes comme FAUX que des adresses.
A l'adresse $303 se trouve
le chiffre 01. Ce chiffre correspond au
nombre d'octets que le programme doit sauter afin de se retrouver
à la bonne
adresse. Par exemple, dans notre programme, le branchement devant
s'effectuer à
l'adresse $305, le programme doit sauter 01 octet pour atterrir
où il faut. L'
assembleur calcule automatiquement le nombre d'octets à sauter
alors qu'en
écriture directe il faut le calculer soit meme. Dans nos
prochains listing je
vous écrirai les programmes en assembleur et vous donnerai
l'équivalent en
écriture directe comme le l'ai fait au-dessus en attendant que
vous ayez appris
à vous servir d'un assembleur.
QUELQUE ASSEMBLEUR:
-------------------
MERLIN (anciennement BIG MAC), rapide très simple
d'utilisation et admet des
macros instructions.
LISA est impressionant par sa rapidité mais est moins simple
d'utilisation que
MERLIN et à ma connaissance disponible qu'en DOS 3.3.
EDASM d'Apple (sous PRODOS) aurait pu etre correct si l'accès au
disque n'était
pas si fréquent.
MERLIN PRO en face B de ce disque V2.43
-----------------
! BRAIKCQUEUE !
-----------------
Revenons à notre
programme. Exécuter le programme (300G) et que
se
passe-t-il ? Rien. C'est normal puisque notre branchement
s'effectue
correctement et que nous arrivons à l'adresse $305 qui contient
un RTS (ReTour
de Sous-programme). L'ordinateur nous rend donc la main après
avoir fait ce
qu'on lui a demandé de faire. Changez la valeur donnée du
registre A en 00
(301:00) et exécutez-le programme. Que se passe-t-il cette
fois-ci
?
L'ordinateur fait bip et vous affiche des choses bizarres. Ne vous
inquiétez
pas, il n'est pas planté, vous n'avez pas besoin d'aller le
faire réparer, il a
simplement exécuté l'intruction BRK (hexa 00) car le
branchement à l'adresse
$305 ne pouvait se faire. Cette instruction (contraction de BREAK)
signifie
"interruption du programme en cours". Vous me direz "Mais pourquoi ne
pas avoir
mis un RTS au lieu d'un BRK puisque le programme était de toutes
façons fini",
je vous répondrai alors "Ah petit malin! Mais comment
aurions-nous
pu
distinguer le fait que le branchement se soit bien
réalisé ou non!".
Le
charabia affiché à la suite du BRK est bien utile: il
s'agit en effet des
valeurs registres A, X, Y suivit d'autres renseignements. La valeur du
registre
A est effectivement égale à 0 dans notre cas. Il est
aussi possible d'obtenir
ces valeurs sans l'intermediaire du BRK mais en tapant CTRL-E
<RETURN>. Vous
pouvez donc vérifier que tout se déroule bien en mettant
01 dans A, en
exécutant le programme et en tapant CTRL-E lorsqu'il vous
redonne la main.
----------------
! JMP MOUTON !
----------------
Une instruction nouvelle:
JMP, contraction de JUMP qui comme son nom l'
indique exécute un saut à un programme, mais sans tenir
compte de la valeurs d'
un bit du registre d'état. Ce saut s'appelle un branchement
inconditionnel
alors que les autres instructions que nous avons vu
précédemment sont des
branchements contionnels. Le petit programme qui suit vous permettra de
bien
comprendre la différence entre ces branchements.
DEBUT ORG $300
LDA #$00
STA $F0
LDX #$00
LDY #$D0
STX $F1
STY $F2
BNE NONEGAL
JMP DEBUT
NONEGAL RTS
Equivalent en écriture directe:
300: A9 00 85 F0 A2 00 A0 D0 86 F1 84 F2 D0 03 4C 00 03 60
<RETURN>.
Ce qui donne en mémoire:
300- A9 00 LDA
#$00
302- 85 F0 STA $F0
304- A2 00 LDX
#$00
306- A0 D0 LDY
#$D0
308- 86 F1 STX $F1
30A- 84 F2 STY $F2
30C- D0 03 BNE
$311
30E- 4C 00 03 JMP $300
311-
60 RTS
Ce programme n'est pas
compliqué, il remplit les registres A, X, et Y
de valeurs, les stocke à certaines adresses effectue un
branchement à $311 quand
le bit Z vaut à 1, ou retourne à $300 dans le cas
contraire. Si vous
faites tourner ce programme, vous remarquerez qu'il vous redonne la
main, donc
qu'il passe en $311. La raison est simple, le registre Y contient la
valeur $D0
qui est différente de zéro, donc le bit Z est mis
à un et le
branchement
s'effectue. Par contre, si vous intervertissez STX et STY afin que STX
se
trouve juste avant le BNE et vous refassiez tourner le programme,
vous
remarquerez qu'il ne vous rend plus la main mais qu'il tourne sur lui
meme (JMP
$300) et que le seul façon de l'arreter est d'appuyer sur RESET.
Note de Deckard (23/12/2004): c'est inexact.
STX et STY n'altèrent pas le registre d'état.
Il faut intervertir LDX et LDY pour faire planter le programme, c'est
à
dire LDY #$D0 puis LDX #$00.
Voilà j'espère
que vous avez bien compris le fonctionnement
des
instructions de branchement, exercez-vous à écrire des
petits programmes qui
tiennent compte de toutes les instructions que nous avons vues mais
soyez tout
de meme en forme pour la prochaine fois, ne vous ruinez pas la
santé...et allez
donc faire un tour en face B (il y a MERLIN PRO V2.43).
Retour sommaire
Assembleur Mode d'Emploi 1 partie 4
-------------------------------------------------------------------------------
! PART4 ASSEMBLEUR MODE
D'EMPLOI THE WHITE MAN FROM
HACKERFORCE !
-------------------------------------------------------------------------------
Cette fois-ci, nous allons
découvrir les instructions de transfert, les
différentes façons d'addresser et le saut à des
sous-programmes.
--------------------
! TRANSFERONS... !
--------------------
Il se peut que nous ayons
besoin de transférer les valeurs
d'un
registre à un autre. Par exemple, TYA transfère la valeur
du registre Y dans le
registre A. Y contient toujours cette valeur. Il existe TXA, TAY, TYA,
et TAY.
Sur apple //c (ou nouveau //e) qui contient un micro-processeur 6502
plus
étendu (le 65C02), il est possible de transférer de X
à Y par TXY et vice-
versa. Une autre instruction de transfert existe (TXS et TSX) mais
celle-ci ne
sera étudiée que plus tard. Ce petit programme illustre
l'utilisation des
instructions de transfert:
ORG $300
LDA #$A0
TAX
TAY
STX $02
STY $03
STA $04
BRK
300- A9 A0 LDA
#$A0
302-
AA TAX
303-
A8 TAY
304- 86 02 STX $02
306- 84 03 STY $03
308- 85 04 STA $04
30A-
00 BRK
Ce programme permet de
prendre dans les registres A, X, et Y la valeur
$A0 et de stocker cette valeur dans les adresses $02 à $04.
Il aurait été
possible d'écrire:
ORG $300
LDA #$A0
STA $02
STA $03
STA $04
BRK
300- A9 A0 LDA
#$A0
302- 85 02 STA $02
304- 85 03 STA $03
306- 85 04 STA $04
308-
00 BRK
mais nous voulions finir ce programme avec la valeur de A dans X et Y.
Les
instructions de transfert sont très utiles. Si nous voulons par
exemple
additionner #$03 à une valeur du registre X, ce n'est pas
possible, il faut donc
transférer X dans A, effectuer le calcul sur A, et
transférer le résutat obtenu
dans X.
-----------------------------
! AH DRESSONS L'ADRESSAGE !
-----------------------------
Nous connaissons l'adressage
sur la page zéro sans le savoir. En effet,
lorsque nous écrivons STA $03, nous stockons à l'adresse
03 la valeur de A. L'
adresse 03 se trouve dans la page zéro. Mais qu'est ce que c'est
la page zéro ?
La page zéro, ce sont toutes les adresses allant de $00 à
$FF. Toutes ces
adresses n'ont qu'un octet, ce qui nous rendra de nombreux services
plus tard.
LDA $300, qui signifie
charger dans A la valeur se trouvant en $300 est
un adressage absolu. LDA #$A0 charge dans A la valeur $A0. Cet
adressage est
appellé Immédiat. Les instructions LDA, STA, LDX, STX,
LDY et STY utilisent ces
adressages. Quand on utilise un assembleur, qu'on écrive LDA
#$A0 ou LDA $9FD0,
on ne voit pas la différence entre les codes correspondants aux
mnémoniques.
Par contre, en hexadécimal, les codes de LDA immédiat et
LDA absolu sont
différents.
Si le microprocesseur voit
par exemple le code A9 (LDA immédiat), il
sait que le code hexa qui suit est la valeur à charger dans A.
Par contre, s'il
voit la valeur AD (LDA absolu), il sait que les deux octets qui
suivent
correspondent à l'adresse où se trouve la valeur à
charger. L'assembleur
transforme de lui-meme en codes distincts afin que le microprocesseur
exécute le
programme correctement.
----------------
! JSR, ENFIN !
----------------
Enfin nous allons pouvoir
nous amuser et afficher des choses à l'écran.
L'instruction JSR va nous permettre d'exécuter des
sous-programmes déjà écrits
par les gentils programmeurs de chez Apple. Nous allons utiliser
l'éffacement
de l'écran text et l'affichage de caractères.
Pourquoi ne
l'écririons-nous pas nous-meme ?
Il serait tout à fait
possible d'écrire une routine
d'affichage.
Cependant ceci est beaucoup plus compliqué qu'il n'y parait.
Cette routine
éxistant déjà et étant simple
d'utilisation, nous n'allons pas nous crever à en
inventer une autre.
L'appel de cette routine est
très facile, il faut mettre dans
le
regitre A le code ascii de carctère à afficher. Le code
quoi ? ? ? Le code
ascii (américan standard code for information interchange). En
clair: à chaque
caractère est assigné une valeur de 0 à 255. La
lettre A a comme code $41.
Evidemment, chez Apple on ne fait pas comme les autres, et le code de A
est
$C1. La raison vous sera expliquée plus tard.
Revenons à JSR. Cette
instruction va sauter (comme un JUMP) à
un
sous-programme, mais contrairement au JUMP, va calculer l'adresse de
retour et
y aller dès qu'il va rencontrer un RTS dans ce sous-programme.
Alors allons-y, et
écrivons TWM sur l'écran en haut à gauche.
HOME EQU $FC58
COUT EQU $FDED ; note DCKD: COUT signifie Character OUT (=écrire
caractère)
; (ce n'est pas COUNT comme écrit dans le texte original)
ORG $300
JSR HOME
LDA #"T"
JSR COUT
LDA #"W"
JSR COUT
LDA #"M"
JSR COUT
RTS
0300- 20 58 FC JSR $FC58
0303- A9 D4 LDA
#$D4
0305- 20 ED FD JSR $FDED
0308- A9 D7 LDA
#$D7
030A- 20 ED FD JSR $FDED
030D- A9 CD LDA
#$CD
030F- 20 ED FD JMP $FDED
0312-
60
RTS
0313-
00 BRK
Qu'est-ce que c'est que ce
JSR COUT ? On voit au début du programme
assembleur que nous avons assigné à COUT la valeur $FDED.
Donc à chaque fois
que l'assembleur verra la chaine COUT, il la transformera en $FDED.
Pour la
fonction HOME qui efface l'écran, c'est la meme chose. Le
programme se termine
par un RTS pour nous redonner la main. Je vous ai dit plus haut que la
lettre A
égale à $C1. Nous aurions donc pu écrire LDA #$C1
au lieu de LDA #"A", mais
puisque l'assembleur nous le traduit, pourquoi s'énerver
à trouver chaque code
de chaque lettre! Ci-dessous vous trouverez l'équivalent en
hexadécimal tapez
le programme en assembleur ou en hexa et exécutez-le (par 300G
sous assembleur)
Que voyez-vous apparaitre si vous ne vous etes pas trompé ? TWM
! Ca c'est de
la pub à domicile !
----------------
! RALAPATATE !
----------------
Vous me direz
évidemment qu'écrire TWM comme ça de
carctère
en
caractère, c'est pas génial, surtout si on veut
écrire de longues phrases. Une
solution très simple existe cependant, qui utilise un nouveau
mode d'adressage:
l'absolu indexé par X. Ne sautez pas sur vos chaises, ce n'est
pas compliqué et
c'est super. Le processus est simple: si vous écrivez par
exemple LDA $2000,X
et que X est égal à 1, il chargera A avec la valeur
contenue dans $2001. Super,
non ? Et pour afficher TWM, vous voyez ce que je veux faire ? Non ? Eh
bien
regardez le programme qui suit:
ORG $300
COUT EQU $FDED
LDX #$00
BOUCLE LDA CHAINE,X
BEQ FIN
JSR COUT
INX
JMP BOUCLE
FIN RTS
CHAINE ASC "TWM"00
300- A2 00 LDX
#$00
302- BD 0F 03 LDA $030F,X
305- F0 07 BEQ
$030E
307- 20 ED FD JSR $FDED
30A-
E8 INX
30B- 4C 02 03 JMP $0302
30E-
60 RTS
30F-
D4 ???
310-
D7 ???
311-
CD
CMP
312-
00 BRK
Ce programme charge dans X
la valeur 00, ensuite charge dans A
la
valeur se trouvant à l'adresse $030F + X, c'est-à dire
$030F, part l'afficher,
ajoute un à la valeur de X (INX incrémente un, et DEX
décrémente un à X) et
recommence jusqu'à ce que X soit égal à trois
auquel cas le programme vous rend
la main. On peut remplacer dans certains assembleurs la commande EQU
par =.
ASC est une commande assembleur qui dit à l'assembleur que ce
qui suit est une
chaine de caractères en codes Ascii.
Retour sommaire
Doc Merlin : full screen editor
*************************************************************************
*************************************************************************
*
*
*
MERLIN FULL SCREEN
EDITOR
*
*
*
*************************************************************************
*************************************************************************
*
*
*
Some details by NUMERO 6 from the
Village
*
*
*
*=======================================================================*
*
*
* To have the DOS 3.3 Full screen editor installed on
boot, load *
* the 'HELLO' program and make sure there is a line
like this : *
*
*
* nn PRINT CHR$(4)"BRUN
ED"
*
*
*
* SOURCEROR CAN be in memory at the same time
!!
*
*
*
*-----------------------------------------------------------------------*
*
*
* If you have : a 65802 in your
Apple
*
*
a 65816 (i.e. a APPLE ][
GS)
*
*
*
* then you can make use of the "ED.16" version of the full
editor *
* which is faster and has several extra features
:
*
*
*
* ctrl-O .......... insertion of
control
chars
*
* ctrl-S .......... shows length of
clipboard
*
*
*
* OA-left or rigth arrows ... moves
a page at a
time
*
*
*
* Ennnn ........... Enter full
screen at line
nnnn
*
*
*
* This version can also be used to transfer files between
DOS *
* and PRODOS : use OA-Q, then OA-C, boot up the other
version *
* of MERLIN PRO, and type
OA-P.
*
*
*
* OA-F, OA-W, OA-X .... when used
while a range is selected *
* by OA-C, only THAT range will be
searched.
*
*
*
*-----------------------------------------------------------------------*
*
*
* DO NOT use KEYMAC (instead of EDMAC) when ED is in memory
!!!! *
*
*
*-----------------------------------------------------------------------*
*
*
*************************************************************************
*
BONJOUR CHEZ VOUS... *
*************************************************************************
Retour sommaire
Doc Merlin : Full screen editor command summary
*************************************************************************
*************************************************************************
*
*
*
MERLIN FULL SCREEN
EDITOR
*
*
*
*************************************************************************
*************************************************************************
*
*
*
*
* Command summary
by NUMERO 6 from the
Village
*
*
*
*
*
* The command structure follows that of the standard
editor as *
* much as possible, but use the Open Apple (OA) key
as a prefix *
* instead of the Control
key.
*
*
*
*
*
* 1) CONTROL COMMANDS (line oriented and cursor
moves)
*
*
----------------
*
*
*
* ctrl-B .......... cursor to the
beginning of
line
*
* ctrl-N .......... cursor to end
of
line
*
* arrows .......... move
cursor
*
* escape .......... moves cursor to
start of next
line *
* ctrl-F .......... find char typed
next
(recursive
*
*
on the same line
only)
*
* ctrl-W .......... moves to next
word on the
line
*
*
*
* ctrl-D .......... deletes
character under
cursor
*
* Delete .......... deletes
character to left of
cursor *
* ctrl-Q .......... deletes all
chars from cursor to end of line *
* ctrl-R .......... retrieves
original
line
*
*
*
* ctrl-M (Return) . carriage return
AND insert new
line *
* ctrl-I (tab) .... toggles
character insert
mode
*
* ctrl-L .......... toggle lower
case convert
mode
*
*
*
* ctrl-S .......... shows memory
status
box
*
* ctrl-X .......... cancels global
exchange in
progress *
*
*
*
*
* ctrl-Y .......... sets a
marker
*
*
*
*
*
*
*
*
*
*
*
*
*
* 2) OPEN-APPLE COMMANDS (global
commands)
*
*
-------------------
*
*
*
* OA-arrows ....... fast
moves
*
* OA-B ............ go to beginning
of
source
*
* OA-N ............ go to end of
source
*
* OA-Y ............ go to marker
set by
ctrl-Y
*
*
*
* OA-D ............ deletes current
line (undo by OA-I, OA-R) *
* OA-Delete ....... deletes
previous
line
*
*
*
* OA-R ............ replace last
line deleted with current line *
*
*
* OA-Q ............ selects all
text from current line to end *
*
*
* OA-ctrl-I or OA-tab or OA-I ...
inserts new line at cursor *
*
*
* OA-C ............ cut to
clipboard
(twice)
*
* OA-P ............ paste clipboard
at cursor
line
*
*
*
* OA-F ............ find text
(recursive in all
source) *
* OA-W ............ find word
(recursive)
*
* OA-L ............ find label or
line
number
*
*
*
* OA-X ............ global
exchange
*
*
*
* OA-ESC .......... returns to
standard
editor
*
*
*
* OA-Z ............ reprint
screen
*
* OA-8 ............ line of
asterisks
*
* OA-9 ............ line of
boxes
*
* OA-- ............ line of
dashes
*
* OA-= ............ line of equal
signs
*
*
*
*
*
*
*
*
*
* 3) A FEW
EXPLANATIONS
*
*
------------------
*
*
*
* CUT & PASTE : OA-C starts
select
mode
*
*
make your selection using arrow
keys
*
*
(or OA-Q if you want everything to the end)*
*
OA-C again will cut the text on the clipboard *
*
*
*
OA-P pastes the content of the clipboard, WITHOUT *
*
modifying clipboard, so that this can be *
*
used to replicate a range of
lines *
*
*
*
*
*
*
* FIND TEXT : is only
cancelled by OA-B or
ctrl-S
*
*
*
* FIND LABEL : searches only in the
label
column
*
*
(you can type a number for the
label)
*
*
*
*
You can use 'markers' as "* 7" in start of a line *
*
*
* GLOBAL EXCHANGE : looks only for
full
words
*
*
<return> will defeat the
change
*
*
<space bar> will accept the
change
*
*
'A' will cause all occurences to be changed *
*
ctrl-X will abort the
process
*
*
*
*
*
*
*
* DELETE : the deleted lines are
placed in a special undo-buffer *
*
which is independant of the clipboard . The
OA-R *
*
command exchanges the current line with this buffer. *
*
(try : OA-D, some moves down, OA-TAB, then
OA-R) *
*
*
*
*
*
*
*
*
* You must quit the screen editor
in order to use ASM command. *
*
*
*
*
*
*
*
*
*************************************************************************
*
BONJOUR CHEZ VOUS... *
*************************************************************************
Retour sommaire
Doc Merlin : Sourceror
*************************************************************************
*
*
* POURQUOI UN SOURCEROR 65C02 MODIFIE
???
*
*
*
*
by Numero 6 from the
Village *
*
*
*************************************************************************
*
*
*
*
* 1) vous n'avez pas d'Apple ][ GS (pas encore!)
:
*
*
*
*
Le seul interet que presente pour vous ce 'SOURCEROR *
*
revisited ' est de vous permettre de
desassembler *
*
du code 65C02 sans avoir a modifier une copie de
la *
*
ROM F8 en carte langage (gare aux 8O colonnes!),
ou *
*
sans avoir a lancer un second programme,
apres *
*
Sourceror, tel MON65C02
.
*
*
*
*
En resume, vous faites 'BRUN NEW.SOURCEROR', et
le *
*
tour est
joue.
*
*
*
*
*
* 2) vous avez un APPLE ][ GS
:
*
*
*
*
Le probleme est simple : SOURCEROR ne marchait pas ! *
*
*
*
NEW.SOURCEROR incorpore simplement les routines
de *
*
desassemblage necessaire (plus quelques
autres *
*
indispensables) et ca
marche.
*
*
*
*
*
* 3) un petit conseil, si je peux me permettre
:
*
*
*
* MERLIN 816 arrive bientot et c'est tant
mieux, meme si ce sera *
* une autre paire de manches
!
*
*
*
* Avec cette nouvelle version, un nouveau
SOURCEROR arrivera *
* probablement ; mais ... ne jetez pas votre
bon vieux MERLIN, *
* il sera sans aucun doute encore tres utile,
croyez moi . *
*
*
*
*
*************************************************************************
*
BONJOUR CHEZ VOUS ... *
*************************************************************************
Retour sommaire
Infos Crackware
La face cachee de Crackware par Max Headroom
Completee par The White Man
Fichier dedicace a The Jokersoft
En revenant de l'Apple Expo, je me suis rué sur mon apple //
pour essayer
Crackware. Horreur, enfer et damnation, sur le Brain Trust copy disk,
(qui plante au boot une fois sur deux sur mon //c 'The White Man') le
brainsmith
demande un password ... Je me suis donc mis a boot tracer .
Apres chaque commande, tapez return.
800: 00
801<800.BFFFM
J'aime travailler avec une mémoire propre...
1600<C600.C700M
16F8: 00
1600 G
Et tourne la galette (tm Max Headroom) C0E8 pour l'arreter.
800
801- 01
Un seul secteur charge au boot ...
801LLLL
On jette un oeil sur le boot.
08A5- JMP $B600
Là, ça devient très intéressant...
Deuxieme etape du boot tracing:
16F8: A9 00 8D A5 08 4C 01 08
En clair :
16F8- LDA #$00
STA $08A5
JMP $0801
1600G
Et quelques secondes apres, le doux bruit d'un plantage vous chatouille
les
oreilles ...
B600LL
D'abord diverses petites routines et en $B61D la fameuse routine
d'attente
de touche du menu. Comment ca marche ??? D'abord on attend une touche,
ensuite on compare la touche avec une table en $BBE0. J'ai jette un oeil
sur cette table : il y a effectivement les 10 touches de 1 a 0 mais
aussi
2 codes suplementaires ... Pendant le menu, amusez vous a taper soit _,
ou ) ou delete ( he oui , ils ont ose ... ). Bon, apres cette
parenthese,
revenons a notre menu. Selon la touche tapee, la routine met certains
parametres en place ( ne vous inquietez pas pour le JMP $C600 en $B66A
) et
entre autre, elle modifie ce fameux JMP $C600. Ensuite elle saute
à la
routine de chargement et saute au debut du programme demande...
Je ne me suis pas amuse a comprendre a quoi servent tous ces parametres,
il y a beaucoup plus simple :
B66A: 00
De cette façon, tout se chargera et nous redonnera la main au
moment de
sauter au programme. Donc :
B600G
On se retrouve sous le menu. La , on tape 9 pour charger le brainsmith
et
hop, un tres joli plantage vous rend la main.
B66A: 4C
B66AL
B66A- JMP $2DD0
Le menu saute donc apres en $2DD0, adresse de chargement du brainsmith.
2DD0L
En 2DD0 il y a d'abord diverses routines (vectorisation du reset ,
affichage
de la presentation). En $2DFC l'on trouve une tres jolie serie de tests
de
touche. C'est la demande de password... Elle fonctionne d'une facon tres
simple : elle attend une touche et quand vous tapez la bonne touche
elle passe
au test suivant qui fait exactement la meme chose et cela 6 fois de
suite.
Donc il vous suffit de taper 6 fois toutes le touches de votre clavier
pour
passer la demande de password. Le password est donc contenu
dans ces tests de touche. Vous vous armez d'un papier et d'un crayon et
vous
allez donc noter les 6 caracteres que l'on retrouvent dans les
comparaisons
(juste apres les CMP). Des que vous avez ces codes, vous allez jetter
un oeil
dans une table des codes ASCII et vous trouvez CCLOPT . Ce qui
correspond a :
C aptain Crack
C opperfield
L oockheed
O liver Twist
P atchman
T he Jokersoft
Vous pouvez soit utiliser ce password, soit le shunter. Pour cela il
vous suffit
de noter les codes hexa du debut de la demande de password et de faire
une recherche
sur disk avec Anstrom 2.3 par exemple (salut Pad)... Des que vous avez
trouve la
piste et le secteur (je vais quand meme pas tout vous dire), vous
pouvez mettre a
la place une petite routine qui affiche un message comme je l'ai fait
(NO PASSWORD
VERSION BY MAX HEADROOM) ou simplement un saut a la suite du
programme...
Demerdez vous, ça c'est plus mon probleme ... Avis au
namekillers, si vous ne
connaissez pas le royal (comme au mac donald)
shit hackerforce, amusez vous a
changer ce que j'ai fait et je vous promet de vous batir une sacre
reputation
(je reconnaitrai mon boulot, soyez en sur ) ...
Max Headroom dans ses délires
Retour sommaire
Introduction Assembleur Mode d'Emploi 2
INTRODUCTION,
Ces cours d'assembleurs sont
(je le pense assez clairs pour quelqu'un
qui n'y connait rien) réservés en particulier aux
débutants. Un grand programmeur
n'y trouvera pas son bonheur.
Ces cours reposent en grande
partie sur le graphisme et j'y ai ajouté
un cours sur les pages graphiques de CRICK, qui à mon avis est
très bien fait.
Cette disquette contient le
premier lecteur de fichier en DHGR réalisé
par THE MONZ.
Si vous vous posez des
questions posez-les aussi dans la bal
HACKERFORCE, HACKERCHEST, FLYNN'S (MAX HEADROOM), THEMONZ, THE WHITE
MAN (36-14
code:135060318*RTEL) et nous vous aiderons.
-------------------------------------------------------------------------------
Hackerforce à ouvert
une centrale d'achat qui marche très fort (genre
THE BLACK CHEST) pour avoir des renseignements laissez vos
coordonnées en bal:
HACKERCHEST et nous vous contacterons.
-------------------------------------------------------------------------------
Big HELLLLLLLLOOOOOOO TO:
THE BRAIN TRUST (je sais qu'il sont encore dans les parages)
THE WARRIORS OF DESTINY
MV GANG
CRICK
PHOENIX CORPORATION
DOX A GAZ'S TEAM
GODFATHER
Retour sommaire
Assembleur Mode d'Emploi 2 partie 1
-------------------------------------------------------------------------------
! ASSEMBLEUR MODE D'EMPLOI
2
PART1
BY THE WHITE MAN !
-------------------------------------------------------------------------------
------------------------
! PILE ? WONDER FULL !
------------------------
Nous avons vu la
dernière foie que l'instruction JSR
permettait
d'effectuer un saut à un sous-programme, et lorsque ce
sous-programme
rencontrait un RTS, le programme principal continuait son chemin.
Exemple:
ORG $300
LDA #$C1
JSR $FDED
LDA #$C2
JMP $FDED
Equivalent hexadécimal:
300ºA9 C1 20 ED FD A9 C2 4C ED FD
Ce programme charge dans A
la valeur $C1 (caractère A en ascii), part
en sous-routine d'affichage (JSR $FDED), rencontre dans cette
sous-routine un
RTS, revient à notre programme, et affiche un B. Nous aurions pu
écrire
...
LDA #$C2
JSR $FDED
RTS
Mais pourquoi revenir
à notre programme pour en revenir tout de suite ?
Si nous effectuons un JMP $FDED, ce sous-programme se terminant par un
RTS, l'
Apple nous redonne la main automatiquement. Vous n'avez pas bien saisi
? Je ne
recommencerai pas, il vous suffit de relire ces lignes
précédentes et si vous
ne comprenez toujours pas laissez tomber l'assembleur. Gniak gniak.
Ce chapitre se nommant pile
et autres aneries, il faudrait peut-être en
toucher un mot !
Donc, vous avez compris, le
JSR, le RTS ou quelque chose dans le genre
doit savoir où reprendre le programme lorsque le sous-programme
est terminé.
C'est là qu'intervient cette pile, appelée STACK en
anglais que
les
programmeurs Forth doivent connaitre comme leur poche.
La pile utilise la structure
LIFO (Last in-First out ou Premier entré,
dernière sorti). L'exemple que tout le monde s'accorde à
trouver le meilleur
est celui de la pile d'assiette. Si vous posez une assiette rouge, puis
une
bleue dessus, la première ressortie (à moins que vous ne
soyez un etre vicieux
qui cherche la complication) sera la dernière empilée,
c'est à dire la bleue.
Ceci est un principe très simple qui est repris par le 6502
comme moyen pour
retrouver l'adresse de retour de sous-programme. Le 6502 sait toujours
à quelle
adresse il se retrouve grace à l'emploi du program counter ou
PC. Le program
counter est le seul registre de 16 bits du 6502 et contient en
permanence l'
adresse sur deux octets de l'instruction à exécuter.
C'est dans la pile que le
6502 va stocker l'adresse de retour de sous-programme lors d'un
éventuel JSR,
la pile allant de l'adresse $100 à l'adresse $1FF. Le premier
emplacement
mémoire de la pile est $1FF, mais plutot que de pousser les
valeur vers $100 à
chaque empilage, il a été créé un pointeur
de pile. Vous allez devenir fous, je
sais mais tout ceci est nécessaire pour la bonne
compréhension du problème
qu'est l'appel à un sous-programme. A chaque nouvelle valeur, le
pointeur de
pile ou stack pointer est replacé afin d'indiquer la position de
cette valeur.
Considérez ce petit
programme:
ORG $300
DEBUT JSR $FC58
LDA $00
STA $2FF
JSR $FDDA
LDA #$A0
JSR $FDED
LDA $2FF
JMP $FDED
Equivalent hexadécimal:
300: 20 58 FC A5 00 8D FF 02 20 DA FD A9 A0 20 ED FD AD FF 02 4C ED FD
Il se contente de nettoyer
l'écran (JSR $FC58), d'afficher la valeur se
trouvant à l'adresse 0 (JSR $FDDA) après l'avoir
stockée en $2FF, afficher un
espace (LDA #$A0) et reprendre la valeur pour l'afficher sous forme
de
caractère Ascii (JMP $FDED). Cela nous oblige à utiliser
une adresse de
stockage temporaire en $2FF qui nous prend de la place et nous fait
perdre du
temps. Ce n'est pas avec le programme que je vais vous donner
ci-dessous que
vous allez vous apercevoir du temps gagné car cela se mesure en
millisecondes,
mais sachez que dans un long programme, cela peut avoir beaucoup
d'importance.
ORG $300
DEBUT JSR $FC58
LDA $00
PHA
JSR $FDDA
LDA $A0
JSR $FDED
PLA
JMP $FDED
Equivalent hexadécimal:
300: 20 58 FC A5 00 48 20 DA FD A9 A0 20 ED FD 68 4C ED FD
L'instruction PHA que nous
voyons pour la première fois place sur la
pile la valeur de A. C'est tout, et très pratique. Car la pile
peut nous servir
de stockage temporaire. Le tout est de dépiler ce qu'on a
empilé, et ceci se
produit par l'intruction PLA.
C'est donc l'adresse de
retour qui est empilée grace à l'intruction JSR.
Si pendant un sous-programme, vous empilez d'autres valeurs sur la
pile,
assurez-vous de dépiler absolument avant d'exécuter un
RTS! Par exemple, si l'
adresse de retour est $302, que dans le sous-programme vous emplilez
deux fois
la valeur $20 et que vous exécutez un RTS sans dépiler,
votre adresse de retour
sera considérée comme étant $2020, ce qui est pour
le moins génant! Mais
lorsque l'on maitrise parfaitement la pile, on peut s'amuser avec
cette
caractéristique et employer des ruses de programmation qui
permettent de gagner
un temps fou.
Le programme suivant
illustre ce que je viens d'expliquer:
ORG $300
JSR ESSAI
RTS
ESSAI LDA #$20
PHA
PHA
RTS
Equivalent hexadécimal:
300:20 04 03 60 A9 20 48 48 60
Il serait judicieux de
mettre un RTS en $2020 (2020:60) avant
d'
exécuter le programme afin d'éviter un éventuel
plantage. Vous pouvez y mettre
00 pour vérifier que le programme y va effectivement.
Note de DCKD (24/12/2004): le PC contient l'adresse de la prochaine
instruction -1.
Comme on a empilé $2020, le programme va donc sauter à
l'instruction $2021 au RTS
du sous programme ESSAI. Pour éviter le plantage, mettre un 60
en $2021 et pas $2020.
-----------------
! BREAK ET PC !
-----------------
Si vous avez fait tourner le
programme ci-dessus en mettant la valeur 00
en $2020, vous vous etes peut-etre aperçu que le programme
s'arretait, et vous
affichait des chiffres bizarres. Par exemple, vous pourriez obtenir
ceci:
0306- A= 00 X= 1D Y=
34 P= B0 S= F6
1e COL 2e COL 3e COL 4e COL
La première colonne
est en fait l'adresse que contient le PC (compteur
ordinal), qui est comme je l'ai précédemment
écrit, l'adresse de la prochaine
instruction à exécuter. Lors d'un break, ce qui est
affiché est l'adresse où se
trouvait le break+2. Je vous expliquerai pourquoi plus tard, mais ceci
est très
utile pour "débugger" vos programmes (éliminer les fautes
de programmation),
car le fait d'insérer des breaks de temps en temps aide à
suivre le déroulement
pas à pas. Les trois autres colonnes correspondent aux valeurs
contenues dans
les registres A, X et Y, et il est aussi très important de
pouvoir lire ces
valeurs pendant un débuggage. Nous ne verrons pas pour l'instant
la
signification des deux auttres colonnes qui sont plus
compliquées à interpréter
Voilà, vous avez de quoi planter votre Apple en beauté,
amusez-vous.
Retour sommaire
Assembleur Mode d'Emploi 2 partie 2
-------------------------------------------------------------------------------
! ASSEMBLEUR MODE D'EMPLOI
2
PART2 BY
THE WHITE MAN !
-------------------------------------------------------------------------------
Vous etes créateur de
programme, et comme tout le monde vous avez fait
vos premiers pas avec le BASIC. C'est bien bien, c'est chouette, on se
marre,
mais c'est quasiment aussi lent qu'un escargot.
Je suppose que vous vous
posez la question suivante: comment adapter le
mini-programme BASIC suivant ?
10 HOME
20 PRINT "SALUT LES MECS"
30 PRINT "CE PROGRAMME INUTILE EST VACHEMENT BALEZE"
Je vous vois venir, la tete
enfarinée. Quel est l'interet de
l'
assembleur pour des programmes aussi cons? Alors là, je dis
"stop, halte".
L'impression de chaines de caractère à l'écran est
la base de tout
bon
programme. Il n'existe pas un seul bon jeu qui se respecte sans cette
désormais
célèbre routine de PRINT que nous allons
décortiquer un peu plus loin.
Auparavant, je vais vous
faire repasser quelques notions en revue.
Inutile de revenir sur la
routine COUT (adresse $FDED). Quelqu'un a
crié "SI!!" ?? Ok, j'y reviens. En deux mots, ce sous-programme
fixe dans le
moniteur de l'Apple se tape tout le boulot d'affichage des
caractères. Pour l'
utiliser, on place dans l'accumulateur le code ASCII de la lettre
à afficher.
Ensuite, c'est tout bénéfice pour nous autres feignants,
car COUT s'occupe de
gérer la position du curseur sur l'écran, de placer la
lettre et ça baigne.
Bien. En
résumé voici comment j'affiche un Q sur l'écran.
(J'aurais pu
prendre un A mais un Q n'a jamais fait de mal à personne).
ORG $300
LDA #$D1
JMP $FDED
Equivalent hexadécimal:
300: A9 D1 4C ED FD
On vous a tellement
seriné ce principe dans divers cours d'assembleur
que ce doit etre du gateau pour vous, mes petits bichons. Dès
lors, comment
afficher une chaine de caractères ? Rien de plus simple,
reportez-vous au cours
d'ASSEMBLEUR MODE D'EMPLOI 1 PART4.
Pourtant, ce que je veux
faire (et je vais y arriver) c'est écrire un
sous-programme d'affichage utilisable à n'importe quel moment
à l'interieur d'
un autre programme. En PASCAL, on appellerait ça une
Procédure, en assembleur
une sous-routine, mais ce ne sont que des mots.
Pour cette recette du jour
que nous allons intituler PRINT (vachement
original comme nom), nous avons besoin d'un pointeur, du sous-programme
COUT,
et de la pile. Accrochez vous à vos basquettes, voilà le
source:
PTR= $46
COUT= $FDED
ORG $300
DEBUT JSR PRINT
ECRIT ASC "SALUT LES MECS"
HEX 8D00
JSR PRINT
ENCORE ASC "CE PROGRAMME EST VACHEMENT BALEZE"
HEX 8D00
STOP RTS
PRINT PLA
STA PTR
PLA
STA PRT+1
LDY #$01 ;
note DCKD (24/12/2004): car PC=adr-1 (CQFD)
SUITE LDA (PTR),Y
BEQ FIN
JSR COUT
INY
BNE SUITE
FIN CLC
TYA
ADC PTR
STA PTR
LDA PTR+1
ADC #$00
PHA
LDA PTR
PHA
RTS
Et maintenant la meme chose en hexadécimal:
300:20 3A 03 D3 C1 CC D5 D4
308:A0 CC C5 D3 A0 CD C5 C3
310:D3 8D 00 20 3A 03 C3 C5
318:A0 D0 D2 CF C7 D2 C1 CD
320:CD C5 A0 C5 D3 D4 A0 D6
328:C1 C3 C8 C5 CD C5 CE D4
330:A0 C2 C1 CC C5 DA C5 8D
338:00 60 68 85 46 68 85 47
340:A0 01 B1 46 F0 06 20 ED
348:FD C8 D0 F6 18 98 65 46
350:85 46 A5 47 69 00 48 A5
358:46 48 60
Ceci nécessite
quelques commentaires. Les outils tout d'abord: PTR est
un pointeur temporaire, c'est à dire une case qui nous permettra
de stocker des
valeurs et de les retrouver facilement car nous sommes très
brouillons.
Dès le début
du programme, nous sautons en sous-routine PRINT, et
là
que se passe-t-il ?
Nous tirons de la pile (PLA)
l'adresse de départ de la chaine
à
afficher. Ici, c'est l'adresse de ECRIT-1. Nous stockons cette adresse
dans le
pointeur. Comme une adresse comporte toujours deux octets, cette
opération est
répétée deux fois de suite. Pour résumer ce
point de brume, l'adresse de
ECRIT-1 se trouvera en PTR et PTR+1 ($46 et $47).
Suite à cela, on
utilise le registre Y en lui donnant la valeur 01. Ce
registre va nous servir de compteur de chaine. On pénètre
alors dans l'
intéressante boucle ci-dessus nommée SUITE. Ici, par le
principe de l'adressage
indirect indexé, on va chercher une à une les lettres de
ma phrase. Comment se
peut-il que cela se fasse ? C'est simple. L'adressage indexé en
page
zéro met dans l'accumulateur la valeur se trouvant à
l'adresse indiquée par le
pointeur (PTR) plus la valeur de Y. En l'occurence, on met dans le
pointeur l'
adresse $302. Sachant que Y=1, la valeur chargée dans
l'accumulateur sera celle
se trouvant en $302+Y soit $303. Et là, merveille, on trouve
sous ses yeux
ébahis, la première lettre (sous forme de code ASCII) de
ma phrase à afficher.
On verifie si cette valeur ne serait par (par hasard) un zéro,
(BEQ FIN).
Auquel cas, on s'empresse de filer en sortie de programme. En effet,
vous
noterez qu'on a pris soin de faire suivre chacune des phases des
valeurs
suivantes: 8D 00. Le 8D est le code ASCII du retour chariot (RETURN).
Ce qui
signifie qu'on va à la ligne, et le 00 annonce la fin de la
phrase. Tant qu'il
n'y a pas de 00 dans l'accumulateur, la boucle SUITE affiche tout ce
qui lui
tombe sous le main.
Après chaque
affichage de caractère, on incrémente Y et on retourne
en
SUITE. Par conséquent on placera dans l'accumulateur la
prochaine lettre de ma
phrase. Prenez trois aspros et relisez tout ça au calme.
Vous noterez que ce principe
nous limite à un affichage maximun de 255
caractères. En effet, si Y atteint la valeur 255, en
l'incrémentant encore, il
reprendra la valeur 00. Dans ce cas, la routine recommencerait à
afficher la
chaine sans s'arreter. Pour éviter cela, on compare Y à
00 (BNE SUITE). Si Y
prend cette valeur de 00, le programme va automatiquement en FIN.
Note de DCKD (24/12/2004): Y commence à 1 et il faut
obligatoirement un 00 à la
fin, ce qui fait une chaine de 254 caractères maximum retour
chariot inclus et non
pas 255.
Voyons maintenant ce qui se
passe dans cette partie FIN. En premier
lieu, on met la retenue à zéro, ce qui laisse
présager une addition proche. On
transfère ensuite la valeur de Y dans l'accumulateur. A ce
moment-là, Y est
égal au nombre de signes de ma phrase + 1. Dans mon pointeur,
j'ai toujours l'
adresse de départ de ma phrase (ECRIT-1). En ajoutant à
cette adresse la valeur
de Y, on va automatiquement trouver l'adresse de la fin de ma phrase.
Ce qu'on
veux obtenir c'est qu'après l'affichage, le programme reprenne
son cours non
pas à la suite de notre JSR PRINT mais à la suite de la
fin de ma phrase.
Après un JSR, le
microprocesseur va chercher sur la pile l'adresse de
retour. C'est donc en falsifiant cette adresse qu'on peut le
piéger. En l'
occurence on va lui donner l'adresse de fin de phrase. Pour cela on
remet sur
la pile les deux valeurs du pointeur incrémentées de la
longueur de la chaine.
C'est à la fois simple, compliqué et vachement
rusé.
L'intéret de cette
routine PRINT est qu'elle est relogable
très
facilement et utilisable à n'importe quel moment dans n'importe
quel programme.
La règle à respecter pour afficher une phrase sera donc
la suivante:
JSR PRINT
ASC "LA CHAINE A AFFICHER"
HEX 8D00
La chaine doit
IMPERATIVEMENT se terminer par un 00 sinon c'est
le
plantage assuré.
Vous pouvez utiliser PRINT
dans tous vos programmes nécéssitant de l'
affichage. Mais si vous pensez que c'est son seul avantage, vous vous
mettez
le connecteur dans l'oeil jusqu'au lecteur de disquettes. En effet
(mais il nous
fait chier avec ses en effet), cette routine est également
utilisable avec les
commandes du DOS 3.3. Ce qui est fort excitant, convenez-en. Vous
pourrez donc
envoyer des commandes en simulant le PRINT CTRL-D du BASIC suivi de
l'énoncé de
la commande en n'oubliant pas d'ajouter un retour chariot et un
zéro.
Ne vous réjouissez
pas trop vite, possesseur de PRODOS. Cette façon de
faire ne lui plait pas du tout, et il se plantera en beauté.
Sachez tout de
meme que l'appel de commandes PRODOS est très simple, mais nous
verrons ça
quand j'aurai moi-meme compris.
Retour sommaire
Assembleur Mode d'Emploi 2 partie 3
-------------------------------------------------------------------------------
! ASSEMBLEUR MODE D'EMPLOI
2
PART3
BY THE WHITE MAN !
-------------------------------------------------------------------------------
Bonjours à tous les
mécanos de l'octet, du bit à vapeur et
du
microprossesseur nucléaire. Ce fichier marque un tournant
décisif dans votre
vie, puisque j'ai décidé moi-meme personnellement de vous
révéler les détails
de ce qui vous passionne tous: le GRAPHISME haute résolution
(HGR). J'en vois
déjà qui se mettent à tablette graphique ou leur
souris. Du calme. Commençons
par le commencement. Tout d'abord un poil de théorie. Ca n'a
jamais fait de mal
à personne surtout un poil de C.......... de Chien ou de Chat
mais il parait
qu'il y en a qui sont allergiques. Je vous parlerai d'abord de la
représentation
de la page graphique. Mais qu'est-ce qu'une page graphique ?
Excellente
question. La page graphique est une zone de la mémoire vive
réservée
au
stockage des informations qui seront envoyées sur l'écran
par le circuit vidéo.
Cette zone mémoire est fixe sur l'Apple // et se trouve
située de l'adresse
$2000 à l'adresse $3FFF. On l'appelle "première page
haute résolution". Pas
radin pour deux sous, les concepteurs d'Apple ont doté leur
machine d'une
seconde page graphique qui suit la première et qui se trouve
(par conséquent)
placée de l'adresse $4000 à l'adresse $5FFF. Bon. Nous
avons donc deux pages
graphiques, mais comment s'en servir ? je répondrai : le plus
simplement du
monde ! Il existe des commutateurs à l'intérieur de
l'Apple. Il suffit de
basculer le bon pour faire apparaitre la page graphique
désirée, ou le texte.
Oui mais pardon, me
rétorquerez-vous, où se trouvent ces commutateurs,
et dois-je faire sauter le capot de mon Apple chaque fois que je veux
dessiner?
Non, il suffit, lors de la pleine Lune, de planter deux aiguilles
à cinq
centimètres de la touche RESET pour un //c et trois et demi
centimètres de la
touche ESC pour les //e.
Les commutateurs en question
ne sont pas des interrupteurs "physique",
mais softs (logiciel). En l'occurence, ce sont donc des cases
mémoires d'un
type particulier : il suffit d'envoyer n'importe quelle information
dans ces
cases pour qu'elles agissent comme un commutateur. Vous ne me croyez
pas ? Ok,
faites l'essai immédiatement.
Allumez votre Apple
préféré et passer illico dans le moniteur en
tapant
"CALL-151". C'est fait ? Bien. Tapez maintenant : C050 return. Alors ?
Alors ?
Si tout se passe bien, vous obtenez une image purement
surréaliste
ne
correspondant à rien. Quoi, qui a dit Picasso ? Qu'il se
dénonce. Tapez ensuite
C057 return. Puis C055 return et C054 return puis enfin C051 return. Ah
! Il va
s'en passer des choses sur votre écran. Ne faites jamais C999
return c'est très
dangereux, il fait fondre l'Apple. Où en étais-je, ah
oui, sur votre écran,
c'est le souk, l'enfer, la Bérésina ! Ne vous
affolez pas, vous venez juste de
faire joujou avec quelques uns de ces précieux commutateurs dont
je vous ai parlé
plus haut.
Après les avoir
tripatouillé (les commutateurs), je vais vous
les
montrer de plus près (toujours les commutateurs) et vous
expliquer leur utilité
particulière (encore et toujours les commutateurs).
- C050 permet de
passer en mode graphique.
- C051 nous met
en mode texte. C'est l'un ou l'autre qui est activé.
- C056 affiche la
basse résolution (c'est caca).
- C057 affiche la
haute résolution (c'est Xtra).
- C054 affiche la
première page.
- C055 affiche la
seconde page.
- C053 laisse 4
lignes de texte en bas de la première page
haute
résolution.
- C052 supprime
les 4 lignes de texte en bas de cette meme page.
Vous n'imagez pas le nombre
d'astuces possibles avec ces commutateurs.
On peut faire toutes sortes de choses, et on ne va pas se gener, vu
qu'on est
là pour ça. Je vous invite à réaliser
immédiatement tout de suite une animation
qui en mettra plein les mirettes à votre petit neveu de huit ans
qui fait des
merveilles avec son ZX et ça commence a vous filer des
complexes, c'est vrai
quoi merde, avec un Apple à 11000 balles (il y a cinq ans
environ), on doit
pouvoir frimer de temps en temps.
Marche à suivre: dans
un premier temps, il s'agit de réaliser
deux
dessins avec un utilitaire quelconque. Je vous entends d'ici: si son
cours sur
le graphique se résume à nous conseiller BLAZZING PADDLE
ou MOUSE PAINT, il
peut se le rouler en pointe et le glisser jusqu'au fond de son lecteur
de
disquettes. Calmez-vous ou je me fache à mon tour. Nous
décortiquerons le
graphique comme les homards un soir de Noel. Nous apprendrons à
faire de
l'animation et toutes ces sortes de choses. Mais pour l'heure (il est
23h34) je
cherche à vous aguichez en vous montrant quelques
possiblilités excitantes. Or
donc, commencez facile: avec un joystick ou une souris, réalisez
une tete
simple et souriante, puis sauvegardez ce premier dessin. Ensuite,
reprenez le
meme dessin, et modifiez simplement la bouche, par exemple, pour en
changer la
physionomie. Sauvegardez ce second dessin. Cela dit et ceci fait
éteignez tout
et laissez refroidir. Quelques secondes plus tard, rallumez et c'est
reparti.
Dès lors procédez de la façon suivante:
- CALL - 151 (vous entrez dans le moniteur)
- BLOAD (nom de votre premier dessin),A$2000 (vous le chargez dans la
première
page graphique)
- BLOAD (nom de votre second dessin),A$4000 (vous le chargez dans la
seconde
page graphique)
Le plus dur est fait.
Maintenant, en place pour le quadrille. A vos
claviers, et tapez ce qui suit:
C057 (return): vous etes en haute résolution.
C050 (return): vous passez en graphique. Le premier dessin apparait!
(joie!)
C052 (return): les quatres ligne de textes disparaissent.
Désormais, vous tapez
sans rien voire.
C055 (return): la deuxième page graphique apparait. La tete
change d'expression
Tout baigne.
Après ces
premières manipulations, nous allons écrire un small soft
(en
français un 'petit programme'), very easy (en français
'vachement facile'). En
voici le listing (en français 'la liste'):
ORG $300
BIT $C050
BIT $C052
BIT $C057
BOUCLE BIT $C054
LDA #$D0
JSR $FCA8
BIT $C054
LDA #$D0
JSR $FCA8
LDA $C000
BPL BOUCLE
RTS
Voici les codes
hexadécimaux de ce petit programme placé en $300:
300: 2C 50 C0 2C 57 C0 2C 52 C0 2C 54 C0 A9 D0 20 A8 FC 2C 55 C0 A9 D0
20 A8
FC AD 00 C0 10 EB 60
Entrez ce programme et tapez
300G. Pour l'arreter, il suffit de taper
une touche. Vous venez de découvrir les joies du 'flipping' qui
est l'une des
techniques souvent utilisées pour réaliser des animations
simples. On fait
apparaitre alternativement l'une ou l'autre des pages graphiques
à l'écran.
Vous noterez, observateur comme vous l'etes, que j'ai eu recours
à une sous-
routine du moniteur. Je fais deux fois appel à celle-ci: JSR
$FCA8. Il s'agit
simplement d'une boucle de temporisation qui retarde le passage d'une
page à l'
autre. Si je la supprimais, la bascule serait beaucoup trop rapide
(nous sommes
en language machine !). Pour utiliser cette sous-routine
dénommée WAIT, il faut
mettre dans l'accumulateur A une valeur entre 00 et #$FF (255) avant de
l'
appeler. Plus cette valeur est élevée, et plus la boucle
de temporisation sera
longue. Faites des essais en la modifiant. Ici, j'ai pris #$D0 qui
permet d'
obtenir une bonne animation.
Bien je fais un
résumé rapide de la situation: l' Apple possède 2
modes
d'affichage qui sont le graphisme ou le texte. Dans les deux cas, on
peut
afficher l'une ou l'autre des deux pages mémoires (il y a 2
pages de texte et 2
pages graphiques). Pour cela il suffit de basculer des commutateurs
logiciels
ou (softs). N'importe quelle opération de lecture ou
d'écriture suffit
à
activer ces commutateurs. Ici j'ai utilisé BIT, j'aurais pu
mettre LDA ou STA.
Entrainez-vous à
flipper comme des malades.
Retour sommaire
Assembleur Mode d'Emploi 2 partie 4
-------------------------------------------------------------------------------
! ASSEMBLEUR MODE D'EMPLOI
2
PART4 BY
THE WHITE MAN !
-------------------------------------------------------------------------------
Cette fois ci, je vous
balance le doigt dans un drole d'engrenage: la
structure graphique de l'écran Apple. Allons-y donc bille en
tete. L'écran
haute résolution est composé de 192 lignes de 280 points.
Au total, c'est plus
de 53000 points qui sont gérés dans l'une ou l'autre des
pages graphiques. On
pourrait penser qu'à chaque point de l'écran est
allouée une case mémoire. Si
c'était le cas, il faudrait donc 53000 octets soit plus de 50Ko
pour une seul
page. Bonjour les dégats. Comment cela se passe-t-il donc ?
Simplement: un
octet étant composé de 8 bits, à chacun de ces
bits on fera correspondre un
point sur l'écran. Ah bon! Chouette, j'ai tout compris: si le
bit est à 1, le
point est allumé et si le bit est à 0, le point est
éteint. C'est juste! Et
avec un seul octet, je peux allumer ou éteintre 8 points sur
l'écran! C'est
FAUX! Eh oui..... le grand bordel commence. Avec un octet, on ne
peut gérer
que 7 points sur l'écran. Le huitième bit n'apparait pas,
et il sert
à
déterminer la couleur comme on le verra un peu plus loin.
Donc, pour me résumer
et vous permettre de reprendre votre souffle,
voici comment la bete se présente: chaque ligne est
composée de 280 points,
soit 40 octets puisqu'un octet gère 7 points. (40 * 7 = 280 pour
les nuls du
fond de la classe).
Fort de ce savoir tout neuf,
les plus vifs d'esprit d'entre vous en
auront déduit que 7680 octets sont mécessaires pour
gérer la page entière. Ils
ont parfaitement raison puisque 40 octets * 192 lignes nous donnent le
nombre
précité. 8 kilos! C'est le poids (en octet) d'une page
graphique! Pour que tout
soit bien clair entre nous, nous considérons donc à
présent qu'un écran est
composé de 40 colonnes de 192 octets.
Maintenant, il s'agit de
voir comment tout ça s'organise en mémoire. Et
puisque vous vous impatientez, allumez vos bécanes et tapez les
commandes
suivantes :
HGR (vous nettoyez l'écran).
CALL -151 (vous entrez dans le moniteur).
2000: 7F 7F 7F 7F 7F 7F 7F 7F (tapez 7F quarante fois de suite, puis
RETURN).
Emerveillement plein de
magie: une ligne blance apparait! C'est tout
con, comme ça, mais quand on le fait soi-meme de ses petites
mains, et qu'en
plus c'est du langage machine bonjour l'angoisse.
Ceci réclame quelques
explications. Pourquoi avoir choisi la valeur
#$7F ? Facile à piger, quand on regarde cette valeur
exprimèe en binaire :
01111111. Vous constatez de vous meme que dans 7F, 7 bits de l'octet
sont
positionnés à 1. Par conséquent, tous les points
d'écran correspondant à ces
bits vont s'allumer. Elémentaire mon cher klaxon (bit, bit !).
La bonne logique voudrait
donc que les 80 premiers octets de la page
graphique représentent exactement les deux première ligne
de l'écran. Pour le
vérifier, tapez:
2024: 7F 7F 7F 7F 7F 7F 7F 7F (etc...quarante fois de suite et RETURN).
Horreur, ce n'est pas la
seconde ligne qui vient de s'allumer, mais une
autre quelque part sur l'écran.
Alors là, je vais
etre à la fois bref, flou et net (balèze le mec)
en
meme temps. Pour des raisons d'économie (les cicuits
vidéo coutaient un max de
blé, mais il ne faut pas confondre avec un Max Headroom),
lorsque les
concepteurs ont conçu l'Apple, ils ont été
obligés d'adopter cette structure
qui fait que les adresses de lignes ne se suivent pas en
mémoire. C'est
partilièrement chiant, mais c'est comme ça. Faut faire
avec. Encore heureux,
les quarantes octets se suivent à l'intérieur des lignes
(mais il critique sa
bécane ou je réve).
Je vous entends d'ici dire:
"Ah! Si on avait continué à pratiquer
le
BASIC au lieu de se casser le tronc pour épater les copains, on
en serait pas
là. C'est vrai quoi! En BASIC, c'est vachement facile de faire
des HPLOT sans
s'occuper de ce qui se passe. L'ordinateur fait tout."
Il y a donc des
sous-routines dans le moniteur qui
calculent
automatiquement les adresses. Où c'est-ti-caisson ? J'y viens y
a pas le feu.
Pour allumer un point sur
l'écran sans se casser la binette: on peut se
servir de la sous-routine baptisée HPLOT ($F457). Avant de
l'utiliser, il faut
placer la coordonée Y du point dans l'accumulateur, la partie
basse de la
coordonnée X dans le registre X et la partie haute dans le
registre Y. En
assembleur, ça donnerait la chose suivante:
ORG $300
BIT $C050
BIT $C057
JSR $F3E2
LDX #$03
JSR $FCEC
LDA #$20
LDX #$06
LDY #$01
JSR $F457
RTS
Quelques commentaires
s'imposent: une fois passé en mode graphique (BIT
$C050) puis en haute résolution (BIT $C057), on procède
à un nettoyage de
l'écran (JSR $F3E2), on choisit la couleur du point (LDX
#$03 JSR $FCEC). Cela
fait, j'applique le principe cité plus haut pour allumer le
point 262 (106 en
héxadécimal) se trouvant à la ligne 32 (20 en
hexadécimal).
En réalité, ce
programme est inintéressant puisqu'il réutilise
des
routines déjà utilisées par le BASIC. Or, nous
avons décidé de faire mieux,
sinon c'est pas la peine de se creuser la tete à faire de
l'assembleur. Le
premier objectif est d'arriver à augmenter la vitesse des
routines du BASIC.
Pour allumer un seul point, elles assurent. Mais dés qu'on veut
traiter
beaucoup de données, c'est la galère. Elles sont lentes,
parce qu'elles
calculent l'adresse de l'octet à allumer CHAQUE fois qu'une
opération a lieu.
Pour accélérer ce processus, il faut donc créer
une table de toutes ces adresses
et la consulter plutot que de répéter des calculs. De
quoi ? Quelle table ?...
La table d'adresse de début de chaque ligne. En effet, avec 192
adresses, on
pourra situer n'importe quel point sur l'écran. Si, par exemple
je veux allumer
le premier point de la 3ème colonne à la ligne 0, il me
suffit de connaitre l'
adresse de début de cette ligne. En l'occurence (puisqu'il
s'agit de la
première ligne, l'adresse est: $2000). La troisième
colonne se trouve située 2
octets plus loin, soit à l'adresse $2002. Pour allumer le
premier point de
cette colonne il faudra que je donne une valeur hexadécimale
particulière à l'
octet se trouvant dans cette case mémoire. Pour cette exemple
précis, la valeur
en binaire sera 00000001 (puisque-je n'allume que le premier point).
Soit $01
en hexadécimal. Au lieu de faire des calculs complexes pour
savoir que le
premier de la troisième colonne se trouvera dans le
troisième octet de la ligne
concernée, il me suffit de connaitre l'adresse de cette ligne et
de l'
incrémenter.
En résumé:
pour toute opération rapide concernant le graphique
haute
résolution, il est indispensable de créer une table
d'adresse des 192 lignes de
l'écran.
La prochaine fois je vous
expliquerai comment créer cette table.
En
attendant, révisez ce que je viens de dire et essayer de vous
visser les
principes de graphique dans le crane.
Retour sommaire
Cours sur le mode graphique HGR
_
_
!_!_________________________________________________________________________!_!
!
!
!
LES PAGES GRAPHIQUES
HGR
!
!
ET LEUR
STRUCTURE
!
!
PAR
CRICK
!
_!_________________________________________________________________________!_
!_!
!_!
I) L'organisation des pages graphiques
--------------------------------------
La résolution normale des Apple II est de
280*192 pixels avec la possibilité
d'afficher simultanément 6 couleurs différentes (on ne
parlera pas de la double
haute resolution qui permet d'avoir une resolution allant
jusqu'à 560*192 pixels
en noir et blanc)
On dispose de 2 pages graphiques: l'une étant
située de l'adresse mémoire
$2000 à $3FFF, l'autre de $4000 à $5FFF (en
numérotation hexadécimale; en
numérotation décimale:8192-16383,16384-24575). Chaque
page fait donc une
longueur de $1FFF, soit environ 8192 octets.
Pour vous en convaincre, passez sous mode graphique
haute resolution (HGR),
puis sous le moniteur (call-151). Vous devriez observer une page noire
+ 4
lignes de texte. Comme tous les octets de $2000 à $3FFF servent
à coder cette
première page, si on en modifie un, alors on devrait observer
des changements
sur l'écran. Faisons en l'expèrience. Modifions la valeur
de l'adresse $2000.
Tapez donc:"2000:FF". Vous venez d'affecter la valeur $FF à
l'adresse $2000.
Immédiatement, on observe un segment blanc qui apparait en haut
à gauche,preuve
que $2000 sert bien à coder la page graphique.
Ces 2 pages peuvent etre affichées par simple
commutation (les commutateurs
permettent de changer de mode tout en preservant
l'intégrité des pages). Voici
une liste des principaux commutateurs:
Sous BASIC
Sous moniteur effet
---------------
------------- --------
POKE
-16304,0
$C050 active le mode graphique
POKE
-16303,0
$C051
mode texte
POKE
-16298,0
$C056
mode graphique basse resolution
POKE
-16297,0
$C057
mode graphique haute resolution
POKE
-16301,0
$C053
la fenetre texte
POKE
-16302,0
$C052 desactive la fenetre
texte
POKE
-16300,0
$C054 affiche la page 1
(graphique/texte)
POKE
-16299,0
$C055 affiche la page 2
(graphique/texte)
Donc, pour afficher la page graphique 1 sans détruire son
contenu, faites:
Poke-16304,0
Poke-16297,0
Poke-16300,0
Poke-16302,0 (pour avoir la page graphique en entière)
On peut également retourner au mode texte par: Poke -16303,0 (
et si utile,
Poke -16300,0)
NB: Il est à noter qu'il existe également deux pages
texte. Pour afficher la
deuxième page, il suffit d'utiliser le meme commutateur que
celui des pages
graphiques. Cependant, pour écrire dans la deuxième page
texte, cela nécessite
quelques astuces.
II) Codage d'un point
---------------------
Un groupe de 7 points graphiques est codés
par 1 octet d'une des pages
(d'où une ligne graphique est codée par 40 octets:
280/7). Par soucis d'économie
de la mémoire (8K seulement pour 1 page graphique), un octet ne
permet pas
d'afficher simultanément 7 points de couleur différente
cote à cote. En effet,
pour un groupe de 7 points à l'écran (codé par un
meme octet), on peut afficher:
-soit le groupe de couleur
Vert-Magenta (noir et blanc
sont
-soit le groupe de couleur
Rouge-Bleu
toujours affichables)
Par exemple, pour 7 points de l'écran CODES
PAR LE MEME OCTET:
-on peut afficher:
V M B un point vert, un magenta, et un blanc
Bl
R un point bleu, un rouge
-par contre, on ne peut
afficher:
V Bl
M un point vert, un bleu, un magenta
R
V un point rouge, un vert, un rouge
Cette contrainte est liée au codage particulier d'un point sur
l'écran; codage
que nous allons voir.
Le groupe de couleur pour UN octet codant est choisi
en fonction du bit 7 de
l'octet concerné:
bit 7=0 ==> groupe Vert-Magenta-Blanc-Noir
choisi pour les 7 points codés
bit 7=1 ==> groupe Rouge-Bleu-Blanc-Noir
choisi pour les 7 points codés
NB: le bit 7 est le bit le plus à gauche
Mettons par exemple le bit 7 de l'octet $2000
à 0. Examinons les effets à
l'écran lorsqu'on met les autres bit à 1:
bit: 7 6 5 4 3 2 1
0 écran: 0 1 2 3 4 5
6 adresse:$2000
0 0 0 0 0 0 0 1
(=$01) M ° ° °
° ° ° (pt 0 allumé en
Magenta)
0 0 0 0 0 0 1 0
(=$02) ° V ° °
° ° ° (pt 1 allumé en Vert)
0 0 0 0 0 1 0 0
(=$04) ° ° M °
° ° ° (pt 2 allumé en Magenta)
0 0 0 0 1 0 0 0
(=$08) ° ° ° V
° ° ° (pt 3 allumé en Vert)
0 0 0 1 0 0 0 0
(=$10) ° ° °
° M ° ° (pt 4 allumé en Magenta)
0 0 1 0 0 0 0 0
(=$20) ° ° °
° ° V ° (pt 5 allumé en Vert)
0 1 0 0 0 0 0 0
(=$40) ° ° °
° ° ° M (pt 6 allumé en Magenta)
NB:écran: 0 1 2 3 4 5 6 symbolise les 7 points de l'écran
codé par UN octet de
la page graphique.
On voit donc que seul les bit 0 à 6 de
l'octet servent à afficher 1 point
à l'écran. De plus, leur representation à
l'écran se fait de façon inversée:
le bit 0 code le point 0 du groupe concerné tandis que le bit 6
code le point 6.
Donc, si on veut afficher 1 POINT MAGENTA à l'écran, il
faut faire attention au
BIT 7, qui controle l'alternance des couleurs, et à son
EMPLACEMENT sur
l'écran: seul les COLONNES PAIRES sont susceptibles de
l'afficher (POUR UN
OCTET CODANT DE PARITE PAIRE). Si on prend un OCTET CODANT DE PARITE
IMPAIRE
($2001 par exemple), on obtient le meme resultat lorsqu'on met les bit
à 1, à
ceci près: l'ALTERNANCE DES COULEURS EST INVERSEE; le 1er point
n'est plus
Magenta mais Vert.
Exemple:
écran: 0 1 2 3 4 5 6 adresse:$2001
-------
V ° ° ° ° ° ° 0 0 0 0 0
0 0 1 (=$01)
° M ° ° ° ° ° 0 0 0 0 0
0 1 0 (=$02)
° ° V ° ° ° ° 0 0 0 0 0
1 0 0 (=$04)
NB: Si on met le bit 7 à 1, on n'obtiendra plus une alternance
Magenta-Vert,
mais une alternance Bleu-Rouge.
L'alternance de couleur pour un groupe de 7 points
codés suivant l'octet
se caractérise donc par:
écran:0 1 2 3 4 5
6
BIT 7
-----
OCTET PAIR M V M V M V
M
0 :alternance Magenta-Vert
---------- B R B R B R
B
1 :alternance Bleu-Rouge
OCTET IMPAIR V M V M V M
V
0 :alternance Vert-Magenta
------------ R B R B R B
R
1 :alternance Rouge-Bleu
NB: si on veut tracer un point blanc, il suffit d'allumer 2 pixels cote
à cote.
Si par exemple on allume les points 2-3, on n'obtiendra pas un point
magenta et
un vert (ou bleu et rouge) mais un point blanc:
écran: 0 1 2 3
4 5 6 adresse:$2000
° ° M V ° ° ° on n'observe pas un point
vert et un point
magenta cote à cote mais UN POINT BLANC
Si on desire tracer une ligne dans une couleur
précise, il suffit d'allumer
tous les pixels de meme couleur (donc, de meme parité de
colonne):
bit: 6 5 4 3 2 1
0
écran:0 1 2 3 4 5 6
1 0 1 0 1 0
1
* ° * ° * ° * (on observe une ligne
0 1 0 1 0 1
0
° * ° * ° * ° continue de couleur)
Cependant, faites attention aux octets de
parité impaire, la valeur qu'ils
contiennent n'est pas la meme que celle des octets paires à
cause de l'inversion
des alternances de couleur. Donc pour tracer de longues lignes, il faut
faire
la différenciation
Exemple
1er octet 2em
octet 3em octet
------- écran: 0 1 2 3 4 5 6!!0 1 2 3 4 5 6!!0
1 2 3 4 5 6
° * ° * ° * °!!* ° * ° * ° *!!° * °
* ° * ° 1 ligne colorée
______________!!_____________!!______________
valeur bits
0-6:_0_1_0_1_0_1_0!!1_0_1_0_1_0_1!!0_1_0_1_0_1_0_
=$2A
=$55
=$2A (bit 7=0 ici)
NB: si on desire obtenir une ligne blanche, il
suffit d'allumer tous les
pixels cote à cote:
bit: 6 5 4 3 2 1
0
écran:0 1 2 3 4 5 6
1 1 1 1 1 1
1
* * * * * * * (on voit 1 ligne blanche)
On comprend mieux maintenant pourquoi il est
impossible d'afficher (pour un
groupe de 7 points codés par le meme octet) du Vert avec du
rouge (alternance
des groupes de couleurs), et pourquoi on ne peut afficher 2 points de
couleur
différente cote à cote (obligation de les séparer
de 2 pixels: 0 pixel d'espace=1
point blanc, 1 pixel d'espace=1 segment continu de couleur uniforme).
Cependant en rusant un peu, on peut afficher 2
groupes de couleur différente
cote à cote: il suffit de les faire afficher par 2 octets
différents codant
deux groupes de 7 points cote à cote.
Exemple
------- adresse:
$2000
$2001
écran: 0 1 2 3 4 5 6!!0 1 2 3 4 5 6 on observe 1 point Vert
° ° ° ° ° V °!!R ° ° ° ° °
° et un rouge cote à cote
______________!!______________
valeur octet:(0)_0_1_0_0_0_0_0!!0_0_0_0_0_0_1_(1)
(bit 7 entre parenthèses)
=$20
=$81
III) Localisation sur l'écran
-----------------------------
La particularité des pages graphiques de
l'APPLE est que les adresses codant
la page graphique ne se suivent pas linéairement. En plus clair,
si la première
ligne de la page graphique débute en $2000, la seconde ligne ne
débute pas en
$2028 (une ligne est codée par 40 octets) comme on pourrait s'y
attendre. En
effet, celle-ci débute en $2400 !!
Donc, pour afficher un point sur la ligne 35,
comment faire pour retrouver
l'adresse correcte ? Il existe deux moyens pour cela:
-se répérer grace à un
"répertoire" donnant toutes les correspondances
lignes/adresses
-utiliser une routine toute faite qui calcule
ladite adresse
L'avantage de la 2em formule est évidente (gain de place).
Cependant, elle est
beaucoup plus lente que la première méthode. Donc, selon
les cas (besoin de
rapidité ou non), on pourra utiliser l'une ou l'autre
méthode.
1ère méthode
------------
on utilisera la table toute faite (fichier TABLE.S). La table
est prete à etre
reutilisée sous assembleur avec Merlin Pro Dos 3.3. Pour
exploiter la table, on
programmera de cette façon:
Ldy #(numéro de ligne)
Lda
ADB,Y
;adresse de bas poids
Sta tampon
Lda
ADH,Y
;adresse de haut poids
Sta tampon+1
Voila, tampon et tampon+1 contiennent l'adresse du début
de la ligne désirée.
Pour savoir ensuite quel octet modifié, il sufffit de faire une
division:
on prend la partie entiere de (n° de colonne / 7) et on
l'ajoute à l'adresse de
début de ligne ==> adresse finale
Exemple: on désire connaitre l'adresse du
début de la ligne 49, et l'octet à
modifier pour afficher un point en colonne 56. En utilisant les tables,
on
obtiendrait: tampon+1=>$24 tampon=>$AB
==> $24AB comme adresse de début de
ligne.
57/7=8.14286 ==> c'est le 8em octet à partir de
l'adresse de base qu'il faut
modifier. On en déduit que c'est l'octet $24B3 ($24AB+8) qui
nous intéresse
2em méthode
-----------
On utilise la routine HPOSN qui débute en $F411. Cette
routine fait tout le
travail de la 1ère méthode en une seule routine.
Cependant, la routine prend
plus de temps, d'où l'utilité de la première
méthode, notamment dans les
animations hyper-rapides.
HPOSN s'utilise de la manière suivante:
-A contient la valeur de l'ordonnée du
point (où A désigne l'accumulateur)
-X '
' ' ' bas-poids de l'abscisse
du point
-Y '
' ' ' haut-poids
de '
' '
Une fois les parametres rentés, on appelle la routine HPOSN (JSR
$F411). On
obtient alors en $26-$27 l'adresse de début de ligne, et en $E5,
le numéro
de l'octet, à partir de l'adresse de début de ligne,
à modifier; en bref,
l'adresse contenue en $26-27 + la valeur de $E5
NB: $26 contient la valeur de bas-poids de l'adresse
$27
' ' '
' haut-poids ' '
Exemple: on désire connaitre l'adresse exacte du point de
coordonnées 240,176
on fera donc:
Lda #176
Ldx #<240
Ldy #>240
Jsr HPOSN
On obtiendra en retour: $26=>$50 $27=>$23
$E5=>$22
d'où l'adresse ==> $2372
IV) Quelques routines pour l'assembleur
---------------------------------------
Ces routines font appel à divers
paramètres qu'ont désigne par CURSEUR
INTERNE et CURSEUR EXTERNE. Examinons de plus près ces deux
paramètres.
Le curseur externe concerne les coordonnées
du point, le masque de couleur
externe, et l'indicateur de page:
-l'abscisse du point (0-279) est
contenu dans les octets $E0 et $E1
($E0 contient l'octet de bas
poids)
-l'ordonnée du point
(0-191) est contenue dans l'octet $E2
-le masque de couleur externe est
stocké en $E4. Il détermine la couleur
du point à tracer.
Pour le fixer, il suffit d'utiliser la routine
SETHCOL.
-$E6 est l'indicateur de page. Il
détermine sur quelle page graphique
on dessine (avec des
commandes comme HPLOT).
Le curseur interne concerne l'adresse du
début de ligne, le numéro de l'octet
dans la ligne, le masque de bit, le masque de couleur interne:
-l'adresse de base de la ligne est
stockée en $26-27 (HBASL,HBASH). Cette
adresse est celle du premier
octet codant d'une ligne graphique.
-le numéro de l'octet dans
la ligne est stocké en $E5. Il sert à identi
fier l'octet exact à
modifier (on peut vouloir modifier le 3em groupe
de 7 points d'une ligne,
donc le 3em octet). La valeur de $E5 varie
de 0 à 39
-le masque de bit est
stocké en $30(HMASK).Il sert à désigner le point
à
allumer parmi les 7: tous
les bits sont à 0 sauf celui-la
-le masque de couleur interne est
stocké en $1C. Contient la valeur que
l'octet à modifier
devrait avoir pour que tous les points d'une meme
couleur soient
allumés.
HGR en $F3E2: meme effet que la commande basic
------------
HGR2 en $F3D8: idem
-------------
HPOSN en $F411:CALCULE LES PARAMETRES DU CURSEUR INTERNE.
Paramètres d'entrée
-------------- sont l'abscisse du point en X,Y (X octet de bas
poids), l'ordon
née dans l'accumulateur, le masque de couleur en $E4
HPLOT en $F457: trace le point dont l'abscisse est stockée
en X,Y (X bas-poids)
-------------- et l'ordonnée en A,dans la couleur
spécifiée par le masque de
couleur externe
HLINE en $F53A: Trace une ligne allant de la position
spécifiée par le curseur
-------------- interne jusqu'au point d'abscisse X,Y (X bas
poids) et
d'ordonnée A
BCKGND en $F3F4: l'accumulateur contient la valeur du masque
externe de couleur
--------------- La routine remplit la page graphique
spécifiée (par $E6) avec
cette couleur
SETHCOL en $F6F0: X contient la valeur de la couleur
désirée (0-7). La routine
---------------- calcule le masque de couleur externe (et
le stocke en $E4)
__________
Conclusion
__________
Vous connaissez pas mal de chose maintenant sur les pages graphiques
HGR.
Vous devriez etre capable desormais de tracer des points n'importe
où en
assembleur (donc rapidité accrue) si vous connaissez celui-ci !!
Un exercice à réaliser avec ces connaissances:
réaliser un petit scrolling
vertical en assembleur svp !! Puis, un scrolling horizontal.
La prochaine fois, lorsque ce cours aura été
digéré, on abordera le problème de
l'affichage de formes graphiques colorées de n'importe quelle
taille.
NB 1:n'oubliez pas le fichier TABLE.S contenu sur ce disk
NB 2:La table qui suit est pour ceux qui n'auraient pas d'assembleur
mais qui
voudraient quand meme connaitre les
correspondances
********************************************************
* TABLE ENTRE
LIGNE/ADRESSE DE
BASE *
********************************************************
OCTET DE BAS POIDS
BP!! 00!01!02!03!04!05!06!07!08!09!0A!0B!0C!0D!0E!0F
==!!===!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
00!! 00!00!00!00!00!00!00!00!00!80!80!80!80!80!80!80
10!! 00!00!00!00!00!00!00!00!00!80!80!80!80!80!80!80
20!! 00!00!00!00!00!00!00!00!00!80!80!80!80!80!80!80
30!! 00!00!00!00!00!00!00!00!00!80!80!80!80!80!80!80
40!! 28!28!28!28!28!28!28!28!28!AB!AB!AB!AB!AB!AB!AB
50!! 28!28!28!28!28!28!28!28!28!AB!AB!AB!AB!AB!AB!AB
60!! 28!28!28!28!28!28!28!28!28!AB!AB!AB!AB!AB!AB!AB
70!! 28!28!28!28!28!28!28!28!28!AB!AB!AB!AB!AB!AB!AB
80!! 50!50!50!50!50!50!50!50!D0!D0!D0!D0!D0!D0!D0!D0
09!! 50!50!50!50!50!50!50!50!D0!D0!D0!D0!D0!D0!D0!D0
0A!! 50!50!50!50!50!50!50!50!D0!D0!D0!D0!D0!D0!D0!D0
0B!! 50!50!50!50!50!50!50!50!D0!D0!D0!D0!D0!D0!D0!D0
OCTET DE HAUT POIDS
HP!! 00!01!02!03!04!05!06!07!08!09!0A!0B!0C!0D!0E!0F
==!!===!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
00!! 20!24!28!2C!30!34!38!3C!20!24!28!2C!30!34!38!3C
10!! 21!25!29!2D!31!35!39!3D!21!25!29!2D!31!35!39!3D
20!! 22!26!2A!2E!32!36!3A!3E!22!26!2A!2E!32!36!3A!3E
30!! 23!27!2B!2F!33!37!3B!3F!23!27!2B!2F!33!37!3B!3F
40!! 20!24!28!2C!30!34!38!3C!20!24!28!2C!30!34!38!3C
50!! 21!25!29!2D!31!35!39!3D!21!25!29!2D!31!35!39!3D
60!! 22!26!2A!2E!32!36!3A!3E!22!26!2A!2E!32!36!3A!3E
70!! 23!27!2B!2F!33!37!3B!3F!23!27!2B!2F!33!37!3B!3F
80!! 20!24!28!2C!30!34!38!3C!20!24!28!2C!30!34!38!3C
09!! 21!25!29!2D!31!35!39!3D!21!25!29!2D!31!35!39!3D
0A!! 22!26!2A!2E!32!36!3A!3E!22!26!2A!2E!32!36!3A!3E
0B!! 23!27!2B!2F!33!37!3B!3F!23!27!2B!2F!33!37!3B!3F
Un exemple d'utilisation: on cherche l'adresse de base de la ligne 45.
On regarde à 45 dans BP, et HP. On obtient l'adresse de base
$3428
_________________________________
___________________________________
_________________________________<C-R-I-C-K>___________________________________
Retour sommaire
Publicité pour les freewares underground
+-----------------------------------------------------------------------------+
!
Publicité pour toutes les créations
récentes!
!
+----------*-------------------------------------------------------*----------+
!
(K)opyright Brian Moebius and the Others, March 1989. !
*
------------------------------------------------------*
<UPDATE: DECEMBRE 89>
Dans un but informatif, récupérez ce fichier, mettez-le
à jour, et ajoutez-le
à votre super production...
Merci de votre coopération, amitiés, THE
WHITE MAN.
<=----------------------------- < CROCKY DISK >
-----------------------------=>
ARCHIVES 1 à 8 (<- spécial Black Chest)
Une série de documentations indispensables!
ARCHIVES 9 avec des docs inédites (WASTELAND, la doc de ANSTROM
2.3 (El Matos)
qui vous permettra de manipuler tous les sprites,...). Archives volume
9 fait 4
faces!
THUNDERDOCS - le dernier né. Il n'y a rien à redire...
tout est génial (de la
présentation aux docs!)
<=------------------------------ < GODFATHER >
------------------------------=>
Les cours de Déplombage.
Vous etes pressé d'avoir votre nom sur un disk que vous
diffuserez partout
dans le monde de l'Apple? Vous voulez laisser un nom derrière
vous?
Demandez à Godfather immédiatement, c'est pour vous si
vous avez de l'argent
à dépenser.
Il possède aussi de nombreuses news. Renseignez-vous!
<=--------------------------- < THE BRAIN TRUST >
---------------------------=>
Des productions gratos et indispensables;
ART OF NOISE #1; La musique pour tout le monde!
COOL-WARE 1-2; Le journal qui vous
fera cracker! euh pardon, craquer!
COOL-WARE 2 UTILITY; Découvrez les gagnants du concours
COOL-WARE 1 et leurs
oeuvres...
HARDCORE 1-2-3; Les meilleurs
digitalisations érotiques! (DHGR)
CRACKWARE;
Découvrez le travail de déplombe fournit par les
spécialistes du BRAIN TRUST... (CRACKS Black Chest)
FRACTAL-WARE; Pour les fans
de graphismes mathématiques (comme quoi les
maths sont plus utiles que beaucoup ne le croient !), un
cours et des programmes sur les images fractales par
PERFECT BUGS.
<=------------------------------ < ASTRABAN >
-------------------------------=>
Le génial speedycopy, 9 copieurs ultra-indispensables et en plus
c'est en
fast-boot! Demandez! Et en plus, un slide show made by crackman DHGR.
<=----------------------------- < WHISKY HDC >
------------------------------=>
HDC Network's #5 et #6, les 2 derniers journaux les plus giga sur disk
si
vous etes un fou de la micro-télématique (donc que vous
avez un minitel!)
Codes T2 inclus.
<=------------------------ < LE GANG DES LYONNAIS >
-------------------------=>
Les superbes Docs de Lyon I à VI! (Avec les docs des derniers
GDF chest).
Et maintenant découvrez les DDL hors série avec les docs
des derniers imports
L's G (dont le très beau et très attendu...TUTOR TECH!)
Le gang des lyonnais importe en ce moment massivement des utilitaires
des
States (Geopublish, Geofile, les times out 3.0, etc...)
<=---------------------------- < BRIAN MOEBIUS >
----------------------------=>
Le plus jeune cracker sur Apple en france et surement dans le monde
entier!
Ca ne l'empeche pas d'etre productif et d'avoir une bonne opinion de
lui-meme!
THE PRODOS COLLECTION. 2 sides. Always disponible pour les maniacs du
ProDOS.
THE HGF-BOOT. (Dernière révision !)
Soon: Une RWTS optimisée.
<=-------------------------- < LA ROYAL AIR FIX >
---------------------------=>
FORCE FIX. Une production d'illustres personnes vous
révélant des fix fous...
(Produit
par Crocky Disk et Magma)
FORCE FIX 2 (Soon). Des fixs, toujours des fixs... et sur des softs
récents
SVP!
<=------------------------------ < DIABOLIK >
-------------------------------=>
Le maitre inconstesté de l'animation TAKE ONE! Ses products':
DIABOLIK SERIES 1 à 3; Short stories.
ANIMATE MEN 1 à 3; Des
personnages animés éclatants!
BEYOND PICTURE;
Toujours de belles pages graphiques animées...
FILM
LIBRARY;
Des reproductions fidèles des titres de
cassettes
vidéo...
Goolies (Soon);
Des animations toujours plus fluides...
<=----------------------------- < HACKERFORCE >
-----------------------------=>
THE ELECTRONIC BODY MUSIC. Des musics digitalisées
endiablées avec présentation
(1 à
3)
DHGR animée.
SIERRA
SOLVER.
Ras le bol de tourner en rond dans les
jeux
d'aventure Sierra? Cette compil' de soluce est là
pour vous faciliter la tache...
GOLDEN ALBUM ROCK.
Encore des superbes musics digitalisées (adaptation
(1 à
2)
de GOLDEN ALBUM sur GS).
ASSEMBLEUR MODE D'EMPLOI Des cours d'assembleurs
très simple et surtout très
(1 à
2)
clairs pour les débutants.
<=--------------------------- < THE BYTLEJUICE >
----------------------------=>
FBOOT COLOR. Outre ses nombreux cracks, il vous offre cet
éclatant fast boot
maker qui donnera à vos products un second souffle...
<=---------------------------- < GANDALF-APPLE >
---------------------------=>
THE KIT OF ADVENTURE MASTER 1-2. Des solutions de jeux d'aventure comme
s'il
en pleuvait...
<=------------------------------- < DECKARD >
------------------------------=>
PRODOC READER. Un lecteur de
fichier HGR ouvert à l'utilisateur tournant
sous DOS 3.3 et dérivés, PRONTODOS, et PRODOS.
WIZARDRY V DOCUMENT. La doc de ce méga jeu de role de sir-tech
en fboot de sam
(doc offerte par le Black Chest)
DOC ULTIMA 5 VO. Anglais. Pour vos
correspondants étrangers, only!
Découvrez les premières notes de STONES, la ballade
composée par Iolo FitzOwen, et qui ne figurent pas dans
la doc française...
MURYADEN.
Jeu de role réalisé en collaboration avec ELRIK et The
BYTLEJUICE.
DOC MURYADEN. La doc de ce
super jeu de role genre Ultima comme quoi il
ne fait pas les choses à moitié.
<=-------------------------------- < DOUME >
-------------------------------=>
MIGHT & MAGIC 2 DOC. Dans la meme veine que la doc de wizardry 5.
(Doc Black Chest)
<=----------------------- < THE WARRIORS OF DESTINY >
----------------------=>
ULTIMA 5 DOC VF 2.0. La doc de ce fabuleux jeu de role vous est offerte
par
THE NEWSRUNNER, CROCKY DISK et DECKARD.
<=------------------------- < BLACK CHEST MEMBERS >
------------------------=>
TRUCS EN VRAC. Les membres du Black Chest vous ont mijoté un
super disk
contenant des productions personnelles (docs,utilitaires,...)
TRUCS EN VRAC 2. (Soon). Une douzaine de personnes vous mijotent le
second
volet des tools à gogo, docs, etc...
<=------------------------------- < NIBBLE >
-------------------------------=>
CROC'S.(soon). Journal informatique avec au programme un dossier sur
les virus,
les derniers codes minitel, des fixs, des aides de jeux,...
<=---------------------------- < THE DEAD MAN >
----------------------------=>
ALLIANCE MAG. (Soon). Un nouveau journal informatique (papier) avec
tout plein
de renseignements alléchants: principe du Fboot,...
<=--------------------------- < DOX A GAZ TEAM >
---------------------------=>
DOX A GAZ 1 à 5. Rien que des docs en français et de
qualité, s'il vous plait!
DOX A GAZ 6. Spécial Pool of Radiance avec la complicité
de William Comte.
En face 2, vous trouverez un fast load pour ne plus se prendre la
à faire 36 changements de faces pour jouer à ce jeu de
role né
d'alliance SSI/TSR. La face 2 permet aussi de faire sauter les
codes (Autocracker).
DOX A GAX 7 (Octobre 89). La suite de la doc de Pool of Radiance! (avec
d'autres dont the last ninja, bas dudes,... (EN VF of
course!)
*******************************************************************************
AJOUTEZ VOS COORDONNEES TELEMATIQUES POUR QUE L'ON PUISSE
VOUS JOINDRE...
Pour contacter tous ces beaux et gentils mecs il suffit de prendre votre
minitel, ou why not celui de votre voisin si vous n'en avez pas, de
faire
le 36.14 et de taper un des codes suivants:
135060318*RTEL Bals: BRIAN MOEBIUS
CROCKY DISK (+ sur Jazz)
GODFATHER
AP II
WHISKY HDC
ASTRABAN
GANDALF-APPLE
DOUME
NIBBLE
THE BLACK CHEST
EDDIE HAWK
DECKARD
THE NEWSRUNNER
THE WHITE MAN
FLYNN'S (MAX HEADROOM)
THEMONZ
HACKERFORCE
HACKERCHEST
NOUVEAU: Pour avoir accès à nos bals (The White Man,
Hackerforce,...),
tappez 36-14 chez*nom
de la personne recherchée
ex:
chez*Hackerforce => vous atterrissez directement dans
une bal
privée. Laissez vos messages sans passer par
d'interminables menus...
*******************************************************************************
CREATION & UPDATES : o MARS 89
- BRIAN MOEBIUS
o JUIN 89 - DECKARD
o OCTOBRE 89 - THE BLACK CHEST
o NOVEMBRE 89 - DECKARD
o DECEMBRE 89 - THE WHITE MAN
o
- TOI/VOUS!
*******************************************************************************
Retour sommaire
