Bonjour!

Je voudrait savoir comment changer la taille d'un programme depuis un programme en asm (sur une ti 83).
J'ai trouvé les fonctions suivantes:
_editProg
_closeProg
D'après ce que j'ai compris, il faut appeler _editProg, modifier la taille du programme (mais ça je n'ai pas compris comment), puis confirmer avec _closeProg...

Est ce que vous pourriez m'expliquer comment on modifie la taille du coup svp?
Merci d'avance!
Je ne sais pas si tu as lu cet article : http://wikiti.brandonw.net/index.php?title=83Plus:OS:Edit_Buffers

Par contre j'ai l'impression qu'il s'agit surtout de romcalls pour travailler avec des programmes TI-Basic, non ? Enfin j'ai seulement lu en diagonale l'article, donc je me trompe peut être.

À mon avis le plus simple reste d'utiliser _InsertMem pour ajouter des données à la suite d'une variable (par contre il faudra mettre à jour soit même les 2 octets qui en définissent la taille total dans l'header).

Si tu utilises Ion il y a une routine pour trouver l'adresse d'un programme : ionDetect.
Si tu sais le nom du programme il y a aussi le bcall _ChkFindSym. La façon la plus facile est d'utiliser _InsertMem et puis mettre à jour les 2 octets de taille du programme. Mais qu'est-ce que tu veux faire exactement ?
Ok merci, j'utilise _ChkFindSym de toute façon puisque j'ai besoin de manipuler les infos contenues dans le prgm, et je trouve que c'est plus pratique à utiliser (je veux dire que comme ça j'évite de dépendre des routines de ion)
Je vais donc utiliser insertMem (en fait mon prgm que je veux agrandir sert de fichier pour stocker des informations, c'est si j'ai de nouvelles informations à stocker que je dois agrandir sa taille.

Merci à tous les 2 pour votre aide! smile
Et un petit rappel : _insertMem ne peut insérer du mémoire que à la fin du variable. Qu'est-ce que c'est ton projet ? C'est toi qui, il y a quelques moi, bossais sur un jeu Snake multijoueur, n'est-ce pas ? smile
Mon projet c'est de faire une sorte d'éditeur de texte on-calc, pour rentrer mes cours sur ma ti principalement grin
Ce que je veux faire, c'est un programme assez léger (1-2 ko max), et que les fichiers contenant les cours soient petits également (1o/caractère), mais en présentant un affichage sur l'écran graphique, pour que ce soit plus pratique encore à rentrer qu'en tapant du texte brut depuis l'éditeur de programme, et avoir une meilleure visibilité des informations.

Et oui, c'est moi qui bossait sur un snake multijoueur en fin d'année dernière.
J'avais finalement réussi à le faire marcher, et puis je n'ai plus eut le temps de faire trop d'asm (j'avais quelques projets en C/C++).
Maintenant que le bac est passé, j'ai décidé de m'y remettre, et après avoir fini mon éditeur de textes, je modifierai quelques trucs sur mon snake, d'après les remarques qui m'ont été faites dessus.

J'ai une autre question:
J'ai besoin d'une routine qui marcherait exactement comme Input/Prompt en Ti-Basic pour récipérer une chaine de caractère (c'est pour le nom du programme, et je n'ai pas trop envie de la coder moi-même puisque je vais faire une routine à peu près semblable pour la fonction principale de mon éditeur... sur l'écran graphique alors que je préfèrerais rentrer le nom du prgm sur l'écran standard)
J'ai trouvé ceci (sur le tuto d'asm guru):
        ld a,0
        ld (asm_ind_call),a
        call pgmio_exec
        call _chkfindsym

Malheureusement, ça n'a pas l'air de fonctionner sur la ti-83 (il y a bien un input, jusque là tout va bien, puis la calto, peu après avoir exécuté cette instruction (pgmio_exec) se met à ne plus répondre...)

Est ce que vous savez pourquoi?

