2nd, Alpha, Shift & puissances - Page 1

On va économiser les topics, g attendu d'avoir 2 questions pour poster

1) Comment faut-il faire pour activer//désactiver l'alpha, le 2nd et le shift dans un programme en C

2) C koi le symbole des puissances en C (j'ai essayé ^ mais visiblement c pas ça...)

Les indicateurs sont géré par l'AUTO_INT_1
=> désactive l'AU1, et tu ne les auras plus (il me semble que c dit dans la FAQ de TIGCC)
par contre, il te faudra utiliser _rowread pr lire le clavier... car toutes les autres fonctions reposent sur l'AU1


Il n'y a pas de symbole pr les puissance, car le C ne défini pas d'opérateur pour cela.
Il faut utiliser la fonction pow me semble-t-il
pow(x, y)
=> x puissance y : x^y
http://tigcc.ticalc.org/doc/timath.html#pow

pas de puissance en C ???
me semblait pourtant

enfin, il me semble qu'il n'y a pas d'opérateur de puissance.

l'opérateur ^ sert pour des XOR bit à bit

oui ou alors je pense au C sur ordi.
p-e que certain compil l'on ajouté

ca doit etre d'origine dedans ...
sinon, si tu veux un algo .. c pas dur

ouai je sais ca...

C sur PC et C sur TI, c'est le même language....

oui mais pas les mem compilo

Ok, merci pr Pow

Heu par contre les indicateurs, c pas pour ne plus les voir, c pour pouvoir depuis mon programme les activer ou les désactiver (comme l'alpha lock quand on ouvre une boite de dialogue).

microbug> "pas les mêmes compilo"... je me trompe peut-être, mais il me semble que TIGCC est basé sur GCC, qui est un compilateur conçu pour PC, non ?
Et, en plus, TIGCC se dit conforme à la norme GNU-C, et se doit donc de respecter les mêmes standard que les compilo GNU-C sur PC (c'est à dire quelques trucs de plus que les compilo ANSI-C qui sont habituellement utilisés sur PC)

Bob> Kevin avait donné sur ce forum il y a quelques temps des routines pour la gestion de Alpha-lock.
Je les reposte, mais c lui qu'il fo remercier.

char AlphaLockSaveState; 

void AlphaLockOn(void)
{ 
	if (*((*(long **)0xc8)-1)<=1155) 
	{
		AlphaLockSaveState=*((char *)*(*((*(short ***)0xc8)+0x96)+4)+0x1f); 
		*((char *)*(*((*(short ***)0xc8)+0x96)+4)+0x1f)=1;
	}; 
	else 
	{
		_rom_call(void,(char*),481)(&AlphaLockSaveState); 
	}; 
}; 

void AlphaLockOff(void)
{ 
	if (*((*(long **)0xc8)-1)<=1155) 
	{
		AlphaLockSaveState=*((char *)*(*((*(short ***)0xc8)+0x96)+4)+0x1f); 
		*((char *)*(*((*(short ***)0xc8)+0x96)+4)+0x1f)=0;
	}; 
	else 
	{
		_rom_call(void,(char*),482)(&AlphaLockSaveState); 
	}; 
}; 

void RestoreAlphaLock(void)
{ 
	if (*((*(long **)0xc8)-1)<=1155) 
	{
		*((char *)*(*((*(short ***)0xc8)+0x96)+4)+0x1f)=AlphaLockSaveState;
	}; 
	else 
	{
		_rom_call(void,(char*),483)(&AlphaLockSaveState); 
	}; 
};

Bah merci à toi quand même, je ne savais pas que ça avait déjà été posté (dsl pr le topic du coup )

Et puis merci à Kevin, mais il commence à être habitué

c'est un des petits trucs que je garde sur mon Dur...
le genre de choses qui peut servir

Et pour le 2nd et le Shift, t'aurais pas les codes par hazard ?

pour le shift et le 2nd ce sont des bits a cote de celui de alpha lock je crois car je lavais fais dans un jeu en assembleur mais le probleme cest que si tu coupes pas les interruptions en plus des bits a desarmer ya aussi des choses a faire dans levent structure (ou un truc du genre) de lams...
pour savoir quels bits desarmer tu telecharges lauto alpha lock de kevin kofler tu regardes les sources et avec vti tu tamuses a regarder ce que font les bits autour de celui de alpha lock quand tu touches a shift et a seconde (attention lemplacement des bits change a chaque ams mais ils sont places de lameme facon les uns par rapport aux autres)
pour le truc de lams avec levent structure ou je sais pas quoi je connais po....
voila les sources en asm que javais utilise dans mon falldown auquel personne doit joue :

movea.l AB_prodid*4(a5),a0 ;get AMS version
 jsr (a0)
 addq.w #4,a7
 move.l #$75ab,alpha ;ajuste l'adresse
 cmp.b #'0',buffer+5 ;teste 1.00
 beq start
 move.l #$75b3,alpha ;ajuste l'adresse
 cmp.b #'3',buffer+5 ;teste 1.05
 beq start
 move.l #$79af,alpha ;ajuste l'adresse
 cmp.b #'5',buffer+5 ;teste 2.01
 beq start
 move.l #$79b3,alpha ;ajuste l'adresse
 cmp.b #'6',buffer+5 ;teste 2.02
 beq start
 cmp.b #'7',buffer+5 ;teste 2.03
 beq start
 move.l #$6497,alpha ;ajuste l'adresse
 cmp.b #'8',buffer+5 ;teste 2.04
 beq start
 move.l #$649b,alpha ;ajuste l'adresse
 cmp.b #'9',buffer+5 ;teste 2.05
 beq start
 clr.b alpha ;version non supportée
start: ;version de AMS compatible

(pour connaitre la version dams et lemplacement des bits sur TI 89 attention)

tst.l alpha
 beq loop_name
 ;enleve tous les modificateurs
 movea.l alpha(pc),a0
 clr.b (a0)+
 clr.b (a0)+
 clr.b (a0)+
loop_name:

(et voila ca met tous les indicateurs a zero mais ca ne les effacent pas de lecran hein, enfin je pense po)

et pis il faut aussi un chtit alpha dc.l 0 pour stocker ladresse voila

ah oui il faut aussi savoir que dans a5 ya ladresse de la table des rom_calls (il suffit de faire movea.l $c8,a5 et pis ya buffer ds.b 20 pour stocker le resultat renvoye par AB_prodid

Ah ouais mais... Tu l'as pas en C qq part ?

'tain je comprend rien à l'ASM ...

Moi non plus. Et c pas une raison pour flooder mon topic

J'avais recherché les flags pour 2nd, diamond... y'a quelque temps. Cherchez ici : [URL]http://membres.lycos.fr/extended/ti_files/flags.html[/URL] mon post. En C il suffit d'utiliser du AND et du OR avec des nombres binaires.

ben cest les adresses que jai donnees nan ?

Ouha l'ancien yaronet

Ah une question qui n'a rien à voir :

Peut on remplacer un :

if(strcmp(chaine,"hello"))
{
...
}
else if(strcmp(chaine,"world"))
{
...
}
etc...

par un switch, et si oui comment ?

pit-etre que ca marche :

unsigned char chaine[] = "....";

swith(chaine)
{
case chaine == "hello":
{...}
case chaine== "world":
{...}
default: {}
}

je v essayer, mais m'étonnerais que ça marche, puisque normalement il faut utiliser strcmp pour comparer des chaines

Edit : Non ça marche pas
[edit]Edité par Bob 64 le 10-04-2002 à 13:57:01[/edit]

>jpflori : apparement non.

cest bizarre pasque moi jeatis parti de ladresse de alpha lock dans les sources de auto alpha lock de kevin kofler et javais bidouille vti et son debugger en appuyant sur ces touches et apparemment ca marchait dans mon programme deffacer ce que jefface menfin doit yavoir plein dautres trucs dans lams cest lourd

Mon flag vire tous les indicateurs d'un coup, et c'est un flag officiel, même si il n'est pas réferencé comme variable globale. Je l'ai trouvé sans bidouiller au pif, en désassemblant.

jai pas bidouille au pif quand meme je me suis mis a ladresse de laoctet ou ya le bit de auto alpha lock et jai regarder comment reagissaient les bits tout autour quand on appuyait sur shift et seconde ou toute combinaison de ces touches sur plusieurs versions dams et apres avoir fait des tests ca marchait tres bien et puis ca faisait pas planter ni vti ni ma calc pasque jai cherche su^per longtemps dans la doc de tigcc mais yavait rien voila

Oui, c'est ce que j'appel chercher au pif (y'a pas de mal à ça, je l'ai dejà fait).
Mais mon flag est utilisé officiellement par l'AMS, directement, et je sais (enfin je savais) quelles roms calls l'utilisaient, donc je savais parfaitement si ca faisait bien ce que je pensait que ça faisait.

Enfin on va pas se battre pour un flag (que je n'ai jamais utilisé d'ailleurs).