1

Bon voilà happy

J'voudrais, en gros, avoir un TSR qui, au démarrage de la Ti, lance un programme Ti-BASIC ou ASM ...
Bref, la question se divise en deux :
* Ca existe ?
* Si ça n'existe pas, comment je code des TSR ? Vous avez de la doc ? smile

Merci, j'suis un peu largué, et j'sais pas trop où poster ça =\ #okay#

2

Ouep, ça peut se faire facilement.

Tu crées un programmes qui change le handler du trap #4, en installant son propre handler qui va appeler le trap #4 d'origine (extinction de la caclulatrice), puis exécuter son propre code (exécution d'un programme asm ou basic).
Ton handler doit être recopié en RAM dans un handle locké au fait (HeapAllocHigh, HeapAllopPtr, HeapLock).

3

J'ai absolument rien compris :mrgreen:.

T'as pas de la documentation ?
Et c'est pas à l'extinction, mais au démarrage ....
J'ai jamais fait de C++ ou d'ASM sur Ti ^^

4

le trap 4 est un vecteur d'interruption.

l'appeler ça éteint la calculatrice (trap #4 en asm)

si tu l'interceptes tu remplaces "éteindre" par ce que tu veux, par exemple "éteindre puis exécuter un truc" smile

5

Ha d'accord. En fait, le TSR éteint la Ti, mais lui ordonnes de lancer un programme après, ce qui sera fait uniquement au démarrage ? happy

J'ai compris le principe, mais pour la mise en oeuvre, je sèche ^^

6

Exact. happy
Je te fais un topo détaillé dès que j'ai raccroché le téléphone.

7

Bon.
Alors la calculatrice s'éteint de la manière suivante : le romcall off() appelle le trap #4 (c'est un vecteur, ie une routine qui est exécutée, et dont l'adresse se situe à $8C). La routine est donc exécutée, et éteint l'écran, divers oscillateurs etc... Quand elle se rallume, le trap #4 se termine et rend la main là où on l'avait appelé. Comme l'a dit squalyl, c'est par là qu'il faut attaquer pour faire ce que tu veux :
tu vas remplacer l'adresse de ce qu'exécute AMS à $8C (mettons $00123456) par la tienne, au pif $00654321, si ton code se situe là. Comme ça, c'est ton code qui va être exécuté, non celui d'AMS. Ca s'appelle une redirection. Le but du jeu est de faire :
-> la calculatrice lance le code contenu à l'adresse de $8C, donc elle exécute le code à $00654321.
-> on a donc la main avec notre routine. on exécute le code à $00123456, adresse qu'on a pris soin de retenir avant de la remplacer par la notre : la calculatrice s'éteint., puis nous rend la main : on a donc la main dès le démarrage.
-> on exécute ensuite le code qu'on veut (genre printf("Windows est en cours de démarrage"), ou mieux, printf("Uncompressing the kernel..."), 'fin bref, t'as le choix tripo).

Ca, c'est pour le principe. Maintenant, comemnt faire concrètement ?
Ton code va être en deux parties :
- le code d'installation et de désinstallation, qui va s'exécuter quand on va lancer ton programme. Il ne sert qu'une fois, et mets en place le TSR, ou le désinstalle s'il est déjà en place.
- le code de l'interruption proprement dit, qui s'exécutera à chaque exctinction et à chaque démarrage.

Rentrons dans les détails croustillants :

installation/désinstallation :
- tu lis l'adresse située à $8C, tu sais donc où se trouve en mémoire le handler (le code d'interuption) du trap #4.
- tu lis l'adresse de l'interuption que tu veux installer, c'est à dire ton propre code dans ton programme d'installation
- tu compares octet par octet le code de ces deux interuptions
a. si les binaires sont différents, ça veux dire que ton interuption n'est pas installée. On est donc dans un cas d'installation
b. si le binaire du handler est le même que ton code (sauf un détail, voir suite), ça veut dire que c'est déjà ton TSR qui est installé, donc on est dans un cas de désinstallation.

