11:48 Mot de passe oublié ?

4080

en fait, quand on lit -(a0, ça peut etre le début de -(a0), ou de -(a0symbol+5)
Or, dans les deux cas, on a déjà effectué des substitutions de macro si nécessaire. Donc c'est la merde. Plus qu'à prédire ce que va donner un remplacement de macro, bonjour les perfs ><
Donc -(an), (an) et (an)+ sont emmerdants à parser, le reste ça va.

4081

tu peux aussi empecher les symboles de commencer par un nom de registre grin
avatar

4082

oué, mais c'est quand même abusé, c'est criant de paresse grin
Pis de toute façon, on a déjà un appel de substitution de macro entre - et ( quand on parse une expression, donc pour fallback sur l'évaluation d'un adressage indirect, c'est déjà trop tard sad
C'est le prix des sbstitutions de macro et de leurs arguments à la volée : ça fait gagner en place, mais c'est vraiment plus compliqué à parser sad

4083

Donc voilà, ça devrait donner un truc dans ce genre là, assez imbitable #sick#
;	char = (a2).b
;	if (char == '#')					; #immediate
;		EvalExpression ()
;		EncoreImmediate ()
;		return
;
;	if (char == '(' OR char == '-')						; (an), (an)+, -(an)
;		a2++
;		MACRO_PARAM_INSPECT
;		if (IsAn ())
;			MACRO_PARAM_END
;			if (char == ')')
;				MACRO_PARAM_BEGIN
;				GetAn ()
;				if (char + 1 == '+')
;					EncodePostInc ()
;					return 
;				else
;					EncodeIndirect ()
;					return
;	X = EvalAbsolute ()
;	if (NAN)								; an, dn, sr, ccr, usp
;		if (an, dn, sr, ccr, usp)
;			EncodeReg ()
;			return
;		else
;			Fail
;	else									; should be x16, x32, x16(pc), x16(an), x8(pc,yn), x8(an,yn)
;		MACRO_PARAM_RESTART
;		if (char == '(')
;			MACRO_PARAM_RESTART
;				if (IsAN ())
;					if (char == ',' AND X < 2^8)		: x8(an,yn)
;						MACRO_PARAM_RESTART
;						if (char + 1 == yn)
;							EncodeXANYN ()
;							return
;						else
;							error ()
;					else if (char == ')'  AND X < 2^16)	; x16(an)
;						Encode XAN ()
;						return
;					else
;						error ()
;				else if (IsPC ())
;					if (char == ',' AND X < 2^8)		; x8(pc,yn)
;						MACRO_PARAM_RESTART
;						if (char + 1 == yn)
;							EncodeXPCYN ()
;							return
;						else
;							error ()
;					else if (char == ')'  AND X < 2^16)	; x16(pc)
;						Encode XPC ()
;						return
;					else
;						error ()
;				else
;					error ()
;	if (X > 2^16)								; x32
;		EncodeAbsoluteLong ()
;		return
;	else
;		EncodeAbsoluteShort ()						; x16
;		return

4084

J'ai honte de généréer un dictionnaire de clefs Mifare Classic. Juste pour pouvoir modifier ma carte de fac ( y a mon crédit dedans grin ) C'est pas comme si on s'étalait sur 6 bytes....

using System; using System.Threading.Tasks; using System.IO; namespace MifareDict { class Program { public static void Main(string[] args) { StreamWriter output = new StreamWriter(new FileStream("./output2.txt", FileMode.Create)); // Keys are 6 bytes wide. Parallel.For(0x100000000000, 0xFFFFFFFFFFFF, i => { Console.WriteLine("{0:X12}", i); output.WriteLine("{0:X12}", i); }); } } }

[EDIT] Ah bah tiens grin
Exception non gérée : System.AggregateException: Une ou plusieurs erreurs se sont produites. ---> System.IndexOutOfRange
Exception: Condition de concurrence critique d'E/S probable détectée lors de la copie dans la mémoire. Le package d'E/S
n'est pas thread-safe par défaut. Dans des applications multithread, l'accès au flux doit se faire de façon thread-safe,
par exemple un wrapper thread-safe retourné par les méthodes Synchronized de TextReader ou TextWriter. Cela s'applique
également aux classes telles que StreamWriter et StreamReader.
à System.Buffer.InternalBlockCopy(Array src, Int32 srcOffsetBytes, Array dst, Int32 dstOffsetBytes, Int32 byteCount)
à System.IO.StreamWriter.Write(Char[] buffer, Int32 index, Int32 count)
à System.IO.TextWriter.WriteLine(String value)
à System.IO.TextWriter.WriteLine(String format, Object arg0)
à MifareDict.Program.<>c__DisplayClass1.<Main>b__0(Int64 i) dans c:\SharpDevelop Projects\Mif
areDict\MifareDict\Program.cs:ligne 16
à System.Threading.Tasks.Parallel.<>c__DisplayClass15`1.<ForWorker64>b__12()
à System.Threading.Tasks.Task.InnerInvoke()
à System.Threading.Tasks.Task.InnerInvokeWithArg(Task childTask)
à System.Threading.Tasks.Task.<>c__DisplayClass11.<ExecuteSelfReplicating>b__10(Object param0)
--- Fin de la trace de la pile d'exception interne ---
à System.Threading.Tasks.Task.ThrowIfExceptional(Boolean includeTaskCanceledExceptions)
à System.Threading.Tasks.Task.Wait(Int32 millisecondsTimeout, CancellationToken cancellationToken)
à System.Threading.Tasks.Task.Wait()
à System.Threading.Tasks.Parallel.ForWorker64[TLocal](Int64 fromInclusive, Int64 toExclusive, ParallelOptions paralle
lOptions, Action`1 body, Action`2 bodyWithState, Func`4 bodyWithLocal, Func`1 localInit, Action`1 localFinally)
à System.Threading.Tasks.Parallel.For(Int64 fromInclusive, Int64 toExclusive, Action`1 body)
à MifareDict.Program.Main(String[] args) dans c:\SharpDevelop Projects\MifareDict\MifareDict Program.cs:ligne 14

Surprenant que ça ne soit pas arrivé plus tôt (240Mo le dictionnaire là).
avatar

4085

mais lol, tu vas pouvoir recharger ton crédit comme ça ?

4086

ça doit se faire tongue

Le contenu est stocké sur le dernier bloc (le 15), en clair. Y a mon UUID étudiant, mon nom, prénom, et 0x45, soit 69, et il me reste 69 centimes ^^

Le problème c'est que les access bit du secteur forcent la clef B uniquement pour écrire, mais interdisent de la lire. La clef A vaut 0xFF FF FF FF FF FF, donc elle gêne pas. J'ai regardé du côté de mfoc et d'autres attaques, mais j'ai pas le matériel, et j'sais pas vraiment où trouver ça autre part que sur internet.

Sinon je peux aussi mettre la main sur l'exécutable qui crée les cartes, et en sortir la clef B triso
avatar

4087

B09xGo3CMAAkn6Q.jpg

The_CurEsque
avatar
Spartine, la fille que ce soir elle dîne en enfer: http://www.spartine.com

Pockett Videogames, le site de toutes les consoles portables!: http://www.pockett.net

J'aime beaucoup faire des dessins aux petites filles! C'est ma passion.

4088

Et Melbouïque.

Warpten > euh, c'est peut-être pas une très bonne idée de faire ça, et encore moins d'en parler sur un forum public (surtout avec un log d'erreur qui mentionne ton username), mais c'est toi qui vois tongue
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

4089

./4088 Cepafo. Normalement personne ne connait ce surnom, mais dans le doute ... grin

Et puis je pense pas non plus être le premier à essayer. ^^'
avatar

4090

Nhut (./4087) :
B09xGo3CMAAkn6Q.jpg

The_CurEsque



Sugu raku ni shite yaru...


Mais j'aurais pensé qu'il serait plutôt comparé à PSY.

Tiens tu me rappelles que j'ai KoF XIII sur PC, ça vaudrait la peine de l'installer (le bonheur serait qu'il tourne aussi sur mon laptop).
avatar
"- Nigga you know what the fuck I want, nigga: I want your motherfuckin' Daytons, and your motherfuckin' stereo! And I'll take a double burger with cheese!
- WHUT?"
I LOVE TO HATE/I HATE YOUR LOVE -AND I CAN'T FEEL AFFECTION FOR PEOPLE LIKE YOU!
CAALGOOONNNNN [TELLMESOMETHINGIDONTKNOW SHOWMESOMETHINGICANTUSE PUSHTHEBUTTONSCONNECTTHEGODDAMNDOTS] (Si Dieu existe il doit me détester...)

4091

Et bien voilà, c'était tout con, comme d'habitude, maintenant que c'est résolu, je sais pas pourquoi je m'en faisais une montagne
Parsing d'opérandes
ReadOperand:

	;-------------------------------------------------------------------------------
	;	Check for an immediate value (#expr)
	;-------------------------------------------------------------------------------

	move.b	(a2),d0
	cmpi.b	#'#',d0
	bne.s	\TryIndirects

		addq.l	#1,a2
		MACRO_PARAM_END
		bsr	EvalExpression				; Call MACRO_PARAM_BEGIN/MACRO_PARAM_END
		tst.w	d1
		bmi	ErrorExpressionIsNAN
		bne	ErrorOverflow
		move.l	d0,OPERAND.Immediate(a5)
		move.b	#MODE_IMMEDIATE,OPERAND.Mode(a5)
		move.b	#REG_IMMEDIATE,OPERAND.Reg(a5)
		rts

	;-------------------------------------------------------------------------------
	;	Check if the operand begins with - or (
	;-------------------------------------------------------------------------------

\TryIndirects:
	move.b	#MODE_INDIR,OPERAND.Mode(a5)		; Default: (an)
	cmpi.b	#'-',d0
	beq.s	\HolyShit
	cmpi.b	#173,d0
	beq.s	\HolyShit
	cmpi.b	#'(',d0
	bne.s	\EvalAbsolute
	bra.s	\HolyShit2

	;-------------------------------------------------------------------------------
	;	It could be (an), -(an), (an)+
	;	This is really a shit, because (\x) could be an absolute, or an indirect
	;	So we can't use the usual macro replacement, we must be sure that it will
	;	really be an indirect before performing such a replacement ><
	;-------------------------------------------------------------------------------

\HolyShit:
	move.b	#MODE_PREDEC,OPERAND.Mode(a5)
	addq.l	#1,a2
	cmpi.b	#'(',(a2)
	bne.s	\EvalAbsolute
\HolyShit2:
	addq.l	#1,a2
	MACRO_PARAM_RESTART
	movea.l	a2,a0
	bsr	IsAn
	tst.b	d0
	beq	ErrorInvalidOperand
	MACRO_PARAM_END
	cmpi.b	#')',(a2)+
	bne	ErrorInvalidOperand
	cmpi.b	#'+',(a2)
	bne.s	\NoPostInc
		cmpi.b	#MODE_PREDEC,OPERAND.Mode(a5)
		beq	ErrorInvalidOperand		; It can be predec and postinc in the same time ^^
		move.b	#MODE_POSTINC,OPERAND.Mode(a5)
\NoPostInc:	rts

	;-------------------------------------------------------------------------------
	;	It should be x16, x32, x8(an,yn), x8(pc,yn), x16(an), x16(pc)
	;-------------------------------------------------------------------------------

\EvalAbsolute:
	bsr	EvalExpression
	tst.w	d1
	bmi	\TryRegisters
	bne	ErrorOverflow

	MACRO_PARAM_RESTART
	cmpi.b	#'(',(a2)
	beq.s	\TryXan
	move.b	#MODE_ABSOLUTE,OPERAND.Mode(a5)
	move.b	#REG_ABSOLUTE_LONG,OPERAND.Reg(a5)	; Default: register x32
	move.l	d0,OPERAND.Absolute(a5)
	tst.w	OPERAND.Absolute(a5)
	bne.s	\Long
		move.b	#REG_ABSOLUTE_SHORT,OPERAND.Reg(a5)
\Long:	rts

	;-------------------------------------------------------------------------------
	;	It should be x8(an,yn), x8(pc,yn), x16(an), x16(pc)
	;-------------------------------------------------------------------------------

\TryXan:
	move.l	d0,OPERAND.Offset(a5)			; Save offset for all x(...) address methods. X mut be < 2^16
	tst.w	OPERAND.Offset(a5)
	bne	ErrorInvalidOperand

	addq.l	#1,a2
	MACRO_PARAM_RESTART
	movea.l	a2,a0
	bsr	IsAn
	tst.b	d0
	beq	\TryXpc
		MACRO_PARAM_END
		cmpi.b	#')',(a2)
		bne.s	\TryXanyn
			move.b	#MODE_OFFSET,OPERAND.Mode(a5)
			move.b	d1,OPERAND.Reg(a5)
			addq.l	#1,a2
			rts

\TryXanyn:
	move.b	#MODE_INDEX,OPERAND.Mode(a5)	; Save addressing method
	move.b	d1,OPERAND.Reg(a5)		; And an
\CommonBEW:
	cmpi.b	#',',(a2)+
	bne	ErrorInvalidOperand
	MACRO_PARAM_BEGIN
	movea.l	a2,a0
	bsr	IsAn
	tas.b	d1			; Set address register in the BEW
	tst.b	d0
	beq.s	\SaveBEW

	movea.l	a2,a0			; Else it should be a data register
	bsr	IsDn
	tst.b	d0
	beq	ErrorInvalidOperand
\SaveBEW:
	lsl.b	#4,d1			; Put the register mask at its place

	MACRO_PARAM_END			; Now check for .w/.l. Default to .w
	cmpi.b	#'.',(a2)
	bne.s	\EndBEW
		addq.l	#1,a2
		MACRO_PARAM_BEGIN
		move.b	(a2)+,d0
		ori.b	#$20,d0		; Lower case
		cmpi.b	#'w',d0
		beq.s	\EndBEW
		cmpi.b	#'l',d0
		bne	ErrorInvalidOperand
		bset.l	#3,d1
\EndBEW:
	move.b	d1,OPERAND.BEW(a5)
	tst.b	OPERAND.Offset+1(a5)
	bne	ErrorInvalidOperand
	tst.b	OPERAND.Offset+2(a5)
	bne	ErrorInvalidOperand
	MACRO_PARAM_END
	cmpi.b	#')',(a2)+
	bne	ErrorInvalidOperand
	rts

\TryXpc:
	move.b	(a2)+,d0
	lsl.w	#8,d0
	move.b	(a2)+,d0
	ori.w	#$2020,d0
	cmpi.w	#'pc',d0
	bne	ErrorInvalidOperand

	MACRO_PARAM_END
	cmpi.b	#')',(a2)
	bne.s	\TryXpcyn
		move.b	#MODE_PC,OPERAND.Mode(a5)
		move.b	#REG_PC,OPERAND.Reg(a5)
		addq.l	#1,a2
		rts

\TryXpcyn:
	move.b	#MODE_PC,OPERAND.Mode(a5)
	move.b	#REG_PC_INDEX,OPERAND.Reg(a5)
	bra	\CommonBEW

	;-------------------------------------------------------------------------------
	;	Last possibility: an, dn, usp, ccr, sr
	;-------------------------------------------------------------------------------

\TryRegisters:
	movea.l	a2,a0
	bsr	IsDn
	tst.b	d0
	beq.s	\NoDn
		move.b	#MODE_DN,OPERAND.Mode(a5)
		move.b	d1,OPERAND.Reg(a5)
		addq.l	#2,a2
		rts

\NoDn:	movea.l	a2,a0
	bsr	IsAn
	tst.b	d0
	beq.s	\NoAn
		move.b	#MODE_AN,OPERAND.Mode(a5)
		move.b	d1,OPERAND.Reg(a5)
		addq.l	#2,a2
		rts

\NoAn:	move.b	(a2),d0					; Read the 2 next chars, and put them in lower case
	lsl.w	#8,d0
	move.b	1(a2),d0
	ori.w	#$2020,d0

	cmpi.w	#'sr',d0
	bne.s	\NoSR
		move.b	#MODE_SR,OPERAND.Mode(a5)
		addq.l	#2,a2
		rts

\NoSR:	cmpi.w	#'cc',d0
	bne.s	\NoCCR
	move.b	2(a2),d0
	ori.b	#$20,d0
	cmpi.b	#'r',d0
	bne.s	\NoCCR
		move.b	#MODE_CCR,OPERAND.Mode(a5)
		addq.l	#3,a2
		rts

\NoCCR:	cmpi.w	#'us',d0
	bne	ErrorInvalidOperand
	move.b	2(a2),d0
	ori.b	#$20,d0
	cmpi.b	#'p',d0
	bne	ErrorInvalidOperand
		move.b	#MODE_USP,OPERAND.Mode(a5)
		addq.l	#3,a2
		rts

Et avec ça, mon programme dépasse les 9 ko, toujours sans un run, ça va donner le débogage #tricouic#

4092

et les tests unitaires ? embarrassed
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

4093

./4084 le materiel requis devient cher et rare, mais je confirme qu'il marche
avatar

4094

flanker (./4092) :
et les tests unitaires ? embarrassed

je sais même pas ce que c'est, meme si j'imagine quand meme que ça sert à vérifier le code bout par bout ?
Il y a au final plus de code de test que de code, non ? J'avais tenté un truc comme ça, mais ça va vite chercher loin, et ça prend du temps, meme en C...

4095

En effet, ça prend du temps, parfois plus que le codage lui même, personne n'aime les faire, mais s'ils sont bien fait et que tu automatise leur passage, ça devient un outil redoutable pour détecter immédiatement les régressions.
avatar

4096

Alors concrètement, tu t'y prends comment ? J'imagine que tu crées pas un projet pour chaque fonction, avec un makefile pour la compiler et l'appeler de la manière qui va bien ?

4097

ce que tu dis est possible, mais lourd. en général y'a un script pour automatiser l'execution de tous les tests.

Dans l'idéal il faut faire ça pour eviter les possibles interactions entre les tests.

sinon tu fais un projet separe qui appelle ta lib et execute tous les tests, un par fonction.
avatar

4098

squalyl (./4097) :
sinon tu fais un projet separe qui appelle ta lib et execute tous les tests, un par fonction.

J'ai fait ça pour ma lib, des tests en C, c'est pas mal en effet, je dirais que ça se met naturellement en place, parce qu'une lib est faite pour être appelée fonction par fonction, à peu près indépendamment les unes des autres.

Pour un programme, c'est pas la meme musique. Comment tester une fonction de mon assembleur hors environnement, sachant qu'il utilise un stackframe global, par exemple. Simuler un stack frame prend deux lignes c'est pas le problème, mais alors quid de la pertinence des tests ? J'ai pas loin de 10 ko d'asm sous la main, là, je me vois mal en écrire 20 autres pour valider les 10 sick

4099

Folco (./4096) :
Alors concrètement, tu t'y prends comment ? J'imagine que tu crées pas un projet pour chaque fonction, avec un makefile pour la compiler et l'appeler de la manière qui va bien ?
C'est a peu près l'idée, mais en général tu crées un seul projet séparé qui contient de très nombreuses fonctions de test. Chacune de ces fonctions fait des appels à la fonction de ton projet principal qu'elle teste, avec différents paramètres et vérifie que le résultat retourné est bien celui attendu.

Dans la plupart des langages il y a des framework pour aider à gérer ça, le plus connu étant JUnit pour le Java. Tu peux ainsi lancer l'ensemble de tous les test à n'importe quel moment pour vérifier que tu n'as pas introduit de régression sur des test qui passaient auparavant.

Je suppose que pour de l'assembleur, le modèle doit être légèrement adapté.
avatar

4100

Le truc de Folco est un programme sans utilisateur, c'est une œuvre d'art. Et on ne fait pas de tests unitaires pour une œuvre d'art embarrassed
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

4101

http://tempsreel.nouvelobs.com/monde/20141121.OBS5765/silicon-valley-vs-misere-valley-les-laisses-pour-compte-de-google-co.html
avatar
----- SNK Forever -----
Association Retro-gaming Connexion : http://www.retro-gc.fr/
http://www.consoles-portables.com

4102

J'avais oublié :
- les masques de registres pour movem
- les expressions mathématiques utilisant des constantes strings, genre 'abc', ou "45=@"
- les exigences de longueur sur les adressages absolus, genre move.l #$50.w,d0

C'est résolu.

4103

Folco (./4096) :
Alors concrètement, tu t'y prends comment ? J'imagine que tu crées pas un projet pour chaque fonction, avec un makefile pour la compiler et l'appeler de la manière qui va bien ?

En assembleur, ça doit être assez pénible, en effet grin

Dans d'autres langages, tu écris ta fonction normalement, et tu écris une fonction supplémentaire (ou plutôt une classe qui hérite d'une classe particulière) qui utilise ta fonction à tester.

Des outils vont ensuite parcourir ton code et trouver tout seul ces fonctions de test et les exécuter les unes après les autres. Ça enlève (un peu) le côté pénible des tests unitaires.
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

4104

Pour le code natif, un des bons frameworks de tests unitaires est GTest. On peut le compléter par GMock pour des tests plus avancés.
avatar
Membre de la TI-Chess Team.
Co-mainteneur de GCC4TI (documentation en ligne de GCC4TI), TIEmu et TILP.
Co-admin de TI-Planet.

4105

Et G68k, ya pas ? Hors de quetion de faire subir ça à mon code. Comme dit Zerosquare, c'est artistique. Et puis il est reviewé au moins 50 fois, donc ya peu de bugs. Tiens, je m'amuserai à les compter pendant mes tests, je vous tiendrai au courant. Je devrais meme organiser des paris. En général, j'ai un bug au ko.

4106

Vu que tu fais 65ko, ça va en faire beaucoup, quand même.
«Les gens exigent la liberté d’expression pour compenser la liberté de pensée qu’ils préfèrent éviter.» - Sören Kierkegaard

La République, c’est comme la syphilis : quand on l’a attrapée, soit on se fait sauter le caisson, soit on essaie de vivre avec.

4107

grin

4108

Pour Folco, Zerosquare, et ceux qui aiment le low level.

http://www.nuttx.org/doku.php?id=wiki:nxinternal:initsequence
avatar

4109

raaaaaaaaaaaaaah merci pour ce lien !! love

4110

Poussons un 'rts' sur la pile : move.w #$4E75,-(sp)
Exécutons maintenant : jsr (sp)

Alors, que se passe-t-il ?
1. L'adresse suivant le jsr est empilée, puis exécutée vu qu'elle est à (sp), et donc on a très probalement un crash ?
2. PC est mis à l'adresse du $4E75, puis PC+2 est poussé sur la pile, et est donc dépopé à l'instruction suivante, quand le rts est exécuté ? Dans ce cas-là, c'est comme s'il ne s'était rien passé, les flags ne sont meme pas touchés.

A votre avis, il se passe quoi ? smile
Aide Charte Contacts Crédits Réalisé avec yAronet 69 ms