Pl GEMDOS.DOC/fr

From Atari Wiki
Revision as of 14:22, 9 October 2006 by Zorro 2 (talk | contribs)
Jump to navigation Jump to search

                           ---------------------
                             CHAPITRE   nrø 5:  

                             *** LE GEMDOS ***

                            --------------------


 
                      *** LES FONCTIONS DU GEMDOS ***
                      -------------------------------

- Les fonctions du GEMDOS peuvent être directement appel‚es en ASS.,
  il suffit:

   .De passer les paramètres dont la fonction à besoin dans la pile
    système (MOTS ou L-M).
  
   .De passer le code de la fonction dans la pile système.(MOT)

   .D'appeller le GEMDOS avec un  TRAP #1 


- Il en est d'ailleurs de même pour les fonctions du BIOS et de l'XBIOS.
  ( Seul le nrø du TRAP change : TRAP #13 pour le BIOS et TRAP #14 pour
  l'XBIOS )

- ATTENTION !  Les fonctions du GEMDOS,BIOS et XBIOS donnent souvent des
  informations en retour: dans certains registres de donn‚es et certains
  registres d'adresses.
  Il faudra veiller à sauvegarder les registres conscern‚s avant 
  d'appeler une de ces fonctions pour ne pas perdre leur contenu.
  (avec MOVEM par exp.)

- Avant d'utiliser les fonctions du GEMDOS,BIOS et de l'XBIOS, il faudra
  r‚server une certaine quantit‚ de m‚moire car lorsque le système d'ex-
  ploitation lance votre programme, on doit allouer la quantit‚ de m‚moire
  dont le programme a r‚ellement besoin.
  (Pour ‚viter les chevauchements de donn‚es en m‚moire)
  Le système d'exploitation (le Bureau GEM) va lire la PAGE de BASE qui
  se trouve en tête de votre programme .PRG (cf le chapitre INTRODUCTION)
  avant de l'‚xecuter.
  Cette PAGE de BASE a une taille de $100 (256) octets et contient toutes
  les informations dont le système d'exploitation a besoin pour le char-
  gement du PRG, mais c'est à nous d'indiquer la taille de la m‚moire
  qu'il faudra qu'il r‚serve.
  Après le chargement du programme, SP pointe sur la PAGE de BASE, on 
  pourra donc facilement lire les diff‚rentes donn‚es que contient la
  PAGE de BASE en incr‚mentant SP par exemple.

  Organisation de la PAGE de BASE:
                     ------------
  Octet:$00=D‚but de la Page de Base
  ----- $04=Pointeur de la fin de la m‚moire libre
        $08=Pointeur du d‚but du prg
        $0C=Taille de la zone TEXT
        $10=Pointeur sur la zone DATA
        $14=Taille de la zone DATA
        $18=Pointeur sur la zone BSS
        $1C=Taille de la zone BSS
        $20=Pointeur du tampon DTA
        $24=Pointeur de la page de base du PRG appelant (père)
        $80=La ligne de commande

  Pour indiquer la taille de la m‚moire à r‚server, il existe une fonction
  du GEMDOS, les paramètres à passer sont:

  .le nombre d'OCTETS à r‚server (L-M)
  .Un L-M qui est le pointeur de la fin de la m‚moire libre
  .un MOT ‚gal à 0
  
  Le code de la fonction est $4A (fonction 'SETBLOCK')

  Pour trouver le nombre d'octets à r‚server (la taille totale du PRG) 
  grƒce à la Page de Base, on additionne:

  .La taille de la Page de Base ($100 octets)
  .La place occup‚e par les instructions (L-M en $C(SP) car SP pointe sur
   le d‚but de la page de base)
  .La taille de la zone DATA (L-M en $14(SP) )
  .La taille de la zone BSS  (L-M en $1C(SP) )
  
  On pose le r‚sultat dans un registre dn et on le pose comme paramètre
  (L-M) dans la pile système (MOVE.L  dn,-(SP) ) suivit d'un L-M qui est
  le pointeur de la fin de la m‚moire libre et d'un MOT ‚gal à 0: 
  (MOVE  #0,-(SP) ) 
  Puis on empile le code de la fonction SETBLOCK :MOVE  #$4A,-(SP)
  et on appelle le GEMDOS avec TRAP #1.

  Cette initialisation devra être faite au d‚but de tout programme.
  ----------------------------------------------------------------
  Pour ‚viter de tout retaper à chaque fois, nous allons cr‚er une
  MACRO INSTRUCTION qui le fera à notre place.

  On d‚limite une MACRO par les directives:
  
  MACRO (Après le nom de la Macro pour marquer le d‚but de la MACRO)
  -----
  ENDM  (A la fin de la MACRO pour marquer la fin de celle-ci)
  ----

     Exp: Une MACRO nomm‚e AJOUTE qui additionne les mots de poids faibles
     ---- des registre d0 et d1 s'‚crira:


        TEXT

ajoute  MACRO            ;d‚but de la macro
        ADD.W    d0,d1   ;la Macro proprement dite
        ENDM             ;Fin de la Macro

    ; Cette MACRO pourra ensuite être utilis‚e:

        MOVE     #3,d0
        MOVE     #5,d1
        ajoute           ;appel de la MACRO 'ajoute'
        MOVE     d1,res

        BSS

res     DS.W     1       ;On trouvera le mot 5+3=8 en 'res'

        END

  La MACRO pourra être utilis‚e aussi souvent que vous le d‚sirez, mais
  il faudra veiller à ne pas mettre de Labels dans votre MACRO car ils
  seraient re‚crits plusieurs fois et ceci provoquerait des erreurs...

  On peut ensuite sauver la MACRO dans un fichier.

  Pour indiquer au LINKER que vous allez utiliser une MACRO qui se trouve
  dans un fichier externe, il faudra utiliser la DIRECTIVE:

  INCLUDE   "fichier.xxx"
  -------
  Il faudra l'utiliser avant que la première MACRO de 'fichier.xxx' soit
  utilis‚e. 
  Tout le fichier sera ASSEMBLE à part, mais seuls les MACROs utilis‚es
  seront incluses.
  

  Mais revenons à notre fonction du GEMDOS 'setblock':

  Le Listing de la Macro SETBLOCK sera:

          TEXT

SETBLOCK  MACRO               ;d‚but macro
          move.l    a7,a5     ;USP dans a5
          lea       pile,a7   ;'pile' est l'adresse pointant sur une zone
                              ;de la m‚moire r‚serv‚e pour certaines 
                              ;fonctions. 
                              ;(le nom du label est quelconque...)
                              ;(Il faut bien sur r‚server cette zone avec
                              ;DS.x place:200 octets suffisent en g‚n‚ral)
          move.l   4(a5),a5   ;adresse de fin de la m‚moire libre dans a5
          move.l   $c(a5),d0  ;Longeur zone TEXT dans d0
          add.l    $14(a5),d0 ;ajoute taille de la zone DATA 
          add.l    $1C(a5),d0 ;ajoute taille de la zone BSS
          add.l    #$100,d0   ;ajoute taille de P. de B. à d0

          move.l   d0,-(sp)   ;EMPILE la place à r‚server (1ø paramètre)
          move.l   a5,-(sp)   ;EMPILE a5                  (2ø paramètre)
          move     #0,-(sp)   ;EMPILE mot=0               (3ø paramètre)
          move     #$4a,-(sp) ;EMPILE le CODE de SETBLOCK
          trap     #1         ;appel du GEMDOS ->‚xecution de la fonction.
          add.l    #12,sp     ;De retour, on incr‚mente SP pour qu'il
                              ;retrouve sa valeur initiale.

          ENDM                ;fin de la MACRO

          END                 ;fin assemblage


 Nous allons sauver cette macro dans le fichier 'INIT_TOS.L'.


 Tous les programmes que nous ‚crirons devront donc ressembler à cela:
 ---------------------------------------------------------------------
 
     TEXT

     INCLUDE   "INIT_TOS.L"   ;Linkage du fichier


     SETBLOCK                 ;appel de la MACRO SETBLOCK

     .                        ;les instructions 
     .                        ;qui forment le prg
     .

     DATA                     ;la zone data

     .                        ;avec les donn‚es initialis‚es
     .
     .

     BSS                      ;la zone bss

     .                        ;avec les r‚servations
     .
     .

     DS.B      200            ;et de la place r‚serv‚e pour les besoins 
pile DS.B      1              ;des fonctions GEMDOS,BIOS,XBIOS que nous
                              ;allons utiliser.     (En amont du label
                              ;'pile').USP pointe sur 'pile' et sera d‚-
                              ;cr‚ment‚ quand on passera les paramètres
                              ;aux fonctions ( MOVE.x source,-(SP) )
                              ;:N'oubions pas que seule la m‚moire dont
                              ;le programme a r‚ellement besoin nous est 
                              ;r‚serv‚e après SETBLOCK.
     END


  Le listing de la macro instruction SETBLOCK se trouve dans le fichier
  INIT_TOS.L sur cette disquette et vous est entièrement disponible.


 NB:Il faudra donc toujours veiller à r‚server de la m‚moire en zone
 -- BSS en amont de l'adresse point‚e par le label que nous avons
    nomm‚ 'PILE'.
    On n'a pas besoin d'‚conomiser de place en r‚servant peu de 
    m‚moire, la taille du segment BSS n'intervenant pas dans la
    taille du PRG...
    

- Je vais maintenant ‚numerer les diff‚rentes fonctions du GEMDOS.

  Seules les fonctions utilis‚es couremment seront ‚tudi‚es, pour les
  autres, il faudra vous r‚fèrer à LA BIBLE DU ST,mais je doute que
  vous aurez à vous en servir dans un futur proche...

  Pour chaque fonction, je vous donnerai:

  .Le CODE et le NOM de la fonction
      ----       ---
  .Les PARAMETRES à passer
       ----------
  .Le BUT de la fonction
      ---

  .Une MACRO INSTRUCTION qui utilise la fonction ‚tudi‚e si celle-ci 
   peut nous être souvent utile...

       Toutes ces macro instructions que nous allons cr‚er à partir des 
   fonctions du GEMDOS,BIOS et XBIOS seront rassembl‚es dans le fichier
   MACROS.L et vous pourrez bien sur vous en servir à chaque fois que
   vous le d‚sirerez.



                      *** LES FONCTIONS DU GEMDOS ***
                      -------------------------------

$00 (TERM),pas de paramètre
---
TERM permet de mettre fin au programme et de revenir au programme appelant
(ou programme père).
C.à.d. que si on utilise la fonction TERM du gemdos, le prg s'arrète et
revient soit au BUREAU GEM ( si le programme a uniquement ‚t‚ charg‚ à
partir du DESKTOP) soit à l'instruction suivant l'instruction d'appel,du
programme PERE.Dans ce dernier cas, le PRG utilisant la fonction TERM est
nomm‚ programme FILS et a ‚t‚ charg‚ par le programme dit 'PERE'.

TERM      MACRO               ;macro TERM nomm‚e 'TERM'
          CLR.W     -(SP)     ;code de TERM
          TRAP      #1        ;appel GEMDOS
          ENDM                ;fin MACRO


$01 (CCONIN),pas de paramètre
---
CCONIN attend un caractère au clavier et l'affiche à la position courante
du curseur.
La fonction donne en retour,le code ASCII de la touche enfonc‚e dans l'oc-
tet de poids faible du mot de poids faible de d0 et le SCANCODE de la tou-
che dans l'octet de poids faible du mot de poids fort de d0.
Le SCANCODE permet de repèrer les touches qui n'ont pas de code ASCII
(comme les touches de fonction) et il permet aussi de distinguer les
touches qui ont le même code ASCII (comme les chiffres du pav‚ num‚ri-
que et ceux du bloc principal)

Le code ASCII et le SCANCODE peuvent être atteints de cette manière par
exemple:

     MOVE      #$01,-(SP)     ;CODE de CCONIN
     TRAP      #1             ;-->gemdos
     ADDQ.L    #2,SP          ;on reinitialise SP
     CMPI.B    #'A',d0        ;compare l'octet de poids faible du mot de
                              ;poids faible de d0 avec le code ASCII de
                              ;'A' soit $41
     BEQ       oui
     SWAP.W    d0             ;SWAP les 2 mots de d0
     CMPI.B    #0,d0          ;le SCANCODE est-il nul ???
     BNE       non
     etc...
  
NB:Vous avez remarqu‚ que j'ai ‚cris:CMPI  #'A',d0.
-- Ecrire 'A' ou le code ASCII de A soit $41 est identique.
   Vous pouvez donc par exemple remplacer MOVE  #$42,d0 par MOVE  #'B',d0
   ,ceci rend le listing plus lisible si vous utilisez des instructions
   qui doivent d‚placer des donn‚es repr‚sentant des codes ASCII...
   L'assembleur fera la rectification. (tout comme MOVE source,an est
   accept‚ et remplac‚ par MOVEA source,an)
 
CCONIN    MACRO                    ;La macro ‚quivalente
          MOVE      #$1,-(SP)
          TRAP      #1
          ADDQ.L    #2,SP
          ENDM

          
$02  (CCONOUT), MOT=code ascii
---
CCONOUT affiche le caractère repr‚sent‚ par le code ASCII qu'on passe
comme paramètre sur la pile à la position courante du curseur.

CCONOUT   MACRO     $\1         ;ici, $\1 indique à l'assembleur qu'on
                                ;va passer un paramètre à la macro.
          move      \1,-(SP)    ;on empile le paramètre \1
          move      #2,-(SP)    ;puis le code de CCONOUT   
          trap      #1          ;gemdos
          addq.l    #4,SP       ;correction de la pile   
          ENDM                  ;fin de la MACRO

Comme vous pouvez le constater, on vient de cr‚er une MACRO instruction
qui admet un PARAMETRE.
On l'indique à l'assembleur par la directive : MACRO   $\1
   
Le paramètre pourra être par exemple:#'A' ou d0 ou #$48 etc...

Exemples d'utilisation de la macro CCONOUT (avec un paramètre):
--------
     CCONOUT   #'a'

va afficher un 'a' à l'‚cran

     MOVE      #'a',d0
     CCONOUT   d0

idem

     CCONOUT   #53

va afficher le caractère de code ascii 53.



$03 (CAUXIN),pas de paramètre
---
CAUXIN permet la reception d'un caractère par l'interface RS232.
Si il n'y a pas eu d'erreur, le code ascii du caractère retourne dans
l'octet de poids faible de d0.

     MOVE      #$3,-(SP)
     TRAP      #1
     ADDQ.L    #2,SP

$04 (CAUXOUT),MOT=code ascii
---
CAUXOUT provoque l'‚mission du caractère dont le code ASCII a ‚t‚ pass‚
comme paramètre dans pile vers l'interface RS232.

     MOVE      #'A',-(SP)     ;envoie un 'A'
     MOVE      #$4,-(SP)
     TRAP      #1
     ADDQ.L    #4,SP


$05 (CPRNOUT),MOT=code ascii
---
CPRNOUT emmet le caractère dont le code ASCII a ‚t‚ empil‚ vers 
l'imprimante.
Si le caractère a ‚t‚ bien envoy‚,on obtient le mot -1 dans d0.
Si l'imprimante est incapable de recevoir le caractère, on obtient un
mot ‚gal à 0 dans d0.

     MOVE      #'A',-(SP)     ;on imprime un 'A'
     MOVE      #$5,-(SP)      ;code de CPRNOUT
     TRAP      #1
     ADDQ.L    #4,SP

$06 (CRAWIO),MOT=$FF ou code ascii
---
CRAWIO admet deux types de paramètres.
Si le paramètre est un MOT ‚gal à $FF, CRAWIO teste si une touche du
clavier EST enfonc‚e.(comme INKEY en BASIC)
Si une touche a ‚t‚ enfonc‚e, son code ascii et son scancode rentre dans
d0, sinon d0 reste inchang‚.
Si le paramètre est diff‚rent de $FF, cette valeur est interpr‚t‚e comme
le code ascii d'un caractère à envoyer à l'‚cran.

INKEY     MACRO                   ;CRAWIO avec $FF comme paramètre
          MOVE      #$FF,-(SP)
          MOVE      #$6,-(SP)
          TRAP      #1
          ENDM

  Exemple d'utilisation de la macro INKEY:
  -------
teste     INKEY               ;appel de la macro  INKEY
          CMPI.B    #'A',d0   ;compare le code ascii de d0 avec 'A'
          BEQ       oui       ;touche 'A' enfonc‚e ? Si oui va en 'oui'
          JMP       teste     ;sinon revient en 'teste'     
oui       NOP  

Tant que la touche 'A' n'est pas enfonc‚e, on saute en 'teste'.


$07 (CRAWCIN),pas de paramètre
---
CRAWCIN attend qu'on appuye sur une touche.
Le caractère reconnu n'est pas affich‚, mais le code ascii et le scancode
de la touche enfonc‚e est transmis à d0 en retour.

WAIT      MACRO               ;macro d'attente d'un touche
          MOVE      #$7,-(SP) ;code de CRAWCIN
          TRAP      #1
          ADDQ.L    #2,SP     ;codes de la touche dans d0.
          ENDM
              
$08 (CNECIN),pas de paramètre
---
Fonction IDENTIQUE à CRAWCIN, sauf qu'ici, frapper CONTROL-C met fin au
PRG (comme avec PTERM), CONTROL-S arrète l'affichage ,CONTROL-Q reprend
l'affichage interompu par control-s.

$09 (PRINT LINE),L-M=adresse d'une chaine de caractères termin‚e par un
---              octet nul.

Cette fonction permet d'afficher une chaine de caractères à l'‚cran.
La chaine de caractères à afficher doit se trouver dans la zone DATA
et doit être termin‚e par un octet NUL.

PRINTLINE      MACRO     $\1       ;MACRO avec \1 paramètre:L'adresse de
                                   ;la chaine de caractères à afficher.
               PEA       \1        ;EMPILE l'adresse \1.
               MOVE      #$9,-(SP) ;code de PRINTLINE
               TRAP      #1
               ADDQ.L    #6,SP
               ENDM
 
Exemple d'utilisation de la macro PRINTLINE:
-------
          PRINTLINE      laurent
          PRINTLINE      exp2
          PRINTLINE      exp3

          DATA

laurent   DC.B           'laurent PIECHOCKI 8,impasse Bellevue 57980',0
exp2      DC.B           53,54,56,80,45,25,0
exp3      DC.B           27,'E',7,'LAURENT',25,0


 NB:  Pour obtenir des effets tels que l'effacement de l'‚cran,le saut de 
 ---  lignes... il existe des codes sp‚ciaux qu'il faut transmettre aux
      fonctions telles que PRINTLINE,CCONOUT... 

      Les codes pr‚c‚d‚s de la valeur ascii 27 (ESC).
      -----------------------------------------------
      27,'E'  :‚fface l'‚cran
      27,'B'  :positionne le curseur une ligne plus bas
      27,'A'  :positionne le curseur une ligne plus haut
      27,'C'  :positionne le curseur une ligne plus à droite
      27,'D'  :positionne le curseur une ligne plus à gauche
      27,'J'  :‚fface l'‚cran à partir de la position actuelle du curseur
      27,'L'  :ins‚re une ligne
      27,'M'  :‚fface la ligne ou se trouve le curseur
      27,'I'  :scroll le curseur et le texte vers le haut
      27,'H'  :positionne le curseur à line 1,colonne 1
      27,'K'  :‚fface une ligne du curseur à la fin de la ligne

      27,'Y',x,y :positionne le curseur à la ligne x-32 et à la colonne
                  y-32                             ----
                  ----
      27,'b',x   :Change la couleur de l'‚criture en couleur nrø x
      27,'c',x   :Change la couleur du fond en couleur nrø x
      27,'f'     :Fait disparaitre le curseur
      27,'e'     :Fait r‚apparaitre le curseur
      27,'j'     :M‚morise la position du curseur
      27,'k'     :Positionne le curseur à la position m‚moris‚e
      27,'p'     :Mode VIDEO-INVERSE de l'‚criture
      27,'q'     :Retour en VIDEO normale


      Ainsi, si j'‚cris:  
      ------------------
        PRINTLINE  efface
   
        DATA

efface  DC.B       27,'E','laurent',0

      ou
      --
        CCONOUT    #27
        CCONOUT    #'E'
        PRINTLINE  laurent

        DATA

laurent DC.B       'laurent',0


On efface l'‚cran (ESC,'E') et on affiche la chaine de caractère:'laurent'


$0A (READLINE),L-M pointant sur un buffer
---
READLINE permet l'entr‚e d'une certaine quantit‚ de caractères à l'‚cran.
(comme INPUT en BASIC).
La chaine de caractère peut être modifi‚e en cours d'‚dition avec 
[Bascspace] et [Delete] et sera valid‚e par [Return] ou [Enter].
(CONTROL-C provoque la fin du programme)

Il faut fournir l'adresse d'un buffer organis‚ commme il suit:

En zone BSS : DS.B   nombre maximum de caractères à rentrer+2
-----------
Il faut avoir plac‚ au d‚but de ce buffer un OCTET repr‚sentant le nombre
maximum de caractères à rentrer ( MOVE.B  x,buffer ) avant d'utiliser la
fonction READLINE.

Après le retour de la fonction:
En 'buffer'+1 se trouve le nombre de caractères rentr‚s 
En 'buffer'+2 se trouve le d‚but de la chaine de caractères rentr‚e.

READLINE       MACRO          $\1       ;paramètre=adresse du buffer
               PEA            \1
               MOVE           #$0A,-(SP)
               TRAP           #1
               ADDQ.L         #6,SP
               ENDM

   Exemple d'utilisation de la macro READLINE:
   ---------------------
     MOVE.B    #5,resu   ;5 caractères à rentrer
     LEA       resu,a5   ;adresse de 'resu' dans a5
     READLINE  resu      ;readline
     addq.l    #2,a5     ;a5 pointe sur la chaine de carac. entr‚e
     MOVE.B    #0,zero   ;pose un OCTET nul à la fin de la chaine pour
     PRINTLINE a5        ;afficher le chaine avec PRINTLINE
     TOUCHE              ;on attend une touche
     BUREAU              ;en on quitte le prg     

     BSS

resu DS.B      7         ;r‚servation pour READLINE
zero DS.B      1         ;r‚servation pour l'octet nul qui finira la 
                         ;chaine pour PRINTLINE




$0B (CONIN STAT),pas de paramètre
---
L'appel à cette fonction donne en d0 un MOT ‚gal à -1 si le tampon de
m‚morisation des touches enfonc‚es contient des caractères.
d0=0 si il n'y a pas de caractères disponibles dans ce tampon.

     MOVE      #$B,-(SP)
     TRAP      #1
     ADDQ.L    #2,SP
     TST.W     D0
     BNE       rien

$0E (SETDRIVE),MOT=NRø du drive à activer.
---
SETDRIVE permet d'activer le drive dont le nrø est pass‚ en paramètre dans
la pile système.
0=Drive A
1=Drive B  etc...

En retour, la fonction donne d0 qui est organis‚ de telle sorte que le
seul bit actif de d0 repr‚sente le dernier lecteur activ‚.
(nrø du bit actif=nrø du drive)


DRIVE     MACRO     $\1            ;param. \1=nrø du drive
          MOVE      \1,-(SP)      
          MOVE      #$E,-(SP)
          TRAP      #1
          ADDQ.L    #4,SP
          ENDM

     Exp d'utilisation:
     ------------------
     DRIVE     #2

Le DRIVE C est activ‚.
Si le dernier Drive actif ‚tait le drive B, on aurait:

d0=%0000000000000010
                  |
                 \|/

           bit nrø1=drive B


$19 (CURRENT DISK),pas de paramètre
---
Cette fonction permet de savoir quel DRIVE est ACTIF.
Le nrø du drive actif est retourn‚ dans d0 selon le format pr‚c‚dent.

WATHDRIVE      MACRO                    ;Quel est le drive actif ?
               MOVE      #$19,-(SP)
               TRAP      #1
               ADDQ.L    #2,SP     
               ENDM

$1A (SETDTA),L-M=adresse du tampon DTA
---
SETDTA installe le tampon DTA qui est utilis‚ par certaines fonctions du
gemdos qui opèrent sur les fichiers.
Ce tampon doit avoir une taille de 44 octets, son adresse doit être 
empil‚e dans la pile système et doit ètre PAIRE.

Pour obtenir une adresse paire, on peut r‚initialiser le PC avec la direc-
tive BSS ou encore utiliser des directives appropri‚es ( mais sp‚cifiques à
à l'assembleur utilis‚ ) :ALIGN.W pour PROFIMAT
                         :CNOP 0,2 pour METACOMCO

On peut aussi tout simplement faire une rectification en ajoutant 1 OCTET
à une adresse inf‚rieure (DS.B  1), ceci a pour effet d'augmenter la va-
leur de l'adresse du DTA:adresse impaire+1=adresse paire.

 
          PEA       buffer
          MOVE      #$1A,-(SP)
          TRAP      #1
          ADDQ.L    #6,SP

          BSS

buffer    DS.B      44


$20 (SUPER),L-M=0 ou L-M=nouvelle valeur de SP
---
Voilà la fonction qui permet de passer EN MODE SUPERVISEUR.

Si le paramètre que vous fournissez est un L-M=0, SUPER activera le MODE
SUPERVISEUR et retournera dans d0 la valeur de SP.
Il faudra sauvegarder cette adresse car elle nous sera indispensable pour
revenir en MODE UTILISATEUR (Pour quitter le prg par exp)

Si on empile un autre L-M que 0,il sera interpr‚t‚ comme la nouvelle 
valeur de SP et d0 contiendra l'ancienne valeur de SP.

SUPER     MACRO                    ;on passe en MODE SUPERVIEUR
          CLR.L     -(SP)
          MOVE.W    #$20,-(SP)
          TRAP      #1
          ADDQ.L    #6,SP
          MOVE.L    d0,sauv_sp     ;on sauve SP en 'sauv_sp'
          ENDM

Il faudra bien entendu r‚server un L-M en 'sauv_sp' !

Pour revenir en MODE UTILISATEUR (indispensable pour quitter le programme
par exemple...):
On utilise la même fonction, mais on y passe comme paramètre l'ancienne
valeur de SP qui a ‚t‚ sauv‚e en sauv_sp.

USER      MACRO                    ;on revient en MODE UTILISATEUR
          MOVE.L    sauv_sp,-(SP)  ;on restore SP
          MOVE.W    #$20,-(SP)
          TRAP      #1
          ADDQ.L    #6,SP
          ENDM



$2A  (GET DATE),pas de paramètre
---
Permet d'obtenir la DATE de l'horloge du bureau GEM dans d0 sous la forme:

Bits 0 à  4=jour
Bits 5 à  8=mois
Bits 9 à 15=(ann‚e-1980)

     MOVE      #$2A,-(SP)
     TRAP      #1
     ADDQ.L    #2,SP

Exemple: si d0=%0001000000100001

La date est:

JOUR:bits 0 à 4 :%00001=le 1ø
MOIS:bits 5 à 8 :%00001=Janvier
AN  :bits 9 à 15:%0001000=8+1980=1988


$2B (SET DATE),MOT=date 
---
SET DATE permet de positionner l'horloge du GEM sur la date que vous lui
transmettez en paramètre.

La date (MOT) est au format pr‚c‚dement d‚crit.

bits 0 à 4:jour
bits 5 à 8:mois
bits 9 à 15:(ann‚e-1980)

Si la date est incorrecte (45/20/1745...),d0 revient avec la valeur -1,
sinon il revient avec la valeur 0.

     MOVE      #%00010000000100001,-(SP)     ;le 1ø janvier 1988
     MOVE      #$2A,-(SP)
     TRAP      #1
     ADDQ.L    #4,SP


$2C (GET TIME),pas de paramètre
---
GET TIME donne en retour l'heure de l'horloge du GEM dans d0 sous la
forme:

bits 0 à 4  :(secondes/2)
bits 5 à 10 :minutes 
bits 11 à 15:heure 

     Exemple:

test MOVE      #$2C,-(SP)     ;GET TIME
     TRAP      #1
     ADDQ.L    #2,SP
                              ;d0 contient l'heure
     AND.W     #%11111,d0     ;on MASQUE les bits 0 à 4 de d0:
                              ;les bits 5 à 15 de d0 sont donc effac‚s.
                              ;il reste les secondes.

     MULS      #2,d0          ;x2 car secondes=(secondes/2) dans d0
     CMPI      #30,d0         ;a-t-on secondes=30 ?
     BEQ       oui            ;si oui:va en 'oui'
     JMP       test           ;sinon revient et redemande l'heure. 

$2D (SET TIME),MOT=heure
---
SET TIME charge l'heure de l'horloge du GEM avec le paramètre qu'on lui
fournit.

L'heure doit être cod‚e sous la forme:

bits 0 à 4  :(secondes/2)
bits 5 à 10 :minutes 
bits 11 à 15:heures 

     Exemple:

     MOVE      #%0001000000100001,-(SP)
     MOVE      #$2D,-(SP)
     TRAP      #1
     ADDQ.L    #4,SP

On positionne l'horloge sur 2h,1 min,2 sec


$31 (KEEP PROCESS),MOT=0,L-M=nb d'octets à protèger.
---
KEEP PROCESS permet, tout comme PTERM de mettre fin au programme et de
revenir au programme 'père'.

Avec PTERM, le programme quitt‚ est effac‚ de la m‚moire d‚finitivement,
tandis qu'avec KEEP PROCESS, on r‚serve un certaine quantit‚ d'OCTETS en
m‚moire (paramètre 2) et on y place le programme à quitter.

Ceci est important pour les programmes sous interruption par exemple, 
nous en reparlerons... 

KEEP      MACRO     $\1            ;paramètre=nb d'octets à r‚server
          CLR.W     -(SP)
          MOVE.L    #\1,-(SP)     
          MOVE      #$31,-(SP)
          TRAP      #1
          ADDQ.L    #8,SP
          ENDM

Exemple d'utilisation:

          KEEP   1024

On place le PRG dans le KO r‚serv‚ et on le quitte...

NB:Faites bien attention à ce que vous r‚servez suiffisament de m‚moire...
--

$3C (CREATE),MOT=attribut du fichier,L-M=adresse du nom de fichier
---

CREATE permet de cr‚er un fichier dans lequel vous pourrez poser des 
donn‚es.

Le 1ø paramètre est l'attribut du fichier:

0=fichier accessible en Lecture et Ecriture
1=fichier accessible en Lecture uniquement
2=fichier invisible
4=fichier système (invisible au desktop)
8 fichier label de volume (invisible au desktop)

Le 2ø paramètre est l'adresse pointant sur le nom du fichier:

Organis‚ ainsi:      'A:\fichier\nom.ext',0

Si le nom du programme à cr‚er est 'nom.ext' et si il se trouve dans le
fichier 'fichier' (inutile si il n'est pas dans un fichier...).
'A:' indique qu'il se trouve sur l'unit‚ de disquette A.
La chaine de caractère doit se terminer par un octet NUL.

En retour, CREATE retourne en d0 le nrø du FILE HANDLE du fichier.
Ce nrø sert à distinguer les diff‚rents programmes externes charg‚s.


CREER     MACRO     $\1,$\2,$\3         ;CREATE avec 3 paramètres
          MOVE      #\1,-(SP)           ;\1=attribut du fichier
          PEA       \2                  ;\2=adresse du nom 
          MOVE      #$3C,-(SP)
          TRAP      #1
          ADDA.L    #8,SP
          MOVE      d0,\3               ;\3=adresse de sauvegarde de d0.
          ENDM

Exemple d'utilisation:

          CREER     0,prg,handle        ;fichier en mode Lecture/Ecriture

          DATA

prg       DC.B      'A:\laurent.gag',0  ;nom du fichier à cr‚er

          BSS

handle    DS.W      1                   ;1 Mot pour le handle


$3D  (OPEN),MOT=attribut,L-M=adresse du nom de fichier à ouvrir
---
OPEN permet d'ouvrir le fichier cr‚‚ avec CREATE pour pouvoir l'utiliser
plus tard (lecture ou ‚criture).

Le 1ø paramètre à fournir est l'attribut du fichier à ouvrir
Le 2ø paramètre à fournir est l'adresse du nom du fichier à ouvrir.

Si OPEN ne rencontre pas de problèmes (fichier pr‚sent et accessible),
d0 revient avec le nrø du handle du fichier, sinon il revient avec une
valeur n‚gative. ( C'est un code d'erreur, voir la liste à la fin du 
chapitre.)

OUVRIR    MACRO     $\1,$\2,$\3    ;OPEN avec 3 paramètres
          MOVE      #\1,-(SP)      ;\1=attribut
          PEA       \2             ;\2=adresse du nom du fichier
          MOVE      #$3D,-(SP)
          TRAP      #1
          ADDQ.L    #8,SP
          MOVE      d0,\3          ;\3=adresse pour sauvegarder le handle
          ENDM

Exemple d'utilisation:

          OUVRIR    0,prg,handle   ;ouverture du fichier (attribut L/E)

          DATA

prg       DC.B      'A:\nom.ext',0 ;nom du fichier à ouvrir

          BSS

handle    DS.W      1              ;1 Mot pour le handle


$3E (CLOSE),MOT=nrø du handle
---
Si le fichier a ‚t‚ ouvert avec OPEN, il sera referm‚ par CLOSE, il faut
passer le nrø du handle du fichier à fermer comme paramètre.

En retour, si le fichier a ‚t‚ correctement ferm‚, d0=0.

FERMER    MACRO     $\1            ;MACRO à 1 paramètre
          MOVE      \1,-(SP)       ;\1=nrø du handle
          MOVE      #$3E,-(SP)
          TRAP      #1
          ADDQ.L    #4,SP
          ENDM

Exemple d'utilisation: 

          FERMER    handle

          BSS

handle    DS.W      1         ;ici a ‚t‚ pos‚ le handle du fichier.



$3F (READ),L-M=adresse du buffer,L-M=nombre d'octets à lire,MOT=nrø handle
---
READ permet de lire un fichier ouvert par OPEN.
Il faut fournir les paramètres suivants à READ:
1ø: L'adresse d'un buffer dans lequel les donn‚es lues seront d‚pos‚es
2ø: Le nombre d'octets à lire dans le fichier
3ø: Le nrø de handle du fichier

D0 retourne avec le nombre d'octets lus ou un code d'erreur n‚gatif.

LIRE      MACRO          $\1,$\2,$\3    ;MACRO à 3 paramètres
          PEA            \1             ;\1=adresse du buffer
          MOVE.L         \2,-(SP)       ;\2=nombre d'octets à lire
          MOVE           \3,-(SP)       ;\3=nrø du handle
          MOVE           #$3F,-(SP)
          TRAP           #1
          ADDA.L         #12,SP
          ENDM

Exemple d'utilisation:

          LIRE      pose,#1024,handle ;lire 1 KO de donn‚es

          BSS

pose      DS.B      1024 ;le buffer pour les 1024 octets à lire
handle    DS.W      1    ;ici se trouve le nrø du handle



$40 (WRITE),L-M=adresse du buffer des donn‚es à ‚crire,L-M=nombre d'octets
---         à ‚crire,MOT=nrø du handle.

WRITE permet d'‚crire des donn‚es dans un fichier ouvert avec OPEN.

Les paramètres à passer sont:
1ø:L'adresse du buffer qui contient les donn‚es à ‚crire dans le fichier.
2ø:Le nombre d'octets à ‚crire dans le fichier
3ø:Le nrø du handle

D0 retourne avec 0 si tout est OK ou avec un code d'erreur n‚gatif.


ECRIRE    MACRO     $\1,$\2,$\3         ;3 paramètres
          PEA       \1                  ;\1=adresse du buffer
          MOVE.L    \2,-(SP)            ;\2=nb d'octets à ‚crire
          MOVE      \3,-(SP)            ;\3=nrø du handle
          MOVE      #$40,-(SP)
          TRAP      #1
          ADDA.L    #12,SP
          EDNM

     Exemple d'utilisation:

          ECRIRE    donnee,#10,handle

          BSS

donnee    DS.B      10   ;les 10 octets à ‚crire
handle    DS.W      1    ;ici a ‚t‚ sauv‚ le handle


$43 (FATTRIB),MOT=attribut,MOT=‚crire ou lire,L-M=adresse du nom du 
---           fichier à modifier

FATTRIB permet de changer ou de lire l'attribut d'un fichier.
Les paramètres à passer sont:

1ø:L'attribut à ‚crire (si on d‚sire le changer,sinon mettre 0)

 0=fichier accessible en Lecture et Ecriture
 1=fichier accessible en Lecture uniquement
 2=fichier invisible
 4=fichier système (invisible au desktop)
 8=fichier label de volume (invisible au desktop)
10=fichier sous-r‚pertoire (uniquement pour la lecture!)
$20=fichier ‚crit et referm‚ correctement (uniquement pour la lecture!)

2ø:Un Mot ‚gal à 1 si FATTRIB doit CHANGER l'attribut
   Un Mot ‚gal à 0 si FATTRIB doit LIRE l'attribut, dans ce cas,l'attribut
   du fichier retourne dans d0. (ou un code d'erreur n‚gatif)
 
3ø:L'adresse pointant sur le nom du fichier à modifier ou lire

FATRIB    MACRO          $\1,$\2,$\3         ;macro à 3 paramètres
          MOVE           \1,-(SP)            ;\1=attribut
          MOVE           \2,-(SP)            ;\2=‚criture ou lecture
          PEA            \3                  ;\3=adresse du nom du fichier
          MOVE           #$43,-(SP)
          TRAP           #1
          ADDA.L         #10,SP
          ENDM

     Exemple d'utilisation:

          FATRIB         #$02,#1,prg

          DATA

prg       DC.B           'A:\auto\laurent.tab',0

FATTRIB va cacher le fichier 'laurent.tab' du fichier 'auto' au desktop.


$4B (PEXEC),L-M=addresse de l'environnement,L-M=adresse de la ligne de 
---         commande,L-M=adresse du nom du fichier,MOT=mode de chargement                          

PEXEC permet de charger un fichier externe suivant 3 modes.

En mode 0:Le prg est charg‚, PEXEC transmet la ligne de commande et l'en-
          vironnement au prg charg‚ puis l'exectute.
          (la ligne de commande et l'environnement sont des paramètres qui
           peuvent ètres pass‚s à des programmes du type .TTP ou .APP) 
En mode 3:Le prg est charg‚, PEXEC transmet la ligne de commande et l'en-
          vironnement au prg et on obtient dans d0 l'adresse ou celui-ci 
          se trouve.
En mode 4:Le prg charg‚ en mode 3 est execut‚.(dans ce cas,l'environnement
          et la ligne de commande ne doivent pas ètres utilis‚s)

Les paramètres à passer à PEXEC sont:

1ø:L'adresse de l'environnement
2ø:l'adresse de la ligne de commande
3ø:l'adresse du nom du fichier
4ø:le mode de chargement (0,3 ou 4)

Le prg qui utilise PEXEC est nomm‚ programme PERE, le prg charg‚ par
PEXEC est le programme FILS.
Le prg PERE reste en m‚moire après avoir utilis‚ PEXEC.

PEXEC     MACRO     $\1,$\2,$\3    ;MACRO à 3 paramètres
          PEA       \1             ;\1=adresse de l'environnement
          PEA       \2             ;\2=adresse de la ligne de commande
          PEA       \3             ;\3=adresse du nom du prg
          MOVE      \4,-(SP)       ;\4=mode
          MOVE      #$4B,-(SP)
          TRAP      #1
          ADDA.L    #16,SP
          ENDM

     Exemple d'utilisation:

          PEXEC     nul,zero,prg,#0

          DATA

nul       DC.B      0                    ;pas d'environnement
zero      DC.B      0                    ;pas de ligne de commande
prg       DC.B      'A:\laurent.prg\',0  ;le prg à charger et executer en
                                         ;mode 0

NB: Pour les ‚ventuelles inclusions de fichiers ASSEMBLEUR sous un
--  programme en GFA BASIC , il suffit d'utiliser la fonction EXEC
    du GFA, et de passer le paramètre dans la ligne de commande.
    Le programme fils en assembleur pourra lire le paramètre qui 
    se trouve au $80 ème octet de la page de base,il s'ex‚cutera
    ensuite en prennant compte du paramètre, et en utilisant la
    fonction PTERM du Gemdos, il redonnera la main au programme
    père en GFA...

$4E (SEARCH),MOT=attribut du fichier,L-M=adresse du nom du fichier à
---          chercher
  
SEARCH cherche si le fichier dont le nom lui est communiqu‚ est pr‚sent
sur la disquette.
Si il est pr‚sent, d0 revient avec la valeur 0 et le tampon DTA qui aura
pr‚alablement ‚t‚ install‚ avec la fonction SETDTA ($1A) sera organis‚
ainsi:

Octet  21     :attribut du fichier
Octets 22 à 23:Heure d'installation du fichier
Octets 24 à 25:Date d'installation du fichier
Octets 26 à 29:Taille du fichier en octets
Octets 30 à 43:NOM et SUFFIXE du fichier trouv‚

Si le fichier n'a pas ‚t‚ trouv‚ par SEARCH, d0 retourne avec le code
d'erreur -33 (fichier non trouv‚)

NB:Les fichiers avec l'attribut Volume Label ne peuvent pas être reconnus
-- par SEARCH...

   Si le nom du fichier est du type:

.  'A:\file.*',0 :On ne tient alors plus compte du SUFFIXE du fichier
   -----------
.  'A:\*.ext',0  :On ne tient que compte du SUFFIXE
   ----------
.  'A:\*.*',0    :=Tous les fichiers
   --------
.  'A:\A??.ext',0:les ? peuvent être n'importe quelle lettre 
   ------------
   (par exemple ABC.ext et AXX.?AA peuvent être identifi‚s par A??.*)
  
Mais dans ces cas,plusieurs nom conviennent pour SEARCH (par exp si on
cherche 'A:\PRG.*',0: 'A:\PRG.EXT',0 et 'A:\PRG.DOC',0 conviennent),
SEARCH prendra alors le 1ø fichier du r‚pertoire qui convient.


SEARCH    MACRO     $\1,$\2,$\3    ;MACRO à 3 paramètres
          PEA       \1             ;\1=adresse du tampon DTA (44 octets)
          MOVE      #$1A,-(SP)     ;SETDTA
          TRAP      #1
          ADDQ.L    #6,SP          ;Le tampon DTA est install‚

          MOVE      \2,-(SP)       ;\2=attribut du fichier
          PEA       \3             ;\3=adresse du nom du fichier
          MOVE      #$4E,-(SP)     ;SEARCH
          TRAP      #1
          ADDQ.L    #8,SP
          ENDM

     Exemple d'utilisation:

          SEARCH    dta,#0,prg          ;attribut=Lecture/‚criture
          CMPI      #-33,d0             ;file not found ??
          BEQ       pas_trouve_fichier  ;alors va en pas_trouve_fichier

          DATA


prg       DC.B      'A:\fichier\nom.ext',0   ;Le prg à chercher

          BSS

dta       DS.B      44                       ;44 oct. r‚serv‚s pour le DTA


$4F (SEARCH NEXT),pas de paramètre
---          
Si on utilise SEARCH et qu'on cherche des fichiers dont le nom peut varier
(PRG.* par exp) et si plusieurs fichiers correspondent à ce nom,nous avons
vu que le 1ø fichier du r‚pertoire qui convient est selectionn‚.
Avec SEARCH NEXT,on peut chercher les autres fichiers qui conviennent au
nom de fichier à choix multiples.
SEARCH NEXT retourne une valeur NULLE dans d0 si il n'y a plus de fichiers
dont le nom convient au nom de fichier recherch‚.
On pourra donc par exemple (Pour trouver les fichier du type 'x.*') tester
l'existence d'autres fichiers dont le nom convient en int‚grant SEARCH
NEXT dans une boucle en testant d0 (si d0=0 il faudra sortir:on utilisera
donc TST.W  d0 puis DBEQ dn,boucle...)
  
     MOVE      #$4F,-(SP)
     TRAP      #1
     ADDQ.L    #2,SP


$56 (FRENAME),L-M=adresse du nouveau nom,L-M=adresse de l'ancien nom,
---           MOT=0

FRENAME permet de changer le nom d'un fichier.
Il suffit de passer l'adresse pointant sur le nouveau nom de fichier et
l'adresse pointant sur l'ancien nom de fichier comme paramètres.

D0 retourne avec une valeur nulle ou un message d'erreur n‚gatif.

RENAME    MACRO     $\1,$\2   ;MACRO a 2 paramètres
          PEA       \1        ;\1=adresse du nouveau nom de fichier
          PEA       \2        ;\2=adresse de l'ancien nom
          MOVE      #0,-(SP)  ;\3=0
          MOVE      #$56,-(SP)
          TRAP      #1
          ADDA.L    #12,SP
          ENDM
          
     Exemple d'utilisation:

          RENAME nouveau,ancien

          DATA

nouveau   DC.B      'A:\zzzzz.zzz',0    ;nouveau nom de fichier
ancien    DC.B      'A:\zzzzz.aaa',0    ;ancien nom



                              -------------

ANNEXE:  Les codes d'erreur du GEMDOS:
-------
-32:num‚ro de fonction non valable
-33:fichier inexistant
-34:nom d'accès inexistant
-35:trop de fichiers ouverts
-36:saisie impossible
-37:num‚ro de r‚f‚rence non valable
-39:m‚moire insuffisante
-46:unit‚ de disquette non valable
-49:plus d'autres fichiers


                           --------------------

  Voilà pour ce qui est des fonctions du GEMDOS.

  Je n'ai pas enum‚r‚ toutes les fonctions du GEMDOS, les autres ne vous
  serviront d'ailleurs pratiquement jamais:
  Seules les fonctions interressantes ont ‚t‚ pr‚sent‚es ici.

  Vous pouvez dès à pr‚sent foncer sur votre ASSEMBLEUR et cr‚er vos 
  premiers programmes:
  Ils ne risquent pas encore d'ètres g‚niaux, mais au moins ils auront
  le m‚rite d'être en ASSEMBLEUR et de vous permettre de progresser.
  Bon courage...

  Les autres,lisez donc le prochain chapitre sur les fonction du BIOS et
  du XBIOS qui se trouve sur la disquette nrø 2.
                                ----------------
  Les exercices viendront ensuite, et avec eux VOS premiers programmes en
  ASSEMBLEUR dignes de ce nom...


  PIECHOCKI Laurent
  8,impasse Bellevue                    suite dans:BIOS.DOC (DISK 2)
  57980 TENTELING                                  -----------------




  

Back to ASM_Tutorial