Pour moi il y a clairement un problème.
Je me demande si un jour quelqu'un a réussi a compiler un code pour ti83 avec spasm/z80asm/zasm sous linux (spasm existe sous windows).
De mon cote, après plus de 200 hello world foireux, des topics sur 3 forums, plusieurs conversations sur irc, je n'ai trouvé personne qui fasse de l'assembleur pour ti83 sous linux...
(Mais je ne suis pas catégorique, il ne s'agit que de suppositions)
Je m'explique :
z80asm et spasm générent le même code.
Du moins sur les échantillons testés...
Par exemple pour ce code :
.NOLIST
#define equ .equ
#define EQU .equ
#define end .end
#include "ti83asm.inc"
#include "tokens.inc"
.LIST
.org 9327h
call _CLRLCDFULL
ret
.end
END
Donne (avec z80asm et spasm) :
CD 55 47 C9 .UG.
Avec CD = call
55 47 = addresse de la rom call.
C9 = ret
(de même 21 01 00 équivaut à "ld hl,1" etc...)
Tasm, lui, pour le même code génére :
3A 30 37 39 33 32 37 30 30 43 44 35 35 34 37 :07932700CD5547
43 39 45 42 0D 0A 3A 30 30 30 30 C9EB..:0000
30 30 30 31 46 46 0D 0A 0001FF..
Beaucoup plus long, et rien de commun au niveau de l'hexa.
Ici on a :
0D 0A 3A 30 30 30 30 30 30 30 31 46 46 0D 0A
Qui doit correspondre à la chaine End:0000:End
Ou du moins le délimiteur qui dit "ici c'est fini".
Avec zasm (toujours le même code) :
3A 30 34 30 30 30 30 30 30 43 44 35 35 34 37 43 :04000000CD5547C
39 43 41 0D 0A 3A 30 30 30 30 30 30 30 31 46 46 9CA..:00000001FF
0D 0A ..
Ca ressemble... mais comme après bin8x ou bin2var ne font pas du tout le même boulot que Obj83.exe, au final ce ne sera pas bon !
(ils oublient de transformer 0D 0A 3A 30 30 30 30 30 30 30 31 46 46 0D 0A en 3F D4 3F 30 30 30 30 3F D4 )
Pour conclure, je pense que le code généré par spasm et z80asm ne correspond pas à ce qu'attend la ti83.
On ne peut pas se dire qu'il y a un probleme de compilation, car les 2 outils produisent le même code, et de plus z80asm (tout comme spasm?!) est un outil fiable.
De plus, compiler pour TI83PLUS marche parfaitement.
Mon idée est que la TI83PLUS est plus "tolérente"...
Notamment la méthode Asm( ne doit pas executer le code de la même manière que Send(9 ...
Je ne me suis évidemment pas arrété là...
J'ai remarqué qu'il y a correspondance entre les code spasm/z80asm et TASM.
Regardez bien : CD 55 47 C9 apparait à droite dans l'équivalence en caractère pour TASM et en tant que code hexa pour spasm/z80asm.
De plus, TASM rajoute une chaine de fin qui est absente du code de z80asm/spasm.
Autre chose, mais qui ne semble pas nécessaire pour l'instant :
L'adresse 9327 apparait chez TASM et pas chez spasm/z80asm.
Elle ne semble pas absolument nécessaire... (c'est plutôt étonnant!)
zasm (compilateur du projet LPG) est assez proche de TASM niveau code.
Mais il y a des variantes, et le code 83P avec bin8x ou bin2var ne donne rien qui aille.
Finalement, voici un convertisseur, à appliquer sur un code .bin avant de le passer à la moulinette bin2var :
#include <stdio.h> /* standard input output header */
#include <malloc.h> /* malloc */
#include <string.h> /* strcpy */
/* You should use spasm or maybe z80asm to compile your files */
/* zasm seems not working :( */
/* After generate the new *****.bin, you must use bin2var (bin8x seems not working) to generate a 83p file */
int main(int argc, char * argv[]) {
FILE * fpr;
FILE * fp;
int e;
char * outfilename;
char c;
char end[] =
{0x3F ,0xD4 ,0x3F ,0x30 ,0x30 ,0x30 ,0x30 ,0x3F ,0xD4};
printf("bin2bin83 by Thibault Duponchelle <t.duponchelle@gmail.com>\n\n");
/* open bin files */
if(argc<2) {
printf("*******Not enough args*******\n");
printf("usage : bin2bin83 input.bin [output] \n");
printf("output is not necessary, by default \"output.bin\" will be generated.\n");
printf("output parameter must be like this : \"WORM\" NOT like \"WORM.BIN\".\n");
printf("Example : 'bin2bin83 foo.bin BAR'\n");
printf("The output will be \"BAR83.bin\".\n(note : '83.bin' have been automatically added).\n");
return 0;
} else {
if((fpr = fopen(argv[1], "r+b"))) {
if(argc>2) {
outfilename=malloc(strlen(argv[2])+6);
strcpy(outfilename,argv[2]);
strcat(outfilename,"83.bin");
if(!(fp=fopen(outfilename,"w+b"))) {
printf("CAN NOT open output.bin");
fclose(fpr);
return 1;
}
}else {
outfilename=malloc(strlen("output.bin")+1);
strcpy(outfilename,"output.bin");
if(!(fp=fopen(outfilename,"w+b"))) {
printf("CAN NOT open output.bin\n");
fclose(fpr);
return 1;
}
}
while((e=fgetc(fpr))!=EOF)
{
//printf("%c= %02X ",c, c); //Print hexa code could bug the console ;D
fprintf(fp,"%02X",e);
}
fwrite(&end,9,1,fp);
printf("output : %s\n",outfilename);
fclose(fp);
fclose(fpr);
} else {
printf("CAN NOT open %s\n",argv[1]);
}
printf("Please send me your feedback : <t.duponchelle@gmail.com>\n");
return 0;
}
}
Compiler ce fichier puis :
>spasm toto.asm
>./bin2bin83 toto.bin tata.bin
>bin2var tata.bin TATA.83P
Et là ca marche !!!
C'est quand même hallucinant, tous les octets du fichier binaire d'entrée sont modifiés...
Mais le fichier final est correct et il comporte en plus la chaine de fin représentée ici par :
char end[] =
{0x3F ,0xD4 ,0x3F ,0x30 ,0x30 ,0x30 ,0x30 ,0x3F ,0xD4};
Voila, si quelqu'un peut me dire si je me trompe, si ce n'est pas absolument nécessaire...
Je serai content de l'entendre.
Mais en attendant, même LongWorm.z80 compile avec ça
J'espère que ce sera utile à quelqu'un.
Dites moi s'il faut y apporter des modifications, si j'ai fait une erreur quelque part (sur l'Asm, le C est baclé)
Rien n'est gravé dans la pierre.
Thibault Duponchelle
