ça serait cool une bonne doc - Page 1

des fonctions builtin etc...
parceque vu que j'avais laissé tomber à l'époque où on m'avait +/- fait chier sur le format d'exe (du coup j'avais pourri mon code) alors que je m'appretais à sortir un editeur de textes...
maintenant qu'on pourrait avoir un bon système, je me laisserais bien tenter

pour ceux qui se rappelent c'etait un editeur de textes formatés avec niveaux de gris, images, tableaux, polices,styles,... le tout sur 40ko en pur C qui marchait bien vite
(nEUrOne avait testé une des premières béta je crois, le reste etait resté privé)

si ça tente du monde, bien que je doute en fait de l'utilité du truc, je dois pouvoir pondre une genre de "suite bureautique"
(traitement de textes, tableur, editeur de d'images/formules) le tout sur 128k(pour le style)

Tu parles de quoi exactement ?

ah ouais c'est vrai,
je me suis relu et j'ai rien compris

je disais: ça serait cool que tu nous fasse une bonne doc des fonctions/formats parce-que je me mettrais bien à coder une app ou un prog de suite bureautique
mais sans doc de qualité, ça chie
(même si c'est succint, ça va mais faut que ça soit exhaustif)

heu oui

d'ailleur, tout est compatible.. si je cree un prog avec XLib il sera comp?

Ce qui marche :
+ Les fonctions AMS.
+ Les fonctions PedroM
+ Les libraries kernel.

Ce qui marche pas :
+ Les librairies statiques.
+ Donc les fonctions internes de tigcc.

j'avais une autre question, les scan de touches, ça se fait en hard ou t'as codé une routine?
si le ngetchx est en hard et que c'est aussi lent que sur ams ça chie
(j'avais commencé une routine de scan en asm bien barbare qui connait tous les codes de ngetchx et qui fonctionne pareil, si ça t'interesse mais bon vu que mon niveau n'a rien a voir avec le tien, j'imagine que tu peux en pondre une en 2 sec)      include "OS.h"      xdef _ti89      xdef _ti92plus      xdef _nostub CALCULATOR equ 1 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; main routine      movem.l d3-d7/a2-a6,-(a7)      move.w #$0700,-(a7)      ROM_CALL OSSetSR      addq.l  #2,a7 _loop: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;      ;; TEMP                                   ;;      ;on affiche le code de la touche pressée      and.b #$FD,$70001D      jsr _kb_getkey      move.w d0,d4      move.w d0,-(a7)      pea.l  printstr      jsr printf           addq.l #6,a7      ;on quitte si on presse esc (264)      cmp.w #264,d4      bne _loop      or.b #$2,$70001D ;; /TEMP                                  ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;                 movem.l (a7)+,d3-d7/a2-a6      rts      printstr:      dc.b "arf(:-p): %d, ",10,0 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;        SCANKEY ROUTINE BY jan²2        ;; ;; renvoie les mêmes codes que  ngetchx() ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; _kb_getkey           eor.l   d0,d0 ;on clean d0: dans lequel sera stocké l'index      moveq.l     #1,d2      lea  _kb_key_masks(PC),a0 ;on fait pointer a0 - le tableau de masques ;detection de la calto(6 ou 7 rows suivant le modele)      tst.b CALCULATOR      beq _kb_calc92_row      move.l #5,_kb_numrows      add.l #6,a0 _kb_calc92_row ;boucle pour chaque row ;     move.l  _kb_numrows(PC),d3 ;compteur de row      move.l _kb_numrows,d3 _kb_getkey_loop_row ;recuperation de la row      move.w  (a0),$600018 ;masque      lsr.l   #6,d1      lsr.l   #6,d1      move.b  $60001B,d1 ;on recupere la row dans d1      addq.l  #2,a0 ;boucle pour chaque col      move.l  #7,d4 ;compteur de col _kb_getkey_loop_col                lsr.b   d2,d1      bcc     _kb_getkey_lastrow ;on quitte si detection d'une touche      add.l   d2,d0 ;on incremente d0 (index)      dbra    d4,_kb_getkey_loop_col ;fin de boucle col      dbra    d3,_kb_getkey_loop_row ;fin de boucle row ;derniere rangée      _kb_getkey_lastrow ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; rangée 0      move.w  #$FFFE,$600018 ;masque du bit 0           lsr.w   #6,d1      lsr.w   #6,d1      move.b  $60001B,d1 ;on recupere la row ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;detection de la calto      eor.l d3,d3      tst.b CALCULATOR      beq _kb_calc92_retval      cmp.w #48,d0      bne _kb_calc89_endarrows ;lecture des flèches      lsr.b   d2,d1      bcc     _kb_calc89_endarrows ;on quitte si detection d'une touche      add.l   d2,d0 ;on incremente d0 (index)      lsr.b   d2,d1      bcc     _kb_calc89_endarrows ;on quitte si detection d'une touche      add.l   d2,d0 ;on incremente d0 (index)      lsr.b   d2,d1      bcc     _kb_calc89_endarrows ;on quitte si detection d'une touche      add.l   d2,d0 ;on incremente d0 (index)      lsr.b   d2,d1      bcc     _kb_calc89_endarrows ;on quitte si detection d'une touche ;quitte avec 0 si aucune touche n'est pressée      moveq.w #0,d0      rts _kb_calc89_endarrows ;lecture des stat keys      lsr.b   d2,d1      bcc     _kb_calc89_2nd      lsr.b   d2,d1      bcc     _kb_calc89_shift      lsr.b   d2,d1      bcc     _kb_calc89_diamond      lsr.b   d2,d1      bcc     _kb_calc89_alpha                 lea  _kb_key_data_89_normal,a0      bra _kb_return _kb_calc89_shift      move.l d2,d3 _kb_calc89_alpha      lea  _kb_key_data_89_alpha(PC),a0      bra _kb_return      _kb_calc89_2nd      lea  _kb_key_data_89_2nd(PC),a0      bra _kb_return      _kb_calc89_diamond      lea  _kb_key_data_89_diamond(PC),a0      bra _kb_return _kb_calc92_retval ;lecture des stat keys      lsr.b   d2,d1      bcc     _kb_92P_V200_2nd      lsr.b   d2,d1      bcc     _kb_92P_V200_diamond      lsr.b   d2,d1      bcc     _kb_92P_V200_shift      lsr.b   d2,d1      bcc     _kb_92P_V200_lock           bra _kb_92P_V200_normal       _kb_92P_V200_shift      move.l d2,d3 _kb_92P_V200_normal                     lea.l  _kb_key_data_92P_V200_normal(PC),a0      bra _kb_calc92_endstatus _kb_92P_V200_2nd      lea.l  _kb_key_data_92P_V200_2nd(PC),a0      bra _kb_calc92_endstatus      _kb_92P_V200_diamond      lea.l  _kb_key_data_92P_V200_diamond(PC),a0      bra _kb_calc92_endstatus      _kb_92P_V200_lock      lea.l  _kb_key_data_92P_V200_lock(PC),a0 _kb_calc92_endstatus      cmp.w #72,d0      bne _kb_return ;lecture des flèches      lsr.b   d2,d1      bcc     _kb_return ;on quitte si detection d'une touche      add.l   d2,d0 ;on incremente d0 (index)      lsr.b   d2,d1      bcc     _kb_return ;on quitte si detection d'une touche      add.l   d2,d0 ;on incremente d0 (index)      lsr.b   d2,d1      bcc     _kb_return ;on quitte si detection d'une touche      add.l   d2,d0 ;on incremente d0 (index)      lsr.b   d2,d1      bcc     _kb_return ;on quitte si detection d'une touche ;quitte avec 0 si aucune touche n'est pressée      moveq.w #0,d0      rts _kb_return      add.l d0,a0      add.l d0,a0      move.w (a0),d0      tst.b d3      beq _kb_end      cmp.l #97,d0      blt _kb_end      cmp.l #122,d0      bgt _kb_end      sub.l #32,d0 _kb_end           rts           ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; données _kb_numrows      dc.l 8 ;masques précalculés _kb_key_masks      dc.w  $FDFF,$FEFF,$FF7F,$FFBF,$FFDF,$FFEF,$FFF7,$FFFB,$FFFD ;codes de touches _kb_key_data_92P_V200_normal      dc.w 45,13,97,113,271,48,46,173,257,136,108,111,43,266,264,0,61,109,107,105,272,263,265,42,94,110,106,117,268,262,13,112,47,98,104,121,273,259,260,261,32,118,103      dc.w 116,269,40,41,44,258,99,102,114,274,55,56,57,0,120,100,101,270,52,53,54,0,122,115,119,275,49,50,51,337,338,340,344 _kb_key_data_92P_V200_2nd      dc.w 4141,4109,0,0,271,60,60,4372,4353,58,34,0,4139,266,4360,0,92,59,124,151,272,263,4361,4138,140      dc.w 0,0,0,268,4358,4109,95,93,39,38,18,273,259,260,261,32,118,103,116,269,40,41,44,4354,0,159,64,274,4151,4152,4153,0,169,176,0,269,4148,4149,4150,0,0,223,33,275,149,4146,4147,4440,4436,4434,4433 _kb_key_data_92P_V200_diamond      dc.w 1,8205,8257,8273,8463,8240,8238,8365,8449,8328,8268,8271,2,8458,0,8456,8253,8269,8267,8265,8464,8455,8457,8234,8286,8270,8266,8277,8460,8454,8205,8272,8239,8258,8264,8281,8465,8451,8452,8453,8224,130,8276,8461,8232,8233,8236,0,      dc.w 8280,8260,8261,8462,8244,8245,8246,0,8282,8275,8279,8467,8241,8242,8243,8529,8530,8532,8536 _kb_key_data_92P_V200_lock      dc.w 1,8205,8257,8273,8463,8240,8238,8365,8449,8328,8268,8271,2,8458,0,8456,8253,8269,8267,8265,8464,8455,8457,8234,8286,8270,8266,8277,8460,8454,8205,8272,8239,8258,8264,8281,8465,8451,8452,8453,8224,130,8276,8461,8232,8233,8236,0,      dc.w 8280,8260,8261,8462,8244,8245,8246,0,8282,8275,8279,8467,8241,8242,8243,8529,8530,8532,8536 _kb_key_data_89_normal      dc.w 264,0,0,0,0,0,0,0,265,258,149,124,61,120,277      dc.w 268,48,49,52,55,40,121,266,269,46,50,53,56,41,122,278,270,173,51,54,57,44,116,257,271,13,43,45,42,47,94,263,272,337,338,340,344 _kb_key_data_89_alpha      dc.w 264,0,0,0,0,0,0,0,265,112,107,102,97,120,277,268      dc.w 118,113,108,103,98,121,266,269,119,114,109,104,99,122,278,270,32,115,110,105,100,116,257,271,13,117,111,106,101,94,263,272,337,338,340,344 _kb_key_data_89_2nd      dc.w 4360,0,0,0,0,0,0,0,4363,4354,159,176,39,4184,4373      dc.w 273,60,34,58,4151,123,4185,18,274,62,92,4149,4152,125,4186,151,275,4372,4147,4150,59,91,4180,4353,271,4109,4139,4141,4138,93,140,263,272,4433,4434,4436,4440 _kb_key_data_89_diamond      dc.w 16648,0,0,0,0,0,0,0,16651,16642,16533,16508,16445      dc.w 16472,277,16652,16432,16433,16436,16439,146,16650,16653,16430,16434,16437,16440,16425,16474,16662,16654,16557,16435,16438,16441,16428,16468,16641,16665,16397,16426,16431,16478,16647,16656,16721,16722,16724,16728 ;;      ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;      KEY_CUP equ 1 KEY_CDN equ 2
je viens de tenter de le relire, comme je disais c'est bien barbare (et très très porc) mais ça me permettait d'accelerer considerablement le prog, ah oui, il delire un poil sur 89 de ce que je viens de tester

au fait, comment qu'on fait pour avoir la rom/les sources

"si ngetchx est en hard"

oui après tout, je ne connais pas du tout la hardware TI, y'a peut-être un controleur clavier

Si dans ce cas ngetchx est en hardware alors comme y accéder et surtout est-ce qu'on ai obligé de recodé getchx si on désactive l'int 1,2 et 5?

perso je ne m'avance pas, je n'y connais rien en hard

ngetchx est base sur une lecture d'une pile FIFO.
Et c'est l'int 1 qui se charge de remplir cette pile.
Contrairement a AMS, la taille de la pile FIFO du clavier de PedroM est plus grande.
mais ngetchx gere aussi le Link, le mode idle, le break, etc.

c'est l'int1, c'est à dire (excuse moi si je suis lourd) que l'int1 "lance" une fonction qui lit le clavier en bas niveau?

Existe t-il une fonction qui fait la même chose que ngetch mais utilisable sans interruptions?

cf le code que j'ai posté mais faut que tu finisse de la coder
si c'est du soft doit y avoir moyen de choper la fonction qui rempli la chaine FIFO

Et créer une chaîne FIFO c'est possible? Bien sûr différente de l'AMS. Merci pour cette fonctions je vais y jeter un coups d'oeil.

ben l'interet de la file c'est que chaque fois que tu presse une touche elle va dans la pile donc il faut matter regulierement donc il te faut les interruptions

Oui mais dans ce cas ça propre interruption. Cette pile FIFO ce présente comment (En RAM à quelle adresse)?

si tu fais toi-même ta pile, tu la définit où tu veux,
tu as besoin d'un segment et d'unpointeur de debut et de fin et tu boucle sur le segment exemple:

un segment de 8 bytes
|_|_|_|_|_|_|_|_|
^end ^start
(tu vas de gauche à droite et tu repart du debut qd tu arrive à la fin pour enfiler,tu recule start, pour defiler, tu avance end et tu remplis/vide la case pointée)
pigé?

Encore une question hors sujet. Je voudrais savoir si il est possible d'allouer un handle fixe?

Comment ça, "fixe"?

je pense qu'il parle des handles lockés

Je m'explique:
En quelque sorte un handle connus en permanence et que seul le programme qui l'as crée peut l'utiliser en permanence sans que preos ne l'efface....

Crée un fichier dans la VAT. C'est la seule solution propre.

J'explique: Pour que PreOs ne traffique pas tes handles, il suffit de programmer en _nostub ou d'utiliser le RAM_CALL hdKeep proposé par PreOs, mais il reste le problème de comment retenir le numéro du handle entre deux exécutions. La solution propre est de créer un fichier avec un nom connu, le système de fichiers est prévu exactement pour ce que tu veux faire.

Donc faire ça dans un fichier. C'est une bonne idée.

1. Preos n'efface pas les handles qui sont deja present au lancement du kernel... Donc un appel a kernel::HdKeep suffira.
2. Je peux exporte un trap semblable a l'int 1... Mais l'interet ?