Ah pourtant il y est /etc/bashrc sur mon système ... bizarre que ça ne fonctionnât pas avant que j'édite auparavant le fichier ~/.bashrc (Ca me laisse perplexe.)
Lionel Debroux (./50) :
Il n'y a pas d'outil dans la TIGCC Tools Suite qui fasse directement la conversion, mais je pense qu'en enchaînant un script très similaire à celui que que j'ai posté, et des outils de la TIGCC Tools Suite, il est faisable d'écrire un convertisseur qui tourne sur l'ordinateur.
D'accord, mais je pense que le plus pratique pour moi, c'est d'inventer un "coupeur de chaines exec", qui les coupe dès qu'une ligne d'instruction asm .
Ex : "move.l #5,do" ne fera qu'une seule et même chaine Exec), de les écrire séparement dans une liste TI-BASIC, et de les concaténer ensuite (concaténation alors bien sûr, automatisée
Je pense à un truc du genre :
:AllExec(liste)
:Prgm
:""->sortie
:For i,1,dim(liste)
:sortie & liste[ i ] -> sortie
:EndFor
:EndPrgm
Le seul regret à ce moment-là, serait de ne pouvoir utiliser la fonction directement combinée avec la commande Exec
=> AllExec(liste) : Exec sortie.
D'ailleurs je l'ai fait avec la liste {"4e75","0000"}; qui est censée ne rien faire en Exec .
allexec({"4e75","0000"}):exec sortie
me redonne immédiatement la main avec le message Done
J'ai également réussi avec la liste qui permet d'éteindre la calculette .
Les césures de la chaine Exec ne seraient pas obligatoirement à la fin de chaque instruction asm (y compris avec leurs valeurs immédiates, masque de movem ...) mais cela aurait pu avoir un double intérêt pédagogique et de "déboggage"
Je serais prêt à essayer (essayer
) de faire cette conversion "coupée", mais que pour le langage ASM sans librairie et sans table de relocation, et autres complications du genre ...
Je penserais même à une stratégie genre (en POO si c'est le plus pratique, je le poste vraiment de manière très barbare
. Ce n'est toujours qu'une idée ...)
1) Je code la liste de toutes les instructions avec des "trous" à la printf : movem =>01001%0001%1%2%3, où %0 = (Direction,1bit), %1 = (Taille, 2 bits), %2 = (ModeAdressage, 3 bits), %3 = (ValeurAdressage, 3bits)
2) Je code tous les "remplissages de trous" possibles, pour l'ensemble des instructions
Ex : (ClasseValeursStatique)Direction =
{ ("Registre->Memoire",sensNormal = true,0),
("Memoire->Registre",sensNormal = true,1),
("Registre->Memoire",sensNormal = false ,1),
("Memoire->Registre",sensNormal = false,0) }
Ce sont quelques bases de la sratégie que j'aurais utilisée .
Allez, je vais aussi être un peu fou : pourquoi n'essaierais-je pas de faire un truc du genre, pour une unique instruction asm, en TI-BASIC ? (une seule instruction ... à cause du temps que cela risque de prendre) .
Je télécharge les sources 
. Même si je retiens bien une fois que j'ai réussi ...) Je le demande parce que j'ai vu sur un autre post que le codage EXEC et le codage ASM - sans forcément parler de signature de fichier (0000 pour les exec) - ce n'est pas tout à fait la même chose .
(Je pense que vous savez déjà pourquoi ...)