a. Installation
- On pourrait être tenté de mettre à l'adresse $8C l'adresse du code qu'on a préparé dans le programme : lea Interruption(pc),a0 / move.l a0,$8C. Erreur : ton programme, une fois achévé, a toute les chances de bouger en RAM. Et pourtant, le trap #4 appellera toujours du code situé là où ton programme était lors de l'installation : crash garanti.
Il faut donc recopier le code de ton interruption quelque part en mémoire, pour ne plus qu'il y bouge. Regarde les fonctions HeapAllocPtr et HeapAllocHigh. Evite d'utiliser HeapAlloc, tu vas allouer en mémoire basse, puis locker (HeapLock), ça va fragmenter ta RAM.
Alloue donc de la mémoire, puis lock le handle si nécessaire (ie si la fonction d'allocation ne le fait pas elle-même). Pour ce qui est de la taille du handle à allouer, tu peux la connaitre par une simple différence de labels : (FinInteruption - DebutInteruption).

b. Désinstallation
- tu retrouves le numéro de ton handle, ou tu cnoserves son adresse (tu auras besoin de l'un ou de l'autre suivant comment tu l'auras créé, regarde HeapPtrToHandle si t'as besoin du handle).
- tu remplaces le contenu de $8C par ce que t'avais enregistré à la place de ton 0.l
- tu désalloue ton handle
- ayé, fini. smile

c. Le tsr proprement dit
Voyons le contenu à proprement parler de ton TSR maintenant.
Le moyen le plus simple que j'avais trouvé pour exécuter l'ancien trap 4, c'est, une fois que ton tsr est lancé, de réinstaller l'ancien trap 4, de l'appeler, puis de réinstaller le tien en écrivant juste l'adresse du début du handler dans la table des vecteurs. Un autre moyen doit être d'appeler l'ancien handler avec un jsr, en ayant pris soin de pousser le SR sur la pile, vu que le code du trap se termine par rte et non par rts. Je sais pas pourquoi j'avais opté pour la première option, peut-être par manque de connaissances, je sais plus.
Après, la calc est redémarrée, le processeur t'appartient, à toi de lui faire faire ce que tu veux. smile

d. Note sur l'installation d'un vecteur
Pour d'évidentes raisons de protection du système, on ne peut pas écrire dans la table des vecteurs sans déclencher une erreur, sans avoir désactiver la protection en écriture dans cette table.
Pour désactiver la protection, il faut mettre à 0 le bit #2 à $600001. Bien évidemment, faut le remettre à 1 une fois que t'as fait ton écriture. Le top est, en trois instruction, de mettre le bit $600001:2 à 0, d'écrire ce que tu veux, puis de remettre le bit à 1. Sinon au moindre bug, tu fous la table en l'air ^^

8

FireHunter (./1) :
Bon voilà happy

J'voudrais, en gros, avoir un TSR qui, au démarrage de la Ti, lance un programme Ti-BASIC ou ASM ...
Bref, la question se divise en deux :
* Ca existe ?
* Si ça n'existe pas, comment je code des TSR ? Vous avez de la doc ? smile

Merci, j'suis un peu largué, et j'sais pas trop où poster ça =\ #okay#

Quel est ton niveau en prog ? grin
avatar
<<< Kernel Extremis©®™ >>> et Inventeur de la différence administratif/judiciaire ! (©Yoshi Noir)

<Vertyos> un poil plus mais elle suce bien quand même la mienne ^^
<Sabrina`> tinkiete flan c juste qu'ils sont jaloux que je te trouve aussi appétissant

9

Euh oui, j'ai oublié de dire qu'un TSR, c'est pas un simple Hello World trinon

10

Ah bon ? cheeky
avatar
<<< Kernel Extremis©®™ >>> et Inventeur de la différence administratif/judiciaire ! (©Yoshi Noir)

<Vertyos> un poil plus mais elle suce bien quand même la mienne ^^
<Sabrina`> tinkiete flan c juste qu'ils sont jaloux que je te trouve aussi appétissant

11

Remarque, tu peux afficher "Hello World" au démarrage en effet, mais bon voilà quoi tripo

12

13

Sinon pour répondre à ta première question, oui ça existe -> http://www.ticalc.org/archives/files/fileinfo/223/22368.html
Et c'est bien pratique pour lancer un programme qui change la vitesse de répétition des touches love
Visitez mon site : http://www.bobti89.fr.st
Testez mon forum ici

14

bobti89 (./13) :
Sinon pour répondre à ta première question, oui ça existe -> http://www.ticalc.org/archives/files/fileinfo/223/22368.html
Et c'est bien pratique pour lancer un programme qui change la vitesse de répétition des touches love

Il me semble que j'avais fait un programme qui la changeait automatiquement, y compris après extinction ^^

edit: ça doit être ça
avatar
<<< Kernel Extremis©®™ >>> et Inventeur de la différence administratif/judiciaire ! (©Yoshi Noir)

<Vertyos> un poil plus mais elle suce bien quand même la mienne ^^
<Sabrina`> tinkiete flan c juste qu'ils sont jaloux que je te trouve aussi appétissant

15

Flanker (./8) :
FireHunter (./1) :
Bon voilà happy

J'voudrais, en gros, avoir un TSR qui, au démarrage de la Ti, lance un programme Ti-BASIC ou ASM ...
Bref, la question se divise en deux :
* Ca existe ?
* Si ça n'existe pas, comment je code des TSR ? Vous avez de la doc ? smile

Merci, j'suis un peu largué, et j'sais pas trop où poster ça =\ #okay#

Quel est ton niveau en prog ? grin


Rien du tout #okay#
J'ai les bases en C.
Folco (./7) :
Bon.
Alors la calculatrice s'éteint de la manière suivante : le romcall off() appelle le trap #4 (c'est un vecteur, ie une routine qui est exécutée, et dont l'adresse se situe à $8C). La routine est donc exécutée, et éteint l'écran, divers oscillateurs etc... Quand elle se rallume, le trap #4 se termine et rend la main là où on l'avait appelé. Comme l'a dit squalyl, c'est par là qu'il faut attaquer pour faire ce que tu veux :
tu vas remplacer l'adresse de ce qu'exécute AMS à $8C (mettons $00123456) par la tienne, au pif $00654321, si ton code se situe là. Comme ça, c'est ton code qui va être exécuté, non celui d'AMS. Ca s'appelle une redirection. Le but du jeu est de faire :
-> la calculatrice lance le code contenu à l'adresse de $8C, donc elle exécute le code à $00654321.
-> on a donc la main avec notre routine. on exécute le code à $00123456, adresse qu'on a pris soin de retenir avant de la remplacer par la notre : la calculatrice s'éteint., puis nous rend la main : on a donc la main dès le démarrage.
-> on exécute ensuite le code qu'on veut (genre printf("Windows est en cours de démarrage"), ou mieux, printf("Uncompressing the kernel..."), 'fin bref, t'as le choix tripo).

Ca, c'est pour le principe. Maintenant, comemnt faire concrètement ?
Ton code va être en deux parties :
- le code d'installation et de désinstallation, qui va s'exécuter quand on va lancer ton programme. Il ne sert qu'une fois, et mets en place le TSR, ou le désinstalle s'il est déjà en place.
- le code de l'interruption proprement dit, qui s'exécutera à chaque exctinction et à chaque démarrage.

Rentrons dans les détails croustillants :

installation/désinstallation :
- tu lis l'adresse située à $8C, tu sais donc où se trouve en mémoire le handler (le code d'interuption) du trap #4.
- tu lis l'adresse de l'interuption que tu veux installer, c'est à dire ton propre code dans ton programme d'installation
- tu compares octet par octet le code de ces deux interuptions
a. si les binaires sont différents, ça veux dire que ton interuption n'est pas installée. On est donc dans un cas d'installation
b. si le binaire du handler est le même que ton code (sauf un détail, voir suite), ça veut dire que c'est déjà ton TSR qui est installé, donc on est dans un cas de désinstallation.

a. Installation
- On pourrait être tenté de mettre à l'adresse $8C l'adresse du code qu'on a préparé dans le programme : lea Interruption(pc),a0 / move.l a0,$8C. Erreur : ton programme, une fois achévé, a toute les chances de bouger en RAM. Et pourtant, le trap #4 appellera toujours du code situé là où ton programme était lors de l'installation : crash garanti.
Il faut donc recopier le code de ton interruption quelque part en mémoire, pour ne plus qu'il y bouge. Regarde les fonctions HeapAllocPtr et HeapAllocHigh. Evite d'utiliser HeapAlloc, tu vas allouer en mémoire basse, puis locker (HeapLock), ça va fragmenter ta RAM.
Alloue donc de la mémoire, puis lock le handle si nécessaire (ie si la fonction d'allocation ne le fait pas elle-même). Pour ce qui est de la taille du handle à allouer, tu peux la connaitre par une simple différence de labels : (FinInteruption - DebutInteruption).

b. Désinstallation
- tu retrouves le numéro de ton handle, ou tu cnoserves son adresse (tu auras besoin de l'un ou de l'autre suivant comment tu l'auras créé, regarde HeapPtrToHandle si t'as besoin du handle).
- tu remplaces le contenu de $8C par ce que t'avais enregistré à la place de ton 0.l
- tu désalloue ton handle
- ayé, fini. smile

c. Le tsr proprement dit
Voyons le contenu à proprement parler de ton TSR maintenant.
Le moyen le plus simple que j'avais trouvé pour exécuter l'ancien trap 4, c'est, une fois que ton tsr est lancé, de réinstaller l'ancien trap 4, de l'appeler, puis de réinstaller le tien en écrivant juste l'adresse du début du handler dans la table des vecteurs. Un autre moyen doit être d'appeler l'ancien handler avec un jsr, en ayant pris soin de pousser le SR sur la pile, vu que le code du trap se termine par rte et non par rts. Je sais pas pourquoi j'avais opté pour la première option, peut-être par manque de connaissances, je sais plus.
Après, la calc est redémarrée, le processeur t'appartient, à toi de lui faire faire ce que tu veux. smile

d. Note sur l'installation d'un vecteur
Pour d'évidentes raisons de protection du système, on ne peut pas écrire dans la table des vecteurs sans déclencher une erreur, sans avoir désactiver la protection en écriture dans cette table.
Pour désactiver la protection, il faut mettre à 0 le bit #2 à $600001. Bien évidemment, faut le remettre à 1 une fois que t'as fait ton écriture. Le top est, en trois instruction, de mettre le bit $600001:2 à 0, d'écrire ce que tu veux, puis de remettre le bit à 1. Sinon au moindre bug, tu fous la table en l'air ^^


Je prends note de tout ça, jvais chercher de la documentation #okay#
bobti89 (./13) :
Sinon pour répondre à ta première question, oui ça existe -> http://www.ticalc.org/archives/files/fileinfo/223/22368.html
Et c'est bien pratique pour lancer un programme qui change la vitesse de répétition des touches love


Je prends note, j'utiliserais si je galère trop ^^


-------------

Merci pour vos réponses, j'vais me replonger dans le C, parce que en fait j'veut verrouiller avec un mot de passe ma Ti #okay#. Du coup, me faut un programme qui résiste à un RESET de la Ti, ou à un break, 'fin toutes les manières pour pas autoriser l'accès si le mot de passe est incorrect. Et j'p'nse pas que en Ti-BASIC, ça suffise happy

16

Non, en basic, c'est pas possible. Et rien ne résiste à un vrai reset, même en interceptant son vecteur, ya toujour moyen de rebooter.
Tu peux jeter un zyeu ici pour ton idée : http://www.tigen.org/forum/index.php?action=sujet&forum=5&cat=17&topic=1098&page=1 cheeky
C'est pas un TSR, mais un programme qui demandera un pass au démarrage si tu pases par lui pour l'extinction.




et dis-toi bien un truc, l'assembleur sur 68k est 1000 fois plus facile que le C, pour trois raisons principales :
- les outils pour coder en assembleur sont beaucoup plus simples, complet et à jour que les outils pour coder en C
- le 68k est un processeur très simple, donc très facile à programmer en assembleur. On peut commencer déjà à faire de choses avec une vingtaine d'instrauctions, le reste vient rapidement.
- tout ce qui est TSR etc... est un jeu d'enfant en assembleur, et une galère en C

17

Je parle d'un RESET type pile, on 2nd+gauche+droite+on #okay#
[EDIT] Ton lien, c'un programme qui locke la Ti c'bien ça ? xD.

18

parce que en fait j'veut verrouiller avec un mot de passe ma Ti #okay#

Je ne veux pas te décourager de faire ce genre de programmes (dans certaines limites, il est utile de réinventer la roue pour apprendre !), mais sache que ça existe déjà wink
Par exemple, KeyPass de Samuel Stearley, dont le mot de passe est une combinaison de touches.
Je parle d'un RESET type pile, on 2nd+gauche+droite+on #okay#

C'est ce que Martial dit wink
Et rien ne résiste à un vrai reset, même en interceptant son vecteur, ya toujour moyen de rebooter.

Même en utilisant une FlashApp, on ne peut pas faire une protection fiable par mot de passe sur des TI-68k tournant AMS...

En d'autres termes, utiliser un programme qui verrouille par mot de passe ne t'offrira à peu près aucune sécurité. Seuls les débutants absolus, qui ne savent pas rebooter leur TI-68k, ne pourront pas rentrer sur ta machine (et faire diverses modifications potentiellement non voulues par toi du contenu).
avatar
Membre de la TI-Chess Team.
Co-mainteneur de GCC4TI (documentation en ligne de GCC4TI), TIEmu et TILP.
Co-admin de TI-Planet.

19

Je comprends...

Concernant le lockeur, j'en ai déjà deux trois en Ti-BASIC ....

Merci pour toutes ces infos smile

20

Les lockeurs en basic se breakent, même avec les nobreak de flib ou vertel ^^

21

Folco (./17) :
assembleur sur 68k est 1000 fois plus facile que le C

désolé mais rotfl

22

pardon ? tripo

23

Pour la répétition du clavier, il y a aussi Fast Keyboard qui persiste également à l'extinction de la calculatrice.
avatar
Mes news pour calculatrices TI: Ti-Gen
Mes projets PC pour calculatrices TI: TIGCC, CalcForge (CalcForgeLP, Emu-TIGCC)
Mes chans IRC: #tigcc et #inspired sur irc.freequest.net (UTF-8)

Liberté, Égalité, Fraternité

24

squalyl (./21) :
désolé mais rotfl.gif
Note qu'il a pas complètement tort : l'assembleur est plus difficile à aborder, mais il y a nettement moins de pièges qu'en C.
avatar
Zeroblog

« Tout homme porte sur l'épaule gauche un singe et, sur l'épaule droite, un perroquet. » — Jean Cocteau
« Moi je cherche plus de logique non plus. C'est surement pour cela que j'apprécie les Ataris, ils sont aussi logiques que moi ! » — GT Turbo

25

Faut avouer que la manière de penser n'a rien à voir. Quand j'ai lu le 68kguide pour la première fois, je sortais du basic : ROtate to the Right ? Mais qu'est-ce que j'en ai à cirer de faire valser des bits dans ma calulatrice ? Bon, après, on comprend. ^^ Ce qui est déroutant, c'est que les instruction du proc sont en elles-même très simples : on copie, on additionne, on déplace, on multiplie etc...
Par contre, niveau algo, ça n'a rien à voir : on pense à autre chose.
Exemple de deux codes en C (tout frais d'hier) et ASM (tout frais d'aujourd'hui) qui font la même chose à un petit chouia près
Code C
void DrawWindow (const short Width, const short Height, const char* Title)
{
	short x0 = (LCD_WIDTH-Width)/2;											//left of the window
	short y0 = (LCD_HEIGHT-Height)/2;										//top
	short x1 = (LCD_WIDTH+Width)/2 - 1;										//right
	short y1 = (LCD_HEIGHT+Height)/2;										//bottom
	SCR_RECT FilledRect = {{(char)x0,(char)y0,(char)x1,(char)y1}};			//SCR_RCET of the rectangle
	WIN_RECT FrameRect = {x0,y0,x1,y1};										//and its WIN_RECT
	const short TitleX = ((LCD_WIDTH - DrawStrWidth (Title, F_4x6))/2);		//title centered

	ScrRectFill (&FilledRect, &ScreenClip, A_REVERSE);						//clear background
	DrawClipRect (&FrameRect, &ScreenClip, A_NORMAL+B_DOUBLE);				//external rect
	FilledRect.xy.y1 = FilledRect.xy.y0 + 8;								//prepare title rect
	ScrRectFill (&FilledRect, &ScreenClip, A_NORMAL);						//draw it
	DrawStr (TitleX, FilledRect.xy.y0+2, Title,A_REVERSE);					//disp title
}

Et l'équivalent en assembleur :
Code ASM
|======================================================================
|	DrawWindow
|======================================================================
|	Draw a window (borders + title)
|
|	input	d0.w	width
|		d1.w	height
|		a3	&title
|	output	WIN_RECT_WINDOW.{x1+1,y1+1} is the top-left pixel inside the window
|	destroy	std
|======================================================================
FunctionSection DrawWindow
	movem.l	%d3-%d5/%a2/%a4-%a5,-(%sp)	|save registers
	lea.l	WIN_RECT_WINDOW(%fp),%a2	|prepare pointers (&WIN_RECT)
	lea.l	SCR_RECT_WINDOW(%fp),%a4	|&SCR_RECT
	lea.l	SCREEN_CLIP(%fp),%a5		|&SCR_RECT (clipping)

	|======================================================================
	|	Compute WIN_RECT_WINDOW and SCR_RECT_WINDOW
	|======================================================================
	moveq.l	#240/2,%d3			|LCD width on 92+/v200
	moveq.l	#128/2,%d2			|LCD height
	tst.b	CALC_TYPE(%fp)
	bhi.s	Calc92
		moveq.l	#160/2,%d3		|LCD width on 89/89ti
		moveq.l	#100/2,%d2		|LCD height
Calc92:
	move.w	%d0,%d4				|read width/2
	move.w	%d1,%d5				|read height/2
	sub.w	%d3,%d4				|-x0
	sub.w	%d2,%d5				|-y0
	neg.w	%d4				|x0
	neg.w	%d5				|y0
	move.w	%d4,(%a2)			|save x0 in WIN_RECT
	move.w	%d5,2(%a2)			|save y0
	swap.w	%d4				|put x0 in the upper word
	swap.w	%d5				|put y0 in the upper word
	move.w	%d0,%d4				|read width/2
	move.w	%d1,%d5				|read height/2
	add.w	%d3,%d4				|x0.w
	add.w	%d2,%d5				|y0.w
	subq.b	#1,%d4				|x1
	subq.b	#1,%d5				|y1
	move.w	%d4,4(%a2)			|save x1
	move.w	%d5,6(%a2)			|save y1
	lsl.l	#8,%d4				|{x0,0,x1,0}
	or.l	%d5,%d4				|{x0,y0,x1,y1}
	move.l	%d4,(%a4)			|store SCR_RECT

	|======================================================================
	|	Clear window background
	|======================================================================
	clr.w	-(%sp)				|A_REVERSE		sp - 2
	pea.l	SCREEN_CLIP(%fp)		|&SCR_RECT		sp - 6
	pea.l	(%a4)				|&WIN_RECT		sp - 10
	RC	ScrRectFill			|erase background

	|======================================================================
	|	Draw window
	|======================================================================
	move.l	#0x00020002,%d5			|will add/sub 1 to each coordinate
DrawRectLoop:
	move.w	#A_NORMAL,(%sp)			|mode
	pea.l	(%a5)				|&SCR_RECT		sp - 14
	pea.l	(%a2)				|&WIN_RECT		sp - 18
	RC	DrawClipRect			|draw it
	add.l	%d5,(%a2)			|update {x0,y0}
	sub.l	%d5,4(%a2)			|update {x1,y1}
	move.w	#A_NORMAL+B_DOUBLE,(%sp)	|mode
	pea.l	(%a5)				|&SCR_RECT		sp - 22
	pea.l	(%a2)				|&WIN_RECT		sp - 26
	RC	DrawClipRect			|draw it
	
	|======================================================================
	|	Draw title rectangle
	|======================================================================
	addi.w	#4<<8+4,(%a4)			|{x0,y0}
	subi.w	#4<<8+85,2(%a4)			|{x1,y1}
	move.w	#A_NORMAL,(%sp)			|mode
	pea.l	(%a5)				|&WIN_RECT		sp - 30
	pea.l	(%a4)				|&SCR_RECT		sp - 34
	RC	ScrRectFill			|draw it

	|======================================================================
	|	Compute title position
	|======================================================================
	clr.w	(%sp)				|font F_4x6
	pea.l	(%a3)				|&title			sp - 38
	RC	DrawStrWidth			|get lenght in d0
	lsr.w	#1,%d0				|lenght/2
	sub.w	%d0,%d3				|abcisse
	move.w	2(%a2),%d1			|y0
	addq.w	#4,%d1				|ordinate

	|======================================================================
	|	Draw title
	|======================================================================
	move.w	#A_XOR,(%sp)			|mode
	pea.l	(%a3)				|&title			sp - 42
	move.w	%d1,-(%sp)			|y			sp - 44
	move.w	%d3,-(%sp)			|x			sp - 46
	RC	DrawStr				|disp it

	|======================================================================
	|	Restores regs and quit
	|======================================================================
	lea.l	46(%sp),%sp			|fix stack
	movem.l	(%sp)+,%d3-%d5/%a2/%a4-%a5	|restore registers
	rts

Faut avouer que ça peut paraitre déroutant, c'est sûr. Mais perso je prends 100 fois plus mon pied à écrire de l'assembleur, comme dit 0², il n'y a pas vraiment de piège : la machine ne fait que ce qu'on lui dit.

26

tu perds du temps en C a écrire du code PIC, et a vouloir reproduire ce que tu fais en asm.

Donc évidemment l'exemple est bien choisi smile

mais bon je comprends le coté sentimental de la chose et je te contredirai pas pour le plaisir grin

27

Je cherche l lien de la doc du 68k. Si vous l'avez .... #sifflote# merci ^^

28

avatar
Zeroblog

« Tout homme porte sur l'épaule gauche un singe et, sur l'épaule droite, un perroquet. » — Jean Cocteau
« Moi je cherche plus de logique non plus. C'est surement pour cela que j'apprécie les Ataris, ils sont aussi logiques que moi ! » — GT Turbo

29

Wouhahou la rapidité ! J'était en train de fouiller les fonds de Google triso 120ème page.

Merci !

[EDIT]

Caca, c'est en anglais ^^

30

T'as le 68kguide au moins ?