Sinon c'est pas grave, je pense que je vais faire lancer à mon prgm un prgm en basic qui contiendrait une simple instruction d'input, ça sera aussi simple.
Est-ce que tu utilises ion ? Peux-tu essayer avec une version nostub ? Je crois que pgmio_exec utilise cmdShadow, où ion a mit quelques routines pour nettoyer tout après avoir quitté le programme et il y a aussi la table de sauts pour les routines d'ion.

Mais c'est assez facile d'écrire ta propre routine d'input si tu utilises _getCSC. Pour un exemple, tu peux regarder le source de Phoenix (score12.asm, enter_name_loop) :
;ix = où sauver le string
enter_name_loop:
        call    GET_KEY
        or      a
        jr      z,enter_name_loop
        cp      KEY_CODE_DEL
        jr      z,backup
        cp      KEY_CODE_ENTER
        ret     z
        ld      c,a
        ld      a,10
        cp      b
        jr      z,enter_name_loop
        ld      hl,chartable-10
        ld      e,c
        ld      d,0
        add     hl,de
        ld      a,(hl)
        ld      (ix),a
        ROM_CALL(TX_CHARPUT) 
        inc     b
        inc     ix
        jr      enter_name_loop
backup: xor     a
        cp      b
        jr      z,enter_name_loop
        dec     b
        dec     ix
        ld      (ix),32
        ld      hl,CURSOR_COL
        dec     (hl)
        ld      a,32
        ROM_CALL(TX_CHARPUT)
        dec     (hl)
        jr      enter_name_loop

chartable:
        .db     ":WRMH."
        .db     "..0VQLG!..ZUPKFC"
        .db     "..YTOJEBX.>SNIDA"
        .db     ".12345.."
Il faudrait faire quelques petites modifications de style (par exemple, changer "ROM_CALL" par "call") parce que Phoenix a été écrit pour être compatible entre toutes les caltos z80. N'hésite pas à demander si tu as des questions smile
Il y a différentes routines qui font ça aussi (apparemment) sur ticalc :

http://www.ticalc.org/archives/files/fileinfo/162/16275.html
http://www.ticalc.org/archives/files/fileinfo/399/39936.html
http://www.ticalc.org/archives/files/fileinfo/304/30452.html
http://www.ticalc.org/archives/files/fileinfo/398/39824.html

N'hésite pas à poster ton code source si tu as besoin d'aide pour des optimisations ou autre (d'ailleurs je pourrais l'adapter pour 83+ si tu veux) smile
Merci pour toutes ces routines, mais comme je l'ai dit je cherche à utiliser au maximum les rom calls de la ti pour économiser de la place (quitte à y perdre en vitesse c'est pas trop grave).
Je ferai ma propre routine d'input mais en petits caractères, pour l'écran standard je préfère utiliser la routine qui est dans la ti.

J'ai essayé avec une version nostub, et ça marche impec' (sauf que la taille est multipliée par 2 du coup.
Sinon j'ai essayé en faisant un Input "",Str0 depuis un prgm basic que je lance depuis mon prgm asm, mais j'ai le même problème: tout marche impec jusqu'à ce que je quitte le prgm et que je retourne sur ion, qui se met à boguer...

Est ce qu'il y aurait un shell qui supporterai d'utiliser pgmio_exec ?

Et merci beaucoup pour votre aide top (je posterai mon code pour voir s'il y a des optimisations à faire (et je sais qu'il y en a roll ), mais d'abord je préfère avancer un peu dans mon code, parce que là pour l'instant c'est le bazar ^^)
Je viens de trouver la romcall _GetStringInput pour TI 83+ mais elle ne semble pas exister/être documenté sur 83 :/

Et inversement pgmio_exec n'existe plus sur 83+.

Donc dans tous les cas le plus simple c'est effectivement d'écrire ta propre routine d'input (sur l'écran d'accueil et sur l'écran graphique), mais sauf si tu tiens vraiment à le faire toi même, je te conseil d'utiliser celles de ticalc : elles permettent sans doute d'utiliser plus de caractères que seulement les lettres, d'utiliser les majuscules/minuscules etc...

