GEMDOS.TXT/fr

Languages:

English  • français

   ***-------------- LES FONCTIONS GEMDOS PAR NUMÉRO ---------------***

   $00      Pterm0    Fin de processus
   $01      Cconin    Lit un caractère sur l'entrée standard
   $02      Cconout   Écrit un caractère sur la sortie standard
   $03      Cauxin    Lit un caractère sur l'entrée standard AUX:
   $04      Cauxout   Écrit un caractère sur la sortie standard AUX:
   $05      Cprnout   Écrit un caractère sur la sortie standard PRN:
   $06      Crawio    Lecture/écriture brute sur l'entrée/sortie standard
   $07      Crawcin   Lecture brute sur l'entrée standard
   $08      Cnecin    Lit un caractère sur l'entrée standard, sans écho
   $09      Cconws    Écrit une chaîne sur la sortie standard
   $0A      Cconrs    Lit une chaîne formatée sur l'entrée standard
   $0B      Cconis    Teste l'état de l'entrée standard
   $0E      Dsetdrv   Fixe le lecteur de disque par défaut
   $10      Cconos    Teste l'état de la sortie standard
   $11      Cprnos    Teste l'état du périphérique standard PRN:
   $12      Cauxis    Teste l'état du standard AUX: en entrée
   $13      Cauxos    Teste l'état du standard AUX: en sortie
   $19      Dgetdrv   Demande le disque par défaut
   $1A      Fsetdta   Fixe l'adresse du DTA (Disk Transfer Adress)
   $20      Super     Entre/Sort/Demande du mode superviseur
   $2A      Tgetdate  Demande la date
   $2B      Tsetdate  Fixe la date
   $2C      Tgettime  Demande l'heure
   $2D      Tsettime  Fixe l'heure
   $2F      Fgetdta   Demande l'adresse du DTA (Disk Transfer Adress)
   $30      Sversion  Demande le numéro de version du GEMDOS
   $31      Ptermres  Finit un programme qui reste résident
   $36      Dfree     Demande d'informations sur un disque
   $39      Dcreate   Création d'un sous-répertoire
   $3A      Ddelete   Efface un sous-répertoire
   $3B      Dsetpath  Fixe le catalogue courant
   $3C      Fcreate   Création d'un fichier
   $3D      Fopen     Ouvre un fichier
   $3E      Fclose    Ferme un fichier
   $3F      Fread     Lit un fichier
   $40      Fwrite    Écrit un fichier
   $41      Fdelete   Efface un fichier
   $42      Fseek     Positionnement dans un fichier
   $43      Fattrib   Retourne/fixe les attributs de fichier
   $45      Fdup      Recopie un identificateur de fichier standard
   $46      Fforce    Force un identificateur de fichier
   $47      Dgetpath  Demande le répertoire courant
   $48      Malloc    Demande d'allocation mémoire
   $49      Mfree     Libère de la mémoire
   $4A      Mshrink   Rétrécit un bloc de mémoire allouée
   $4B      Pexec     Charge/Exécute un programme
   $4C      Pterm     Termine un programme
   $4E      Fsfirst   Recherche la première occurrence d'un fichier
   $4F      Fnext     Recherche l'occurrence suivante
   $56      Frename   Renomme un fichier
   $57      Fdatime   Demande ou fixe la date de création d'un fichier


   ***-------------- FONCTIONS GEMDOS PAR NOM ----------------------***

   $03      Cauxin    Lit un caractère sur l'entrée standard AUX:
   $12      Cauxis    Teste l'état du standard AUX: en entrée
   $13      Cauxos    Teste l'état du standard AUX: en sortie
   $04      Cauxout   Écrit un caractère sur la sortie standard AUX:
   $01      Cconin    Lit un caractère sur l'entrée standard
   $0B      Cconis    Teste l'état de l'entrée standard
   $10      Cconos    Teste l'état de la sortie standard
   $02      Cconout   Écrit un caractère sur la sortie standard
   $0A      Cconrs    Lit une chaîne formatée sur l'entrée standard
   $09      Cconws    Écrit une chaîne sur la sortie standard
   $08      Cnecin    Lit un caractère sur l'entrée standard, sans écho
   $11      Cprnos    Teste l'état du périphérique standard PRN:
   $05      Cprnout   Écrit un caractère sur la sortie standard PRN:
   $07      Crawcin   Lecture brute sur l'entrée standard
   $06      Crawio    Lecture/écriture brute sur l'entrée/sortie standard
   $39      Dcreate   Création d'un sous-répertoire
   $3A      Ddelete   Efface un sous-répertoire
   $36      Dfree     Demande d'informations sur un disque
   $19      Dgetdrv   Demande le disque par défaut
   $47      Dgetpath  Demande le répertoire courant
   $0E      Dsetdrv   Fixe le lecteur de disque par défaut
   $3B      Dsetpath  Fixe le catalogue courant
   $43      Fattrib   Retourne/fixe les attributs de fichier
   $3E      Fclose    Ferme un fichier
   $3C      Fcreate   Création d'un fichier
   $57      Fdatime   Demande ou fixe la date de création d'un fichier
   $41      Fdelete   Efface un fichier
   $45      Fdup      Recopie un identificateur de fichier standard
   $46      Fforce    Force un identificateur de fichier
   $2F      Fgetdta   Demande l'adresse du DTA (Disk Transfer Adress)
   $3D      Fopen     Ouvre un fichier
   $3F      Fread     Lit un fichier
   $56      Frename   Renomme un fichier
   $42      Fseek     Positionnement dans un fichier
   $1A      Fsetdta   Fixe l'adresse du DTA (Disk Transfer Adress)
   $4E      Fsfirst   Recherche la première occurrence d'un fichier
   $4F      Fnext     Recherche l'occurrence suivante
   $40      Fwrite    Écrit dans un fichier
   $48      Malloc    Demande d'allocation mémoire
   $49      Mfree     Libère de la mémoire
   $4A      Mshrink   Rétrécit un bloc de mémoire allouée
   $4B      Pexec     Charge/Exécute un programme
   $4C      Pterm     Termine un programme
   $00      Pterm0    Termine un programme (code de retour 0)
   $31      Ptermres  Termine un programme qui reste résident
   $20      Super     Entre/Sort/Demande du mode superviseur
   $30      Sversion  Demande le numéro de version du GEMDOS
   $2A      Tgetdate  Demande la date
   $2C      Tgettime  Demande l'heure
   $2B      Tsetdate  Fixe la date
   $2D      Tsettime  Fixe l'heure

   *------------------------------------------------------------------*
   $00      Pterm0    Finit un programme

        void Pterm0()

   Termine  un  processus, fermant  tous les fichiers qu'il a ouvert et
   libérant  la  mémoire  qu'il a allouée. Retourne $0000 comme code de
   sortie au programme parent.
   *------------------------------------------------------------------*
   $01  Cconin    Lit un caractère sur l'entrée standard

        LONG Cconin()
     
   Lit   un  caractère sur l'entrée standard   (identificateur 0).   Si
   l'entrée   standard  est  la  console,  le long_mot retourné dans D0
   contient le code ASCII et le code clavier de la touche appuyée
   (code de scrutation) :

          ________________________________________________
         | 31..24      | 23.. 16   |  15..8   |   7..0    |
         |-------------|-----------|----------|-----------|
         |             |  code de  |          |           |
         | $00 ou bits | scrutation|   $00    | caractère |
         | de shift    | ou $00    |          | ASCII     |
         |_____________|___________|__________|___________|

   Les  touches  de fonction (F1 à F10,  HELP, UNDO, etc...) retournent
   le  code  ASCII  $00,  avec le code clavier approprié (cf. le manuel
   sur  le  clavier  intelligent  pour la valeur des codes clavier). Le
   ST BIOS place l'état des touches spéciales dans les bits 24 à 31
   (voir le Guide du programmeur du BIOS pour plus de détails).


   ERREURS
        Ne retourne aucune indication de fin de fichier.
        Ne reconnaît pas 'Control_C'
        Impossible  de  savoir si l'entrée est un périphérique à carac-
        tères ou un fichier.
        Il  devrait exister un moyen de taper les 256 codes possibles à
        partir du clavier.
   *------------------------------------------------------------------*
   $02 Cconout   Ecrit un caractère sur la sortie standard
        void  Cconout(c)
        WORD c
   Écrit  le caractère 'c' sur la sortie standard   (identificateur 0).
   Les   huit   bits  les  plus significatifs de 'c'  sont  réservés et
   doivent être à zéro. Les tabulations ne sont pas interprétées.
   *------------------------------------------------------------------*
   $03 Cauxin    Lit un caractère sur l'entrée standard AUX:

        WORD Cauxin()

   Lit un caractère à partir de l'identificateur 1 (le port série AUX:,
   normalement).

   REMARQUE
        Le  contrôle  de flux de la sortie RS232 ne marche  pas  avec  
        cette fonction.  Les programmes devraient utiliser l'appel de  
        périphérique  de caractère BIOS afin d'éviter de  perdre  des  
        caractères reçus.
   *------------------------------------------------------------------*
   $04 Cauxout   Écrit un caractère sur la sortie standard AUX:
        void Cauxout(c)
        WORD c

   *------------------------------------------------------------------*
   $05 Cprnout   Écrit un caractère sur la sortie standard PRN:
        void Cprnout(c)
        WORD c

   Écrit 'c' sur l'identificateur 2  (le  port  imprimante PRN:, norma-
   lement). Les huits bits hauts de 'c' sont réservés et doivent être à
   zéro. Les tabulations ne sont pas interprétées.

   *------------------------------------------------------------------*
   $06 Crawio    Lecture/Écriture brute sur l'entrée/sortie standard
        LONG Crawio(w)
        WORD w;

   REMARQUES
        Par  le  fait  même  de  sa conception cette fonction ne peut  
        écrire '$ff' sur la sortie standard.
        $00 ne peut être différencié d'une fin de fichier.
   *------------------------------------------------------------------*
   $07 Crawcin   Entrée brute sur l'entrée standard
        LONG Crawcin()

   REMARQUE     Pas d'indication de fin de fichier. 
   *------------------------------------------------------------------*
   $08 Cnecin    Lit un caractère sur l'entrée standard, sans écho
        LONG Cnecin()

   Lit   un   caractère   sur   l'entrée  standard.  Si le périphérique
   d'entrée   est  'CON:', aucun  écho n'est fait.  Les  caractères  de
   contrôle sont interprétés.
   *------------------------------------------------------------------*
   $09 Cconws    Ecrit une chaîne sur la sortie standard
        void Cconws(chaîne)
        char *chaîne;
   Écrit   une  chaîne  débutant  à 'chaîne' et finissant par 0, sur la
   sortie standard.
   *------------------------------------------------------------------*
   $0A Cconrs    Lit une chaîne sur l'entrée standard
        void Cconrs(buf)
        char *buf;
   Lit  une  chaîne sur l'entrée standard.  Les caractères de  contrôle
   habituels sont interprétés :

                   ____________________________________________
                  | Caractère    |    Fonction                 |
                  |--------------|-----------------------------|
                  | <return>, ^J | Fin de ligne                |
                  |   ^H, <rub>  | Efface le dernier caractère |
                  |   ^U, ^X     | Efface la ligne entière     |
                  |      ^R      | Recopie la ligne            |
                  |      ^C      | Fini le programme           |
                  |______________|_____________________________|

   Le premier caractère de 'buf' contient le nombre maximum  d'octets à
   lire  (taille  du  tampon  moins deux). En sortie, le deuxième octet
   contient   le  nombre  de caractères lus.  La chaîne se trouve entre
   'buf+2' et 'buf+2+buf[1]'.
   Il n'est pas garanti que la chaîne se finisse par 0.

   REMARQUE     Plante sur les fins de fichiers.
   *------------------------------------------------------------------*
   $0B Cconis    Teste l'état de l'entrée standard
        WORD Cconis()
   Retourne    $FFFF  si  un  caractère  est  disponible  sur  l'entrée
   standard, $0000 sinon.
   *------------------------------------------------------------------*
   $0E Dsetdrv   Fixe le lecteur de disque par défaut
        LONG Dsetdrv(drv)
        WORD drv;
   Fixe le disque 'drv' par défaut. Les disques sont rangés de 0 à 15
   (A: à P:). Retourne dans D0.L la carte des disques actifs:
           (bit 0 = A, bit 1 = B, etc..).

   Un 'disque actif' est un disque à partir duquel un catalogue a été
   fait.

   REMARQUE Le GEMDOS ne supporte que 16 disques (bits 0 à 15).  Les 
   systèmes ultérieurs en supporteront 32 .
   *------------------------------------------------------------------*
   $10 Cconos    Teste l'état de la sortie standard
        WORD Cconos()

   Renvoie  $FFFF   si  la  console  est prête à recevoir un caractère,
   $0000 si la console n'est PAS prête.
   *------------------------------------------------------------------*
   $11 Cprnos    Teste l'état de la sortie standard PRN:
        WORD Cprnos()
   Retourne  $FFFF  si  'PRN:' est  prêt à recevoir un caractère, $0000
   sinon.
   *------------------------------------------------------------------*
   $12 Cauxis    Teste l'état de l'entrée standard AUX:
        WORD Cauxis()
   Retourne $FFFF si un caractère est disponible sur l'entrée 'AUX:'
   (identificateur 1), $0000 sinon.
   *------------------------------------------------------------------*
   $13 Cauxos    Teste l'état de la sortie standard AUX:
        WORD Cauxos()
   Renvoie $FFFF si 'AUX:' (identificateur 1) est prêt à recevoir un
   caractère, $0000 sinon.
   *------------------------------------------------------------------*
   $19 Dgetdrv   Recherche le lecteur de disque par défaut
        WORD Dgetdrv()
   Retourne le numéro du lecteur courant, compris entre 0 et 15.
   *------------------------------------------------------------------*
   $1A Fsetdta   Fixe l'adresse du DTA (Disk Transfer Adress)
        void Fsetdta(adr)
        char adr;
   Fixe  l'adresse  du DTA à 'adr'.  Le tampon de stockage des  données
   sur   un  fichier (DTA) ne sert que pour les fonctions Fsfirst()  et
   Fsnext().
   *------------------------------------------------------------------*
   $20 Super     Change/teste le mode (Utilisateur ou Superviseur)
        LONG Super(pile)
        WORD *pile;
        'pile' est égal à -1L ($FFFFFFFF):
   la   fonction   retourne $0000  si  le  processeur   est   en   mode
   Utilisateur,  $0001 s'il est en mode Superviseur.

   'pile' est différent de -1L:
        si  le  processeur est en mode Utilisateur, la fonction revient
        avec   le  processeur en mode Superviseur.   Si 'pile' est  NUL
        ($00000000),  la   pile  superviseur  sera  la même que la pile
        Utilisateur   avant  l'appel.  Sinon la pile  Superviseur  sera
        placée à 'pile'.

        Si  le  processeur était en mode Superviseur, il se retrouve en
        mode  Utilisateur  au retour de la fonction.  'pile' devra être
        la   valeur  de  la pile utilisateur qui a été retournée par le
        premier appel de la fonction.

   ATTENTION
        La  pile  Superviseur originale doit être replacée avant la fin
        du   programme  sinon  le   système  plantera  à  la  sortie du
        programme.

   *------------------------------------------------------------------*
   $2A Tgetdate  Demande la date
        WORD Tgetdate()

   Retourne la date en format DOS :

        15 __________________9_8_________5_4_________0 
        |  Année depuis 1980  |   mois    |   jour    |
        |    0.....119        |  1...12   |  1...31   |
        |_____________________|___________|___________|

   RETOUR
        les bits 0 à 4 contiennent le jour allant de 1 à 31.
        les bits 5 à 8 contiennent le mois allant de 1 à 12.
        les   bits   9 à  15 contiennent  l'année   (à  partir de 1980)
        allant de 0 à 119.
   *------------------------------------------------------------------*
   $2B Tsetdate  Fixe la date
        WORD Tsetdate(date)
        WORD date;
   Fixe   'date' comme   date courante  dans  le  format  décrit   dans
   Tgetdate().

   RETOUR   0 si la date est valide.
            ERROR si le format de la date est incorrect.

   REMARQUES
        Le GEMDOS n'est pas difficile sur la date;  par exemple le 31  
        Février ne lui déplaît pas.
        Le GEMDOS ne prévient PAS le BIOS que la date a changée.
   *------------------------------------------------------------------*
   $2C Tgettime  Demande l'heure
        WORD Tgettime()

   Retourne l'heure courante dans le format DOS:

              15__________11_10________5_4__________0
             |    heure     |   minute  |   seconde  |
             |   0...23     |   0...59  |   0...28   |
             |______________|___________|____________|

   RETOUR    Les  bits :
        0 à 4    contiennent les secondes divisées par 2 (0 à 28)
        5 à 10   contiennent les minutes  (0 à 59)
        11 à 15  contiennent les heures   (0 à 23)
   *------------------------------------------------------------------*
   $2D Tsettime  Fixe l'heure
        WORD Tsettime(heure)
        WORD heure;
   Fixe  'heure' comme   heure  courante  dans  le  format décrit  dans
   Tgettime().

   RETOUR   0 si le format de l'heure fournie est valide;
            ERROR si le format de l'heure n'est pas valide.
   REMARQUE
        Le GEMDOS ne prévient pas le BIOS que l'heure a changé.
   *------------------------------------------------------------------*
   $2F Fgetdta   Demande l'adresse du DTA (Disk Transfer Address)
        LONG Fgetdta()
   Retourne l'adresse courante du tampon de stockage des données sur un
   fichier  (DTA), employée  par les  fonctions  Fsfirst() et Fsnext().
   *------------------------------------------------------------------*
   $30 Sversion  Demande le numéro de version du GEMDOS
        WORD Sversion()

   Retourne  le  numéro de version du GEMDOS en format inversé. L'octet
   le plus significatif contient la partie basse du  numéro, l'octet le
   moins significatif, la partie haute.

   REMARQUES
        La version du GEMDOS sur disquette du 29/5/85 et la  première  
        version en ROM du 20/11/85 ont $1300 comme numéro.
     
        Les  numéros  de  version  du  GEMDOS et du TOS ne sont PAS les
        mêmes. (cf. LE MANUEL DE REFERENCE DU BIOS DU ST pour le numéro
        de version du TOS).
   *------------------------------------------------------------------*
   $31 Ptermres  Finit un programme qui reste résident
        void Permres( nbrest,coderet)
        LONG nbrest;
        WORD coderet;

   Finit  le  programme  courant, en conservant une part de sa mémoire.
   'nbrest'  le   est   nombre d'octets appartenant  au  programme  qui
   doivent être gardés,  comprenant et commençant à la page de  base.
   'coderet' est  le  code  de  sortie  qui  est  retourné au programme
   parent.

   La   mémoire   que le programme a allouée (en plus de sa  zone  TPA)
   N'EST PAS libérée.
   Il est impossible de rappeler le programme terminé par Ptermres().

   REMARQUE 
        Les fichiers ouverts sont fermés lors de la fin de processus.
   *------------------------------------------------------------------*
   $36 Dfree     Demande l'espace libre sur un disque
        void Dfree(buf,nbdisq)
        LONG *buf;
        WORD nbdisq;

   Demande  des  informations  sur le disque 'nbdisq' et les place dans
   quatre longs_mots commençant à 'buf':
             __________________________________________________
            |  buf + 0  | nombre de blocs libres sur le disque |
            |-----------|--------------------------------------|
            |  buf + 4  | nombre total de blocs sur le disque  |
            |-----------|--------------------------------------|
            |  buf + 8  | taille d'un secteur en octets        |
            |-----------|--------------------------------------|
            |  buf + 12 | nombre de secteurs par bloc          |
            |___________|______________________________________|

   REMARQUE   Incroyablement lent sur un disque dur (5 à 10 secondes).
   *------------------------------------------------------------------*
   $39 Dcreate   Création d'un sous_répertoire de disque C
        WORD Dcreate(chemin)
        char *chemin;

   'Chemin' pointe  sur  une chaîne terminée par 0 spécifiant le chemin
   du nouveau répertoire.
   RETOUR
        0 en cas de succès;
        ERROR ou le numéro d'erreur approprié en cas d'échec.
   *------------------------------------------------------------------*
   $3A Ddelete   Efface un sous_répertoire
        WORD Ddelete(chemin)
        char *chemin;
   Efface   un   répertoire   qui  doit être  vide  (il  peut toutefois
   comporter  les  fichiers  spéciaux "." et ".."). 'chemin' pointe sur
   une  chaîne  terminée par zéro, spécifiant le chemin du répertoire à
   effacer.

   RETOUR   0 en cas de succès;
            ERROR ou le numéro d'erreur approprié en cas d'échec.
   *------------------------------------------------------------------*
   $3B Dsetpath  Fixe le répertoire courant
        WORD Dsetpath(chemin)
        char *chemin;
   Fixe   'chemin',  (une  chaîne  terminée  par   0), comme répertoire
   courant.  Si  le  chemin commence par une lettre identificatrice  de
   disque suivie de deux-points, le répertoire courant est placé sur le
   lecteur spécifié.

   Le système conserve un répertoire courant pour chaque lecteur.

   RETOUR   0 en cas de succès;
            ERROR ou le numéro d'erreur approprié en cas d'echec.
   *------------------------------------------------------------------*
   $3C Fcreate   Création d'un fichier
        WORD Fcreate(nomfich,attribs)
        char *nomfich;
        WORD attribs;
   Crée  un  fichier 'nomfich' et retourne  son  identificateur,  non
   standard,  d'écriture seule. Le mot d'attributs est stocké dans le
   répertoire; les bits d'attributs sont :
         _________________________________________________________
        |  masque |       description                             |
        |---------|-----------------------------------------------|
        | $01    | fichier créé en lecture seule                  |
        | $02    | fichier transparent au répertoire              |
        | $04    | fichier système                                |
        | $08    | fichier contenant un nom de volume sur 11 bits |
        |________|______________________________________-_________|

   RETOUR
        Un nombre positif, l'identificateur ou :
        ERROR ou le numéro d'erreur approprié.

   REMARQUES
        Si  le bit de lecture seule est positionné,  un identificateur 
        d'écriture seule est retourné, et, de plus, cet identificateur 
        ne permet pas d'écrire.

        Théoriquement, un  seul  numéro  de  volume  est  permis sur un
        répertoire  racine.  Le  GEMDOS  n'impose  rien de tel, ce  qui
        peut causer quelque confusion.
   *------------------------------------------------------------------*
   $3D Fopen     Ouverture d'un fichier
        WORD Fopen(nmfich,mode)
        char *nmfich;
        WORD mode;
   Ouvre  le  fichier 'nmfich' en mode 'mode' et retourne son identifi-
   cateur non standard. Le mode d'ouverture peut être:
                      ____________________________
                     | mode |     description     |
                     |------|---------------------|
                     | 0    | lecture seule       |
                     | 1    | écriture seule      |
                     | 2    | lecture et écriture |
                     |______|_____________________|

   RETOUR
        Un nombre positif, l'identificateur
        Un numéro d'erreur négatif.
   *------------------------------------------------------------------*
   $3E Fclose    Fermeture d'un fichier
        WORD Fclose(idfich)
        WORD idfich;
   Ferme le fichier dont l'identificateur est 'idfich'.

   RETOUR   0 en cas de succès;
            ERROR ou un numéro d'erreur approprié en cas d'échec.
   *------------------------------------------------------------------*
   $3F Fread     Lecture sur un fichier
        LONG Fread(idfich,nbre,buffer)
        WORD idfich;
        LONG nbre;
        char *buffer;

   Lit  'nbre' octets dans le fichier d'identificateur  'idfich',  et
   les place en mémoire à partir de l'adresse 'buffer'.

   RETOUR
        Le nombre d'octets réellement lus, ou:
        0 si code de fin de fichier,
        Un numéro d'erreur négatif.
   *------------------------------------------------------------------*
   $40 Fwrite    Écriture sur un fichier
        LONG Fwrite(idfich,nbre,buffer)
        WORD idfich;
        LONG nbre;
        char *buffer;

   Écrit  'nbre' octets  de la mémoire à partir de l'adresse  'buffer',
   dans le fichier ayant comme identificateur 'idfich'.

   RETOUR   Le nombre d'octets réellement écrits en cas de succès.
            Un numéro d'erreur négatif autrement.
   *------------------------------------------------------------------*
   $41 Fdelete   Effacement d'un fichier
        WORD Fdelete(nomfich)
        char *nomfich;
   Efface le fichier ayant comme nom 'nomfich'.

   RETOUR   0 en cas de succès
            Un numéro d'erreur négatif autrement.
   *------------------------------------------------------------------*
   $42 Fseek     Positionne le pointeur de fichier
        LONG Fseek(offset,idfich,mode)
        LONG offset;
        WORD idfich;
        WORD mode;
   Positionne  le  pointeur dans le fichier défini par l'identificateur
   'idfich'.   'offset' est   un  nombre  signé;   une  valeur positive
   déplace  le pointeur vers la fin du fichier,   une valeur  négative,
   vers le début. Le 'mode' de positionnement peut être :
              _____________________________________________
             | mode  |  Déplacement d'offset octets...    |
             |-------|------------------------------------|
             |    0  | à partir du début du fichier       |
             |    1  | à partir de la position courante   |
             |    2  | à partir de la fin du fichier      |
             |_______|____________________________________|

   RETOUR   La position courante dans le fichier.
            Un numéro d'erreur négatif si erreur.
   *------------------------------------------------------------------*
   $43 Fattrib   Fixe ou demande les attributs d'un fichier
        WORD Fattrib(nmfich,drap,attribs)
        char *nmfich;
        WORD drap;
        WORD attribs;
   'nmfich' pointe  sur un chemin terminé par 0.  Si 'drap' a la valeur
   1, les  attributs  de fichier 'attribs' sont fixés (pas de valeur de
   retour). Si 'drap' est 0, ils sont retournés.

        Les bits d'attributs sont :
         _________________________________________________________
        | masque |               description                      |
        |--------|------------------------------------------------|
        | $01    | fichier  à lecture seule                       |
        | $02    | fichier transparent au répertoire              |
        | $04    | fichier 'système'                              |
        | $08    | fichier contenant un nom de volume (11 octets) |
        | $10    | fichier  sous-répertoire                       |
        | $20    | fichier écrit puis refermé                     |
        |________|________________________________________________|

   REMARQUE   Le  bit  d'archivage, $20, ne  semble  pas  marcher comme
   prévu.
   *------------------------------------------------------------------*
   $45 Fdup      Duplique un identificateur de fichier
        WORD Fdup(idfich)
        WORD idfich;
   L'identificateur 'idfich' doit être un identificateur standard  (0 à
   5). Fdup() retourne  un  identificateur  non  standard (supérieur ou
   égal à 6) qui pointe le même fichier.

   RETOUR   Un identificateur ou :
   EIHNDL   'idfich' n'est pas un identificateur standard
            ENHNDL    Plus d'identificateur non standard
   *------------------------------------------------------------------*
   $46 Fforce    Force un identificateur de fichier
        Fforce(stdh,nonstdh)
        WORD stdh;
        WORD nonstdh;

   Force   l'identificateur  standard 'stdh' à pointer le même  fichier
   ou périphérique que l'identificateur non-standard 'nonstdh'.

   RETOUR   0 si OK
            EIHNDL    identificateur invalide.
   *------------------------------------------------------------------*
   $47 Dgetpath  Demande le répertoire courant
        void Dgetpath(buf,driveno)
        char *buf;
        WORD driveno;
   Le   répertoire  courant pour le lecteur 'driveno' est recopié  dans
   'buf'.  Le   numéro  de lecteur commence à 1 pour le lecteur  A:,  2
   pour le B:, etc..., 0 spécifiant le disque par défaut.

    REMARQUE
   La   taille   maximum   d'un chemin n'est  pas  limitée  par le sys-
   tème. C'est  à  l'application  de  fournir  assez  de  place pour le
   tampon.  128 octets  semblent  suffisants  pour  8 ou 9  sous-réper-
   toires.
   *------------------------------------------------------------------*
   $48 Malloc    Demande d'allocation mémoire
        LONG Malloc(taille)
        LONG taille;
   Si  'taille' est  -1L  ($FFFFFFFF) la fonction retourne la taille du
   plus   grand   bloc   libre  du système.   Autrement si 'taille' est
   différent  de -1L, la fonction essaie d'allouer 'taille' octets pour
   le  programme  en cours.   La fonction retourne un pointeur  sur le 
   début du bloc alloué si tout s'est bien passé,  ou NULL s'il n'exis-
   tait pas de bloc assez grand pour satisfaire la requête.

   REMARQUE
   Un  programme  ne peut avoir, à un instant donné  plus de  20 blocs 
   alloués  par 'Malloc()'.  Dépasser cette  limite  peut désemparer le
   GEMDOS.   (Il  est  cependant  possible  de  faire  le  nombre    de
   'Malloc()' que  l'on  veut  à  condition  de  les   faire suivre par
   l'appel  de  la  fonction  Mfree(),  20 étant  le  nombre maximum de
   fragments qu'un programme peut générer).
   *------------------------------------------------------------------*
   $49 Mfree     Libération de mémoire
        WORD Mfree(adbloc)
        LONG adbloc;
   Libère le bloc mémoire commençant à 'adbloc'.   Le bloc doit être un
   de ceux alloués par Malloc().

   RETOUR
        0 si la libération s'est bien Effectuée.
        ERROR ou le numéro d'erreur approprié sinon.
   *------------------------------------------------------------------*
   $4A Mshrink   Rétrécit la taille d'un bloc alloué
        WORD Mshrink(0,bloc,nouvtail)
        WORD) 0;
        LONG bloc;
        LONG nouvtail;
   Rétrécit  la  taille d'un bloc mémoire alloué.  'bloc' pointe sur la
   page   de  base  d'un programme ou sur un bloc de mémoire alloué par
   Malloc(), 'nouvtail' est la nouvelle taille du bloc.
   Le premier argument du bloc doit être un mot nul.

   RETOUR
        0        si l'ajustement de taille à été réussi.
        EIMBA    si l'adresse du bloc mémoire était invalide.
        EGSBF    si la nouvelle taille demandée était Erronée.

   REMARQUE
        un  bloc  ne peut être que rétréci;  la nouvelle taille du bloc
        doit forcément être inférieure à la précédente.

   N.D.T.:Le   compilateur  'C' Alcyon rajoute, lors de la compilation,
   le   premier  paramètre d'appel '0'.   Il ne faut donc pas le mettre
   dans l'appel de la fonction si l'on  se  sert  de ce compilateur.

   Appel de la fonction avec le 'C' Alcyon :  Mshrink(bloc,nouvtail);
   *------------------------------------------------------------------*
   $4B Pexec     Charge/Exécute un programme
        WORD Pexec(mode,ptr1,ptr2,ptr3)
        WORD mode;
        char *ptr1;
        char *ptr2;
        char *ptr3;

   Cette  fonction  permet  différentes  utilisations  selon le drapeau
   'mode':

        ___________________________________________________________
       |     mode     |     ptr1     |    ptr2     |      ptr3     |
       |--------------|--------------|-------------|---------------|
       | 0: charge et | le fichier à |  le jeu de  |  la chaîne d' |
       |     exécute  |   exécuter   |  commandes  | environnement |
       |--------------|--------------|-------------|---------------|
       | 3: charge    | le fichier à |  le jeu de  | la chaîne d'  |
       |   sans lancer| charger      |  commandes  | environnement |
       |--------------|--------------|-------------|---------------|
       | 4: exécute   | l'adr. de la | (inutilisé) | (inutilisé)   |
       |    uniquement| page de base |             |               |
       |--------------|--------------|-------------|---------------|
       | 5: crée une  | (inutilisé)  |  le jeu de  | la chaîne d'  |
       |  page de base|              |  commandes  | environnement |
       |______________|______________|_____________|_______________|

   Le  nom  du fichier à charger ou à exécuter, 'ptr1', et la chaîne du
   jeu  de  commandes,  'ptr2',  sont des chemins,  terminés par 0.  La
   chaîne   d'environnement   'ptr3',  est  soit  NULL  (0L),  soit  un
   pointeur sur une structure de chaîne de la forme:
                  "chaîne1\0"
                  "chaîne2\0"
                  etc...
                  "chaîne3\0"
                  "\0"

   La  chaîne   d'environnement   peut être n'importe  quel  numéro  de
   chaîne  finie  par un 0,  suivie par une chaîne nulle (un simple 0).
   Le   programme   hérite   d'une copie de  la chaîne  d'environnement
   parente si 'ptr3' est 'NULL'.

   Le   mode   0  (charge et exécute)  chargera  le  fichier  spécifié,
   composera  sa  page de base, et l'exécutera. La valeur retournée par
   Pexec() sera  le  code de sortie du processus enfant (voir  Pterm0()
   et Pterm()).

   Le   mode 3  (charge  sans exécuter)  chargera le  fichier spécifié,
   composera   la  page  de base,  et retournera un pointeur sur  cette
   page de base. Le programme n'est pas exécuté.

   Le   mode 4 (exécute  seulement) reçoit un pointeur sur une page  de
   base.   Le  programme commence son exécution au début de la zone  de
   texte, comme spécifié dans la page de base.

   Le   mode 5  (création d'une page de base)  allouera le  plus  grand
   bloc   libre  de mémoire et créera la plus grande partie de sa  page
   de    base.   Quelques   entrées   comme   la  taille  des  zones de
   texte/données  initialisées/données    non    initialisées  et  leur
   adresse  de base NE SONT PAS installées.  Le programme appelant en a
   la charge.

   Un programme enfant hérite des descripteurs de fichiers  standards
   de  son  parent.  Il  emploie en fait un appel  de  Fdup()  et  de
   Fforce() sur les identificateurs 0 à 5.

   Puisque les ressources système sont alloués lors de la création de
   la  page de base,  le processus engendré DOIT se terminer  en  les
   libérant.  Ceci  est particulièrement important lors  de  l'emploi
   d'overlays.  (voir  'le  livre de cuisine de Pexec' pour  plus  de
   détails sur Pexec()).
   *------------------------------------------------------------------*
   $4C Pterm     Termine un programme
        void Pterm(retcode)
        WORD retcode;
   Termine le programme courant,  ferme tous les fichiers ouverts  et
   libère la mémoire allouée. Retourne 'retcode' au processus parent.
   *------------------------------------------------------------------*
   $4E Fsfirst   Recherche la première occurence d'un fichier
        WORD Fsfirst(fspec,attribs)
        char *fspec;
        WORD attribs;
   Recherche la première occurence  du fichier   'fspec'.   Le spécifi-
   cateur  de  fichier peut contenir des  caractères  spéciaux ('?'  ou
    '*') dans  le  nom  de  fichier  mais  pas dans le chemin de spéci-
   fication. 'attribs' contrôle  le  type  de fichier qu  sera retourné
   par  Fsfirst().   Son format a été décrit  dans la documentation sur
   'Fattrib()'.

   Si   'attribs'  est   à zéro,  les  fichiers  normaux  seront  seuls
   recherchés  (aucun  nom de volume, fichier caché, sous-répertoire ou
   fichier  système  ne sera retourné). Si 'attribs' est positionné sur
   les  fichiers  cachés  ou  sur les fichiers systèmes, alors  ceux_ci
   seront   pris  en  compte  pour la recherche. Si 'attribs' est posi-
   tionné pour trouver un nom de volume,  alors seuls les noms de volu-
   me seront recherchés.

   Lorsqu'un   fichier   est trouvé,  une structure de  44  octets  est
   écrite à l'emplacement pointé par le DTA.
            _________________________________________________
           | offset |  taille  |   contenus                  |
           |--------|----------|-----------------------------|
           | 0 à 20 |          | (réservés)                  |
           |   21   |  octet   | bits d'attributs            |
           |   22   |  mot     | heure de création           |
           |   24   |  mot     | date de création            |
           |   26   |  long    | taille du fichier           |
           |   30   | 14 octets| nom et extension du fichier |
           |________|__________|_____________________________|

   Le  nom  de fichier et son extension se terminent  par  0,  et  ne
   contiennent pas d'espaces.
   RETOUR   0 si le fichier a été trouvé
            EFILNF     si   le   fichier n'a pas été trouvé,     ou  le
            numéro d'erreur approprié.
   *------------------------------------------------------------------*
   $4F Fsnext    Recherche des occurences suivantes
        WORD Fsnext()
   Recherche   les   occurences suivantes  d'un  fichier.  La  première
   occurence  devra  être recherchée par Fsfirst().  Les octets de 0  à
   20 doivent  rester  inchangés depuis l'appel de Fsfirst() ou  depuis
   le dernier appel de Fsnext().

   RETOUR   0 si le fichier a été trouvé
        ENMFIL     s'il  n'y a plus de fichiers trouvés,  ou le  numéro
        d'erreur approprié.
   *------------------------------------------------------------------*
   $56 Frename   Renomme un fichier
        WORD Frename(0,ancnom,nouvnom)
        WORD) 0;
        char *ancnom;
        char *nouvnom;
   Renomme  un  fichier 'ancnom' en 'nouvnom'.  Le nouveau nom ne  doit
   pas déjà exister mais peut être dans un autre répertoire.

   Le premier paramètre doit être 0 (mot).

   RETOUR   0         si OK
            EACCDN    si le nouveau nom existe déjà
            EPTHNF    si l'ancien nom n'a pas été trouvé
            ENSAME    si l'identificateur de disque (A,B,..) n'est  
                      pas le même pour les deux noms.
   *------------------------------------------------------------------*
   $57 Fdatime   Fixe ou demande le moment de création d'un fichier
         void Fdatime(idfich,pttemp,drap)
        WORD idfich;
        LONG pttemp;
        WORD drap;
   Le  fichier  est reconnu par son identificateur  'idfich'.  'pttemp'
   pointe   sur  deux mots contenant l'heure et la date en  format  DOS
   (l'heure se trouve dans le premier mot,  la date dans le  second).

   Si  'drap' est à 1,  la date et l'heure sont placées dans le fichier
   à partir de 'pttemp'.

   Si   'drap' est  à  0, la date et l'heure sont lues et placées  dans
   'pttemp'.
   *------------------------------------------------------------------*

Back to ASM_Tutorial