Apparemment je crois que le shell Venus n'utilise pas cmdShadow, mais il ne permettra pas de porter facilement ton programme sur 83+ (du moins si utilises toujours pgmio_exec).
Merci, je vais tester avec Vénus.
EDIT: Vénus supporte pgmio_exec smile
Au pire, pour la portabilité vers une 83+, je mettrai l'en tête et la fonction d'input sous #ifdef, et j’essayerai avec un shell compatible pour 83+ qui n'empêche pas d'utiliser GetStringInput (mais je verrai une fois que mon code sera finis ^^)

Pour la routine d'input sur l'écran graphique, je vais le faire moi même (pour gérer l'encodage des fichiers plus facilement et pour permettre d'ouvrir des "menu" directement depuis l'éditeur, et ça me permettra aussi de progresser smile )

Une autre question: ce n'est pas très important, mais est-ce qu'il est possible de définir une taille maximale pour la chaine qu'on demande en input? Et de limiter les caractères à ceux utilisés pour nommer les prgm (A-Z 0-9) ?

Merci d'avance!
mathieu41 (./11) :
Une autre question: ce n'est pas très important, mais est-ce qu'il est possible de définir une taille maximale pour la chaine qu'on demande en input? Et de limiter les caractères à ceux utilisés pour nommer les prgm (A-Z 0-9) ?


Avec la romcall pgmio_exec ou _GetStringInput ? Je ne pense pas (mais en même temps je n'arrive pas à trouver de doc sur les paramètres).

Par contre cette routine semble le faire : http://www.ticalc.org/archives/files/fileinfo/399/39936.html
Oui c'était pour pgmio_exec mais c'est pas grave, je vais me débrouiller ^^
Merci!
Au fait, maintenant j'arrive à ajouter des octets à un programme, mais comment on fait pour réduire sa taille?
On doit le faire manuellement, ou on doit utiliser une rom call qui fait ça "proprement"?

Merci d'avance! smile
Ça je ne sais pas, il suffit peut être de changer la taille du programme dans son header ? Il y a peut être quelque chose à faire avec la VAT aussi.

Le mieux serait de copier en RAM le programme-texte que tu ouvres avant de le supprimer puis de le recréer entièrement en quittant l'éditeur (pour la sauvegarde), mais ça prendra plus de mémoire et du coup ce n'est pas dit que ce soit la meilleur chose à faire sur TI 83.
J'y ait pensé, mais le problème c'est qu'en plus ça limite la taille du prgm (par exemple si je stocke tout dans saferam1, j'ai ~760 caractères maximum, alors que si je reste dans le prgm, j'en ait autant que de mémoire disponible...
Sinon j'ai pensé à un système par page, mais ce serait plus compliqué à gérer...
Par contre:
chickendude (./5) :
Et un petit rappel : _insertMem ne peut insérer du mémoire que à la fin du variable.

Ceci est faux (à tout hasard j'ai essayé d'en insérer au milieu du prgm et ça a marché impec)
La Ram est insérée après l'adresse donnée, en fait je crois qu'il n'y a qu'un "décalage" des bytes après cette adresse, de hl octets, puis la rom call met à jour les adresses dans la VAT des variables situées après cette adresse (donc on peut insérer de la mémoire au milieu d'une variable, ça marche très bien wink )

J'ai presque fini ma routine qui gère les nouveaux fichiers (mais qui restent vide malheureusement ^^), et mon menu affiche tous les fichiers dispo (sans édition ni lecture mais ça m'a permis de me familiariser avec les routines qui gèrent la mémoire je devrait aller plus vite maintenant)
Dès que je l'ai fini, je la posterai, si vous avez le temps, dites moi quelles optimisations/modifications je pourrais apporter, et si vous avez des conseils sur ma façon de coder/commenter, etc, je suis tout ouïe ^^

Et encore merci pour votre aide! smile
mathieu41 (./14) :
Au fait, maintenant j'arrive à ajouter des octets à un programme, mais comment on fait pour réduire sa taille?On doit le faire manuellement, ou on doit utiliser une rom call qui fait ça "proprement"?
Il y a le ROMCALL _delMem smile