[BACK]Return to rpl.h CVS log [TXT] [DIR] Up to [local] / rpl / src

Diff for /rpl/src/rpl.h between versions 1.176 and 1.191

version 1.176, 2012/09/29 17:53:02 version 1.191, 2012/12/20 15:32:52
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.10    RPL/2 (R) version 4.1.12
   Copyright (C) 1989-2012 Dr. BERTRAND Joël    Copyright (C) 1989-2012 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 188 Line 188
 #   include <ieeefp.h>  #   include <ieeefp.h>
 #endif  #endif
   
 // Définition spécifique à Hurd  // Définition spécifique à Hurd
 #ifndef PIPE_BUF  #ifndef PIPE_BUF
 #   define fpathconf (".", _PC_PIPE_BUF)  #   define fpathconf (".", _PC_PIPE_BUF)
 #endif  #endif
Line 226 Line 226
   
 /*  /*
 ================================================================================  ================================================================================
   Bugs spécifiques    Bugs spécifiques
 ================================================================================  ================================================================================
 */  */
   
 // Néant  // Néant
   
 /*  /*
 ================================================================================  ================================================================================
Line 252  enum signaux_rpl Line 252  enum signaux_rpl
     rpl_signull = 0,      rpl_signull = 0,
     rpl_sigint,      rpl_sigint,
     rpl_sigterm,      rpl_sigterm,
     rpl_sigstart,       // Signal envoyé par un père pour lancer son fils.      rpl_sigstart,       // Signal envoyé par un père pour lancer son fils.
     rpl_sigcont,        // Signal de redémarrage d'un processus arrêté par      rpl_sigcont,        // Signal de redémarrage d'un processus arrêté par
                         // SUSPEND                          // SUSPEND
     rpl_sigstop,        // Signal d'arrêt envoyé par l'instruction STOP ou      rpl_sigstop,        // Signal d'arrêt envoyé par l'instruction STOP ou
                         // FUSE. (FSTOP)                          // FUSE. (FSTOP)
     rpl_sigabort,       // Signal envoyé par l'instruction ABORT (à regrouper      rpl_sigabort,       // Signal envoyé par l'instruction ABORT (à regrouper
                         // avec FABORT)                          // avec FABORT)
     rpl_sigurg,         // Signal d'arrêt urgent      rpl_sigurg,         // Signal d'arrêt urgent
     rpl_siginject,      // Signal indiquant la présence d'une donnée à lire      rpl_siginject,      // Signal indiquant la présence d'une donnée à lire
                         // envoyée depuis le père                          // envoyée depuis le père
     rpl_sigalrm,        // Signal d'alarme (erreur système) depuis un fils      rpl_sigalrm,        // Signal d'alarme (erreur système) depuis un fils
     rpl_sighup,      rpl_sighup,
     rpl_sigtstp,      rpl_sigtstp,
     rpl_sigexcept,      rpl_sigexcept,
Line 271  enum signaux_rpl Line 271  enum signaux_rpl
   
 #define LONGUEUR_QUEUE_SIGNAUX          1024  #define LONGUEUR_QUEUE_SIGNAUX          1024
   
 // Une structure s_queue_signaux est créée par processus (et non par thread).  // Une structure s_queue_signaux est créée par processus (et non par thread).
 // Elle est projetée dans un segment de mémoire partagée pour qu'elle soit  // Elle est projetée dans un segment de mémoire partagée pour qu'elle soit
 // accessible à la fois du père et des fils.  // accessible à la fois du père et des fils.
   
 #ifndef RPLARGS  #ifndef RPLARGS
 typedef struct queue_signaux  typedef struct queue_signaux
Line 334  union semun Line 334  union semun
   
 /*  /*
 ================================================================================  ================================================================================
   SÉMAPHORES    SÉMAPHORES
 ================================================================================  ================================================================================
 */  */
   
Line 360  union semun Line 360  union semun
   
 #ifndef RPLARGS  #ifndef RPLARGS
   
 // Signaux utilisés par défaut :  // Signaux utilisés par défaut :
 //  SIGINT  //  SIGINT
 //  SIGTSTP  //  SIGTSTP
 //  SIGCONT  //  SIGCONT
 //  SIGPIPE  //  SIGPIPE
 //  SIGUSR1 et SIGUSR2 sont utilisé par libsigsegv.  //  SIGUSR1 et SIGUSR2 sont utilisé par libsigsegv.
 //  SIGHUP  //  SIGHUP
 //  SIGALRM  //  SIGALRM
   
Line 377  union semun Line 377  union semun
   
 /*  /*
 ================================================================================  ================================================================================
   Granularité temporelle    Granularité temporelle
 ================================================================================  ================================================================================
 */  */
   
Line 445  union semun Line 445  union semun
                                             __STATIC_MUTEX_INITIALIZATION__;                                              __STATIC_MUTEX_INITIALIZATION__;
     __EXTERN__ pthread_mutex_t      mutex_gestionnaires_signaux_atomique      __EXTERN__ pthread_mutex_t      mutex_gestionnaires_signaux_atomique
                                             __STATIC_MUTEX_INITIALIZATION__;                                              __STATIC_MUTEX_INITIALIZATION__;
       __EXTERN__ pthread_mutex_t      mutex_creation_variable_partagee
                                               __STATIC_MUTEX_INITIALIZATION__;
     __EXTERN__ pthread_mutex_t      mutex_sections_critiques;      __EXTERN__ pthread_mutex_t      mutex_sections_critiques;
       __EXTERN__ pthread_mutex_t      mutex_liste_variables_partagees;
   
     __EXTERN__ sem_t __PTR__        semaphore_gestionnaires_signaux;      __EXTERN__ sem_t __PTR__        semaphore_gestionnaires_signaux;
   
Line 464  int sem_destroy3(sem_t *semaphore_p, pid Line 467  int sem_destroy3(sem_t *semaphore_p, pid
 int sem_getvalue2(sem_t *semaphore, int *valeur);  int sem_getvalue2(sem_t *semaphore, int *valeur);
 sem_t *sem_open2(pid_t pid, int ordre);  sem_t *sem_open2(pid_t pid, int ordre);
   
 // Le mutex est là uniquement pour pouvoir émuler le comportement  // Le mutex est là uniquement pour pouvoir émuler le comportement
 // de sem_getvalue() sur un système comme MacOS X qui ne possède pas  // de sem_getvalue() sur un système comme MacOS X qui ne possède pas
 // cette fonction.  // cette fonction.
   
 #define sem_getvalue(semaphore, value) sem_getvalue2(semaphore, value)  #define sem_getvalue(semaphore, value) sem_getvalue2(semaphore, value)
Line 486  sem_t *sem_open2(pid_t pid, int ordre); Line 489  sem_t *sem_open2(pid_t pid, int ordre);
 ================================================================================  ================================================================================
 */  */
   
 // Par défaut, tout est redirigé vers stderr sauf indication explicite de  // Par défaut, tout est redirigé vers stderr sauf indication explicite de
 // stdout.  // stdout.
   
 #define printf(...) transliterated_fprintf(s_etat_processus, \  #define printf(...) transliterated_fprintf(s_etat_processus, \
Line 518  sem_t *sem_open2(pid_t pid, int ordre); Line 521  sem_t *sem_open2(pid_t pid, int ordre);
 #   define fflush(flux) fflush((flux == stdout) ? stderr : flux)  #   define fflush(flux) fflush((flux == stdout) ? stderr : flux)
 #endif  #endif
   
 // Ajout d'un timeout sur les fonctions pipe() pour éviter une erreur  // Ajout d'un timeout sur les fonctions pipe() pour éviter une erreur
 // système dans le cas où l'on a atteint le nombre maximale de fichiers  // système dans le cas où l'on a atteint le nombre maximale de fichiers
 // ouverts.  // ouverts.
   
 #define pipe(descripteurs) \  #define pipe(descripteurs) \
Line 538  sem_t *sem_open2(pid_t pid, int ordre); Line 541  sem_t *sem_open2(pid_t pid, int ordre);
         erreur; \          erreur; \
      })       })
   
 // Redéfinition de abs pour un fonctionnement en entier de type long long int  // Redéfinition de abs pour un fonctionnement en entier de type long long int
   
 #ifdef __GNUC__  #ifdef __GNUC__
 #   define abs(i) ({ typeof(i) _i; _i = (i); (_i >= 0) ? _i : -_i; })  #   define abs(i) ({ typeof(i) _i; _i = (i); (_i >= 0) ? _i : -_i; })
 // typeof() est une extension de gcc, mais est présent sur d'autres compilateurs  // typeof() est une extension de gcc, mais est présent sur d'autres compilateurs
 // comme Sun Studio. Dans le cas où typeof() n'existe pas, il est possible  // comme Sun Studio. Dans le cas où typeof() n'existe pas, il est possible
 // d'utiliser la macro suivante, mais elle possède un effet de bord dû à  // d'utiliser la macro suivante, mais elle possède un effet de bord dû à
 // l'évaluation multiple de l'argument.  // l'évaluation multiple de l'argument.
 #else  #else
 #   define abs(i) (((i) >= 0) ? (i) : (-i))  #   define abs(i) (((i) >= 0) ? (i) : (-i))
 #endif  #endif
Line 720  pid_t debug_fork(); Line 723  pid_t debug_fork();
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Paramètres du système    Paramètres du système
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 739  pid_t debug_fork(); Line 742  pid_t debug_fork();
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Erreurs système    Erreurs système
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   #define DEBUG_ERREURS
 #ifdef DEBUG_ERREURS  #ifdef DEBUG_ERREURS
 #   ifdef MESSAGES  #   ifdef MESSAGES
 #       define __erreur(i)  i  #       define __erreur(i)  i
Line 765  pid_t debug_fork(); Line 768  pid_t debug_fork();
 #endif  #endif
   
   
 // -1 : erreur provoquée par une bibliothèque externe  // -1 : erreur provoquée par une bibliothèque externe
 #ifndef RPLARGS  #ifndef RPLARGS
 #   define d_es                                 2000  #   define d_es                                 2000
 #   define d_es_allocation_memoire              __erreur(2001)  #   define d_es_allocation_memoire              __erreur(2001)
Line 831  pid_t debug_fork(); Line 834  pid_t debug_fork();
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Erreurs à l'exécution    Erreurs à l'exécution
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
 // -1 : erreur provoquée par une bibliothèque externe  // -1 : erreur provoquée par une bibliothèque externe
 #ifndef RPLARGS  #ifndef RPLARGS
 #   define d_ex                                 0  #   define d_ex                                 0
 #   define d_ex_pile_vide                       __erreur(1)  #   define d_ex_pile_vide                       __erreur(1)
Line 983  enum t_type  { ADR = 0, ALG, BIN, CHN, C Line 986  enum t_type  { ADR = 0, ALG, BIN, CHN, C
                 SLB, SPH, SQL, TBL, VCX, VIN, VRL };                  SLB, SPH, SQL, TBL, VCX, VIN, VRL };
   
     /*      /*
     ADR : adresse sur 32 bits (au moins) non signés (unsigned long)      ADR : adresse sur 32 bits (au moins) non signés (unsigned long)
             Adresse d'une définition à interpréter.              Adresse d'une définition à interpréter.
   
     ALG : expression algébrique (struct_liste_chainee *)      ALG : expression algébrique (struct_liste_chainee *)
             La liste chaînée contient la définition convertie en notation              La liste chaînée contient la définition convertie en notation
             polonaise inversée. Ce type diffère du type 'RPN' au niveau              polonaise inversée. Ce type diffère du type 'RPN' au niveau
             du format de sortie (notation algébrique).              du format de sortie (notation algébrique).
   
     BIN : entier binaire sur 64 bits (unsigned integer8 *)      BIN : entier binaire sur 64 bits (unsigned integer8 *)
             Sans objet.              Sans objet.
Line 1004  enum t_type  { ADR = 0, ALG, BIN, CHN, C Line 1007  enum t_type  { ADR = 0, ALG, BIN, CHN, C
   
     FCH : descripteur de fichier (struct_fichier *).      FCH : descripteur de fichier (struct_fichier *).
   
     FCT : déclaration d'une fonction et de son nombre d'arguments      FCT : déclaration d'une fonction et de son nombre d'arguments
             (struct_fonction *). Ce type n'est nécessaire que dans le              (struct_fonction *). Ce type n'est nécessaire que dans le
             traitement des types 'ALG' et 'RPN'.              traitement des types 'ALG' et 'RPN'.
   
     INT : entier sur 64 bits (integer*8, integer8 *)      INT : entier sur 64 bits (integer*8, integer8 *)
Line 1013  enum t_type  { ADR = 0, ALG, BIN, CHN, C Line 1016  enum t_type  { ADR = 0, ALG, BIN, CHN, C
             Type C/Fortran : integer8              Type C/Fortran : integer8
   
     LST : liste (struct_liste_chainee *)      LST : liste (struct_liste_chainee *)
             Les objets sont enregistrés sous forme de liste chaînée récursive.              Les objets sont enregistrés sous forme de liste chaînée récursive.
             Cela permet de traiter des tableaux de données hétérogènes de              Cela permet de traiter des tableaux de données hétérogènes de
             grandes dimensions. Le nombre de dimensions maximal est fixé par              grandes dimensions. Le nombre de dimensions maximal est fixé par
             la mémoire de la station.              la mémoire de la station.
   
     MCX : matrice de complexes (struct_matrice *)      MCX : matrice de complexes (struct_matrice *)
             Sans objet.              Sans objet.
Line 1040  enum t_type  { ADR = 0, ALG, BIN, CHN, C Line 1043  enum t_type  { ADR = 0, ALG, BIN, CHN, C
             Sans objet.              Sans objet.
   
     RPN : definition (struct_liste_chainee *)      RPN : definition (struct_liste_chainee *)
             Ce type diffère du type 'ALG' au niveau du format de sortie              Ce type diffère du type 'ALG' au niveau du format de sortie
             (notation polonaise inversée).              (notation polonaise inversée).
   
     SCK : socket (struct_socket *)      SCK : socket (struct_socket *)
   
     SLB : bibliothèque dynamique partagée (struct_bibliotheque *)       SLB : bibliothèque dynamique partagée (struct_bibliotheque *) 
             Sans objet.              Sans objet.
   
     SPH : sémaphore nommé (struct_semaphore *)      SPH : sémaphore nommé (struct_semaphore *)
   
     SQL : connecteur sur une base de données SQL (struct_connecteur_sql *)      SQL : connecteur sur une base de données SQL (struct_connecteur_sql *)
   
     TBL : tableau multidimensionnel d'objets (struct_tableau *).      TBL : tableau multidimensionnel d'objets (struct_tableau *).
   
Line 1120  typedef struct rpl_mutex Line 1123  typedef struct rpl_mutex
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Structure sémaphore    Structure sémaphore
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 1152  typedef struct marque Line 1155  typedef struct marque
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Structure bibliothèque    Structure bibliothèque
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 1224  typedef struct connecteur_sql Line 1227  typedef struct connecteur_sql
 #       ifdef POSTGRESQL_SUPPORT  #       ifdef POSTGRESQL_SUPPORT
             PGconn              *postgresql;              PGconn              *postgresql;
 #       endif  #       endif
           sqlite3                 *sqlite;
     } descripteur;      } descripteur;
 } struct_connecteur_sql;  } struct_connecteur_sql;
 #endif  #endif
Line 1237  typedef struct connecteur_sql Line 1241  typedef struct connecteur_sql
             "POSTGRESQL") == 0) \              "POSTGRESQL") == 0) \
         postgresqlclose((*((struct_connecteur_sql *) (*s_objet).objet)) \          postgresqlclose((*((struct_connecteur_sql *) (*s_objet).objet)) \
                 .descripteur); \                  .descripteur); \
       else if (strcmp((*((struct_connecteur_sql *) (*s_objet).objet)).type, \
               "SQLITE") == 0) \
           sqlite3_close((*((struct_connecteur_sql *) (*s_objet).objet)) \
                   .descripteur.sqlite); \
     else \      else \
         BUG(1, uprintf("SQL type '%s' not allowed!", \          BUG(1, uprintf("SQL type '%s' not allowed!", \
                 (*((struct_connecteur_sql *) (*s_objet).objet)).type));                  (*((struct_connecteur_sql *) (*s_objet).objet)).type));
Line 1272  typedef struct socket Line 1280  typedef struct socket
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Structure liste chaînee    Structure liste chaînee
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 1297  typedef struct gestion_signaux Line 1305  typedef struct gestion_signaux
     unsigned char               masque_signaux[d_NOMBRE_SIGNAUX];      unsigned char               masque_signaux[d_NOMBRE_SIGNAUX];
   
     /*      /*
      * 'I' : signal ignoré       * 'I' : signal ignoré
      * 'Q' : signal mis en queue pour un traitement ultérieur       * 'Q' : signal mis en queue pour un traitement ultérieur
      * 'N' : traitement normal du signal       * 'N' : traitement normal du signal
      */       */
   
Line 1346  typedef struct liste_profilage2 Line 1354  typedef struct liste_profilage2
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Structure contenant les fichiers graphiques (liste chaînée)    Structure contenant les fichiers graphiques (liste chaînée)
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 1378  typedef struct nom Line 1386  typedef struct nom
 {  {
     unsigned char               *nom;      unsigned char               *nom;
     logical1                    symbole;    /* d_vrai/d_faux */      logical1                    symbole;    /* d_vrai/d_faux */
     // symbole == d_vrai signifie que le nom a été introduit dans un      // symbole == d_vrai signifie que le nom a été introduit dans un
     // calcul sans les apostrophes.      // calcul sans les apostrophes.
 } struct_nom;  } struct_nom;
   
Line 1460  typedef struct liste_pile_systeme Line 1468  typedef struct liste_pile_systeme
     clause :      clause :
     I : IF      I : IF
     R : IFERR      R : IFERR
     X : IFERR indiquant la présence d'une erreur.      X : IFERR indiquant la présence d'une erreur.
     T : THEN      T : THEN
     E : ELSE      E : ELSE
     Z : traitement en cours de ELSE      Z : traitement en cours de ELSE
Line 1469  typedef struct liste_pile_systeme Line 1477  typedef struct liste_pile_systeme
     W : WHILE      W : WHILE
     M : WHILE avec une clause fausse.      M : WHILE avec une clause fausse.
     S : SELECT      S : SELECT
     K : aucun cas CASE n'a encore été traité.      K : aucun cas CASE n'a encore été traité.
     C : au moins un cas de SELECT...CASE a été traité.      C : au moins un cas de SELECT...CASE a été traité.
     Q : traitement en cours d'un cas CASE.      Q : traitement en cours d'un cas CASE.
     F : traitement du cas DEFAULT      F : traitement du cas DEFAULT
     */      */
Line 1481  typedef struct liste_pile_systeme Line 1489  typedef struct liste_pile_systeme
     unsigned char               type_cloture;      unsigned char               type_cloture;
   
     /*      /*
     type clôture :      type clôture :
     C     SELECT   : END termine un test SELECT/DEFAULT/END.      C     SELECT   : END termine un test SELECT/DEFAULT/END.
     D     DO       : END termine une boucle DO/UNTIL/END.      D     DO       : END termine une boucle DO/UNTIL/END.
     I     IF       : END termine un test IF/THEN (ELSE)/END.      I     IF       : END termine un test IF/THEN (ELSE)/END.
Line 1492  typedef struct liste_pile_systeme Line 1500  typedef struct liste_pile_systeme
   
     F     FOR     : NEXT ou STEP termine une boucle avec compteur.      F     FOR     : NEXT ou STEP termine une boucle avec compteur.
     S     START   : NEXT ou STEP termine une boucle sans compteur.      S     START   : NEXT ou STEP termine une boucle sans compteur.
     L     LOOP    : boucle utilisé dans le traitement de l'instruction RETURN.      L     LOOP    : boucle utilisé dans le traitement de l'instruction RETURN.
             Elle correspond à une boucle FOR ou START mais sans son              Elle correspond à une boucle FOR ou START mais sans son
             initialisation.              initialisation.
     A     FORALL  : NEXT termine une boucle sur un objet.      A     FORALL  : NEXT termine une boucle sur un objet.
     */      */
Line 1521  typedef union position_variable Line 1529  typedef union position_variable
 typedef struct variable  typedef struct variable
 {  {
     unsigned char           *nom;      unsigned char           *nom;
     unsigned char           origine;      unsigned char           origine; // P(rogramme) ou E(valuation)
   
     unsigned long           niveau;      unsigned long           niveau;
   
Line 1537  typedef struct variable Line 1545  typedef struct variable
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Structure variable partagée    Structure variable partagée
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 1553  typedef struct variable_partage Line 1561  typedef struct variable_partage
     union_position_variable     variable_partagee;      union_position_variable     variable_partagee;
   
     struct_objet                *objet;      struct_objet                *objet;
 } struct_variable_partagee;  
   
 typedef struct table_variables_partagees  
 {  
     pthread_mutex_t                     mutex;  
   
     volatile struct_variable_partagee   *table;  
   
     volatile unsigned long              nombre_variables;      pthread_mutex_t             mutex;
     volatile unsigned long              nombre_variables_allouees;  } struct_variable_partagee;
   
     unsigned long                       position_variable;  
 } struct_table_variables_partagees;  
   
 #endif  #endif
   
Line 1582  typedef struct variable_statique Line 1580  typedef struct variable_statique
     unsigned char           *nom;      unsigned char           *nom;
     unsigned char           origine;      unsigned char           origine;
   
     // Position de création de la variable statique dans le programme ou dans      // Position de création de la variable statique dans le programme ou dans
     // l'expression. 'origine' vaut 'P' pour programme ou 'E' pour expression.      // l'expression. 'origine' vaut 'P' pour programme ou 'E' pour expression.
   
     unsigned long           niveau;      unsigned long           niveau;
Line 1690  typedef struct rpl_arguments Line 1688  typedef struct rpl_arguments
 /* Traitement des erreurs                               */  /* Traitement des erreurs                               */
   
     unsigned char               *message_erreur;      unsigned char               *message_erreur;
     unsigned char               type_erreur;            /* S = système      unsigned char               type_erreur;            /* S = système
                                                            E = exécution */                                                             E = exécution */
     integer8                    erreur;      integer8                    erreur;
   
 /* Traitement des messages d'aide                       */  /* Traitement des messages d'aide                       */
Line 1715  typedef struct rpl_arguments Line 1713  typedef struct rpl_arguments
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Structure d'arbre des instructions intrinsèques    Structure d'arbre des instructions intrinsèques
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 1729  typedef struct instruction Line 1727  typedef struct instruction
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Structure d'arbre des variables variable globales et locales    Structure d'arbre des variables globales et locales
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
 #ifndef RPLARGS  #ifndef RPLARGS
 typedef struct arbre_variables  typedef struct arbre_variables
 {  {
     unsigned int            noeuds_utilises;      unsigned int                        noeuds_utilises;
     signed int              indice_tableau_pere;                                          // Nombre de noeuds utilisés dans le
     struct arbre_variables  *noeud_pere;                                          // tableau **noeuds
     struct arbre_variables  **noeuds;      signed int                          indice_tableau_pere;
     struct liste_variables  *feuille;                                          // Position de la structure dans le
                                           // tableau **noeuds du père
   
       struct arbre_variables              *noeud_pere;
       struct arbre_variables              **noeuds;
   
       struct liste_variables              *feuille;
       struct liste_variables_statiques    *feuille_statique;
 } struct_arbre_variables;  } struct_arbre_variables;
   
   typedef struct arbre_variables_partagees
   {
       unsigned int                        noeuds_utilises;
                                           // Nombre de noeuds utilisés dans le
                                           // tableau **noeuds
       signed int                          indice_tableau_pere;
                                           // Position de la structure dans le
                                           // tableau **noeuds du père
   
       struct arbre_variables_partagees    *noeud_pere;
       struct arbre_variables_partagees    **noeuds;
   
       struct liste_variables_partagees    *feuille;
   
       pthread_mutex_t                     mutex_feuille;
   } struct_arbre_variables_partagees;
   
   #define INITIALISATION_MUTEX(mutex) \
       do { \
           pthread_mutexattr_t     attributs_mutex; \
           pthread_mutexattr_init(&attributs_mutex); \
           pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL); \
           pthread_mutex_init(&(mutex), &attributs_mutex); \
           pthread_mutexattr_destroy(&attributs_mutex); \
       } while(0)
   
 typedef struct tableau_variables  typedef struct tableau_variables
 {  {
     unsigned char           origine;      unsigned char           origine;
     unsigned char           *nom;       // pointeur sur la struct_variable      unsigned char           *nom;       // pointeur sur la struct_variable
                                         // réelle et non copie de la chaîne                                          // réelle et non copie de la chaîne
     unsigned long           niveau;      unsigned long           niveau;
   
     struct_objet            *objet;     // pointeur sur l'objet et non copie      struct_objet            *objet;     // pointeur sur l'objet et non copie
                                         // de l'objet.                                          // de l'objet.
   
     logical1                variable_verrouillee;      logical1                variable_verrouillee;
       logical1                variable_masquee;
     union_position_variable variable_statique;      union_position_variable variable_statique;
     union_position_variable variable_partagee;      union_position_variable variable_partagee;
 } struct_tableau_variables;  } struct_tableau_variables;
   
   // La liste des variables est une liste doublement chaînée et circulaire.
 typedef struct liste_variables  typedef struct liste_variables
 {  {
     union      union
     {      {
         // Utilisation dans la gestion des variables          // Utilisation dans la gestion des variables
         struct_variable                 *variable;          struct_variable                 *variable;
         // Utilisation dans la pile système (variables par niveau)          // Utilisation dans la pile système (variables par niveau)
         struct_liste_chainee            *liste;          struct_liste_chainee            *liste;
     };      };
   
Line 1774  typedef struct liste_variables Line 1807  typedef struct liste_variables
     struct liste_variables              *precedent;      struct liste_variables              *precedent;
 } struct_liste_variables;  } struct_liste_variables;
   
   // La liste des variables statiques et une liste double chaînée et non
   // circulaire.
   typedef struct liste_variables_statiques
   {
       struct liste_variables_statiques    *suivant;
       struct liste_variables_statiques    *precedent;
       struct liste_variables_statiques    *reference;
       struct_arbre_variables              *feuille;
       struct_variable_statique            *variable;
   } struct_liste_variables_statiques;
   
   typedef struct liste_variables_partagees
   {
       struct liste_variables_partagees    *suivant;
       struct liste_variables_partagees    *precedent;
       struct liste_variables_partagees    *reference;
       struct_arbre_variables_partagees    *feuille;
       struct_variable_partagee            *variable;
       pthread_t                           tid;
       pid_t                               pid;
   } struct_liste_variables_partagees;
 #endif  #endif
   
 /*  /*
Line 1863  typedef struct processus Line 1917  typedef struct processus
     logical1                    presence_fusible;      logical1                    presence_fusible;
     pthread_t                   thread_fusible;      pthread_t                   thread_fusible;
     pthread_t                   thread_surveille_par_fusible;      pthread_t                   thread_surveille_par_fusible;
       pthread_t                   thread_signaux;
       int                         pipe_signaux[2];
   
     volatile int                pointeur_signal_ecriture;      volatile int                pointeur_signal_ecriture;
     volatile int                pointeur_signal_lecture;      volatile int                pointeur_signal_lecture;
Line 1877  typedef struct processus Line 1933  typedef struct processus
   
 /* Variables                                            */  /* Variables                                            */
   
     // La liste des variables par niveau est doublement chaînée.      // La liste des variables par niveau est doublement chaînée.
     // À tout moment, elle pointe sur le niveau le plus haut existant et      // À tout moment, elle pointe sur le niveau le plus haut existant et
     // l_liste_variable_par_niveau->precedent renvoie la liste des      // l_liste_variable_par_niveau->precedent renvoie la liste des
     // définitions. l_liste_variable_par_niveau->precedent->precedent pointe      // définitions. l_liste_variable_par_niveau->precedent->precedent pointe
     // sur la liste des variables globales.      // sur la liste des variables globales.
     //      //
     // À l'initialisation :      // À l'initialisation :
     // l_liste_variables_par_niveau->suivant == l_liste_variables_par_niveau      // l_liste_variables_par_niveau->suivant == l_liste_variables_par_niveau
     // l_liste_variables_par_niveau->precedent == l_liste_variables_par_niveau      // l_liste_variables_par_niveau->precedent == l_liste_variables_par_niveau
   
     struct_arbre_variables      *s_arbre_variables;      struct_arbre_variables      *s_arbre_variables;
     struct_liste_variables      *l_liste_variables_par_niveau;      struct_liste_variables      *l_liste_variables_par_niveau;
       struct_liste_variables_statiques
                                   *l_liste_variables_statiques;
   
       struct_arbre_variables_partagees
                                   **s_arbre_variables_partagees;
       struct_liste_variables_partagees
                                   **l_liste_variables_partagees;
   
     logical1                    niveau_supprime;      logical1                    niveau_supprime;
   
     struct_variable             *pointeur_variable_courante;      struct_variable             *pointeur_variable_courante;
     struct_liste_variables      *pointeur_feuille_courante;      struct_liste_variables      *pointeur_feuille_courante;
       struct_variable_statique    *pointeur_variable_statique_courante;
       struct_variable_partagee    *pointeur_variable_partagee_courante;
   
     int                         *pointeurs_caracteres_variables;      int                         *pointeurs_caracteres_variables;
     int                         nombre_caracteres_variables;      int                         nombre_caracteres_variables;
   
     struct_variable_statique    *s_liste_variables_statiques;  
     unsigned long               nombre_variables_statiques;  
     unsigned long               nombre_variables_statiques_allouees;  
   
     struct_table_variables_partagees  
                                 *s_liste_variables_partagees;  
   
     unsigned long               niveau_courant;      unsigned long               niveau_courant;
     unsigned long               niveau_initial;      unsigned long               niveau_initial;
     unsigned long               position_variable_statique_courante;  
   
     logical1                    creation_variables_statiques;      logical1                    creation_variables_statiques;
     logical1                    creation_variables_partagees;      logical1                    creation_variables_partagees;
Line 1920  typedef struct processus Line 1978  typedef struct processus
   
     struct_liste_chainee        *s_sockets;      struct_liste_chainee        *s_sockets;
   
 /*  Connecteurs aux bases de données                   */  /*  Connecteurs aux bases de données                    */
   
     struct_liste_chainee        *s_connecteurs_sql;      struct_liste_chainee        *s_connecteurs_sql;
   
 /* Bibliothèques dynamiques                                */  /* Bibliothèques dynamiques                             */
   
     struct_liste_chainee        *s_bibliotheques;      struct_liste_chainee        *s_bibliotheques;
     struct_instruction_externe  *s_instructions_externes;      struct_instruction_externe  *s_instructions_externes;
Line 2126  typedef struct processus Line 2184  typedef struct processus
     unsigned char               masque_interruptions[d_NOMBRE_INTERRUPTIONS];      unsigned char               masque_interruptions[d_NOMBRE_INTERRUPTIONS];
   
     /*      /*
      * 'I' : interruption ignorée       * 'I' : interruption ignorée
      * 'Q' : interruption mise en queue pour un traitement ultérieur       * 'Q' : interruption mise en queue pour un traitement ultérieur
      * 'N' : traitement normal de l'interruption       * 'N' : traitement normal de l'interruption
      */       */
   
Line 2149  typedef struct processus Line 2207  typedef struct processus
 /* Variables volatiles                                  */  /* Variables volatiles                                  */
   
     volatile sig_atomic_t       var_volatile_alarme;      volatile sig_atomic_t       var_volatile_alarme;
     // Traitement de ctrl+C et des arrêts brutaux      // Traitement de ctrl+C et des arrêts brutaux
     volatile sig_atomic_t       var_volatile_requete_arret;      volatile sig_atomic_t       var_volatile_requete_arret;
     // Traitement de ctrl+Z      // Traitement de ctrl+Z
     volatile sig_atomic_t       var_volatile_requete_arret2;      volatile sig_atomic_t       var_volatile_requete_arret2;
Line 2176  typedef struct processus Line 2234  typedef struct processus
     integer8                    nombre_arguments;      integer8                    nombre_arguments;
   
     /*      /*
      * Il s'agit du nombre d'arguments utilisé pour l'évaluation       * Il s'agit du nombre d'arguments utilisé pour l'évaluation
      * des expressions algébriques.       * des expressions algébriques.
      * -1 : la fonction ne peut être dans un objet de type ALG.       * -1 : la fonction ne peut être dans un objet de type ALG.
      * -2 : nombre d'arguments inconnu       * -2 : nombre d'arguments inconnu
      *  0 : la fonction doit apparaître en notation infixe       *  0 : la fonction doit apparaître en notation infixe
      * >0 : la fonction apparaît comme une fonction normale       * >0 : la fonction apparaît comme une fonction normale
      */       */
   
     logical1                    lancement_interactif;      logical1                    lancement_interactif;
Line 2207  typedef struct processus Line 2265  typedef struct processus
     struct_liste_profilage2     *pile_profilage_fonctions;      struct_liste_profilage2     *pile_profilage_fonctions;
     struct timeval              horodatage_profilage;      struct timeval              horodatage_profilage;
   
     // Mutex spécifique au processus et donnant accès à la pile des processus      // Mutex spécifique au processus et donnant accès à la pile des processus
     pthread_mutex_t             mutex;      pthread_mutex_t             mutex;
     pthread_mutex_t             mutex_allocation;      pthread_mutex_t             mutex_allocation;
   
Line 2220  typedef struct processus Line 2278  typedef struct processus
     pthread_mutex_t             protection_liste_mutexes;      pthread_mutex_t             protection_liste_mutexes;
     unsigned int                sections_critiques;      unsigned int                sections_critiques;
   
 /* Drapeau nécessaire à RESTART                   */  /* Drapeau nécessaire à RESTART                 */
   
     volatile logical1           requete_redemarrage;      volatile logical1           requete_redemarrage;
   
 /* Gestion optimisée de la mémoire                    */  /* Gestion optimisée de la mémoire                  */
   
     double                      estimation_taille_pile_tampon;      double                      estimation_taille_pile_tampon;
     unsigned long               taille_pile_tampon;      unsigned long               taille_pile_tampon;
Line 2275  typedef struct processus Line 2333  typedef struct processus
     struct_arbre_variables      *variables_noeud[TAILLE_CACHE];      struct_arbre_variables      *variables_noeud[TAILLE_CACHE];
     int                         pointeur_variables_noeud;      int                         pointeur_variables_noeud;
   
       struct_arbre_variables_partagees
                                   *variables_partagees_noeud[TAILLE_CACHE];
       int                         pointeur_variables_partagees_noeud;
   
     struct_liste_variables      *variables_feuille[TAILLE_CACHE];      struct_liste_variables      *variables_feuille[TAILLE_CACHE];
     int                         pointeur_variables_feuille;      int                         pointeur_variables_feuille;
   
Line 2283  typedef struct processus Line 2345  typedef struct processus
   
     struct_arbre_variables      **variables_tableau_noeuds[TAILLE_CACHE];      struct_arbre_variables      **variables_tableau_noeuds[TAILLE_CACHE];
     int                         pointeur_variables_tableau_noeuds;      int                         pointeur_variables_tableau_noeuds;
   
       struct_arbre_variables_partagees
                                   **variables_tableau_noeuds_partages
                                   [TAILLE_CACHE];
       int                         pointeur_variables_tableau_noeuds_partages;
 } struct_processus;  } struct_processus;
 #endif  #endif
   
Line 2314  typedef struct fonction Line 2381  typedef struct fonction
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Procédures d'exécution des mots-clef du langage RPL/2    Procédures d'exécution des mots-clef du langage RPL/2
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 2845  void instruction_yield(struct_processus Line 2912  void instruction_yield(struct_processus
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Procédures    Procédures
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 2962  void liberation_arbre_instructions(struc Line 3029  void liberation_arbre_instructions(struc
         struct_instruction *arbre);          struct_instruction *arbre);
 void liberation_arbre_variables(struct_processus *s_etat_processus,  void liberation_arbre_variables(struct_processus *s_etat_processus,
         struct_arbre_variables *arbre, logical1 definitions);          struct_arbre_variables *arbre, logical1 definitions);
   void liberation_arbre_variables_partagees(struct_processus *s_etat_processus,
           struct_arbre_variables_partagees *arbre);
 void liberation_contexte_cas(struct_processus *s_etat_processus);  void liberation_contexte_cas(struct_processus *s_etat_processus);
 void liberation_generateur_aleatoire(struct_processus *s_etat_processus);  void liberation_generateur_aleatoire(struct_processus *s_etat_processus);
   void liberation_mutexes_arbre_variables_partagees(struct_processus
           *s_etat_processus, struct_arbre_variables_partagees *l_element_courant);
 void liberation_threads(struct_processus *s_etat_processus);  void liberation_threads(struct_processus *s_etat_processus);
 void liberation_profil(struct_processus *s_etat_processus);  void liberation_profil(struct_processus *s_etat_processus);
 void localisation_courante(struct_processus *s_etat_processus);  void localisation_courante(struct_processus *s_etat_processus);
Line 2988  void scrutation_interruptions(struct_pro Line 3059  void scrutation_interruptions(struct_pro
 void sf(struct_processus *s_etat_processus, unsigned char indice_drapeau);  void sf(struct_processus *s_etat_processus, unsigned char indice_drapeau);
 void *surveillance_processus(void *argument);  void *surveillance_processus(void *argument);
 void swap(void *variable_1, void *variable_2, unsigned long taille_octets);  void swap(void *variable_1, void *variable_2, unsigned long taille_octets);
   void *thread_signaux(void *argument);
 void trace(struct_processus *s_etat_processus, FILE *flux);  void trace(struct_processus *s_etat_processus, FILE *flux);
 void traitement_asynchrone_exceptions_gsl(struct_processus *s_etat_processus);  void traitement_asynchrone_exceptions_gsl(struct_processus *s_etat_processus);
 void traitement_exceptions_gsl(const char *reason, const char *file,  void traitement_exceptions_gsl(const char *reason, const char *file,
Line 3030  int envoi_signal_thread(pthread_t tid, e Line 3102  int envoi_signal_thread(pthread_t tid, e
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Fonctions de sommation de vecteur dans perte de précision    Fonctions de sommation de vecteur dans perte de précision
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 3076  struct_vecteur *variance_statistique(str Line 3148  struct_vecteur *variance_statistique(str
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Gestion des bibliothèques    Gestion des bibliothèques
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 3157  unsigned char *transliteration(struct_pr Line 3229  unsigned char *transliteration(struct_pr
   
 #ifndef RPLARGS  #ifndef RPLARGS
 logical1 analyse_syntaxique(struct_processus *s_etat_processus);  logical1 analyse_syntaxique(struct_processus *s_etat_processus);
   logical1 arret_thread_signaux(struct_processus *s_etat_processus);
 logical1 caracteristiques_fichier(struct_processus *s_etat_processus,  logical1 caracteristiques_fichier(struct_processus *s_etat_processus,
         unsigned char *nom, logical1 *existence, logical1 *ouverture,          unsigned char *nom, logical1 *existence, logical1 *ouverture,
         unsigned long *unite);          unsigned long *unite);
Line 3187  logical1 initialisation_fichier_acces_di Line 3260  logical1 initialisation_fichier_acces_di
         sqlite3 *sqlite, logical1 binaire);          sqlite3 *sqlite, logical1 binaire);
 logical1 initialisation_fichier_acces_indexe(struct_processus *s_etat_processus,  logical1 initialisation_fichier_acces_indexe(struct_processus *s_etat_processus,
         sqlite3 *sqlite, integer8 position_clef, logical1 binaire);          sqlite3 *sqlite, integer8 position_clef, logical1 binaire);
   logical1 lancement_thread_signaux(struct_processus *s_etat_processus);
 logical1 recherche_instruction_suivante(struct_processus *s_etat_processus);  logical1 recherche_instruction_suivante(struct_processus *s_etat_processus);
 logical1 retrait_variable(struct_processus *s_etat_processus,  logical1 retrait_variable(struct_processus *s_etat_processus,
         unsigned char *nom_variable, unsigned char type);          unsigned char *nom_variable, unsigned char type);
 logical1 retrait_variable_par_niveau(struct_processus *s_etat_processus);  logical1 retrait_variables_par_niveau(struct_processus *s_etat_processus);
 logical1 retrait_variable_partagee(struct_processus *s_etat_processus,  logical1 retrait_variable_partagee(struct_processus *s_etat_processus,
         unsigned char *nom_variable, union_position_variable position);          unsigned char *nom_variable, union_position_variable position);
   logical1 retrait_variables_partagees_locales(
           struct_processus *s_etat_processus);
 logical1 retrait_variable_statique(struct_processus *s_etat_processus,  logical1 retrait_variable_statique(struct_processus *s_etat_processus,
         unsigned char *nom_variable, union_position_variable position);          unsigned char *nom_variable, union_position_variable position);
   logical1 retrait_variables_statiques_locales(
           struct_processus *s_etat_processus);
 logical1 sequenceur(struct_processus *s_etat_processus);  logical1 sequenceur(struct_processus *s_etat_processus);
 logical1 sequenceur_optimise(struct_processus *s_etat_processus);  logical1 sequenceur_optimise(struct_processus *s_etat_processus);
 #endif  #endif
Line 3217  logical1 recherche_variable(struct_proce Line 3295  logical1 recherche_variable(struct_proce
         unsigned char *nom_variable);          unsigned char *nom_variable);
 logical1 recherche_variable_globale(struct_processus *s_etat_processus,  logical1 recherche_variable_globale(struct_processus *s_etat_processus,
         unsigned char *nom_variable);          unsigned char *nom_variable);
 logical1 recherche_variable_partagee(struct_processus *s_etat_processus,  
         unsigned char *nom_variable, union_position_variable position,  
         unsigned char origine);  
 logical1 recherche_variable_statique(struct_processus *s_etat_processus,  
         unsigned char *nom_variable, union_position_variable position,  
         unsigned char origine);  
 logical1 test_cfsf(struct_processus *s_etat_processus,  logical1 test_cfsf(struct_processus *s_etat_processus,
         unsigned char indice_drapeau);          unsigned char indice_drapeau);
 logical1 test_expression_rpn(unsigned char *chaine);  logical1 test_expression_rpn(unsigned char *chaine);
Line 3253  int alsprintf(unsigned char **strp, cons Line 3325  int alsprintf(unsigned char **strp, cons
 int interruption_violation_access(void *adresse_fautive, int gravite);  int interruption_violation_access(void *adresse_fautive, int gravite);
 #ifndef RPLARGS  #ifndef RPLARGS
 int liste_variables(struct_processus *s_etat_processus,  int liste_variables(struct_processus *s_etat_processus,
         struct_tableau_variables *tableau, int position,          struct_tableau_variables *tableau);
         struct_arbre_variables *l_element_courant);  int nombre_variables(struct_processus *s_etat_processus);
 int nombre_variables(struct_processus *s_etat_processus,  
         struct_arbre_variables *l_element_courant);  
 int readline_analyse_syntaxique(int count, int key);  int readline_analyse_syntaxique(int count, int key);
 int readline_effacement(int count, int key);  int readline_effacement(int count, int key);
 #endif  #endif
Line 3280  unsigned char longueur_entiers_binaires( Line 3350  unsigned char longueur_entiers_binaires(
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Fonctions retournant un INTEGER*8 (valeur binaire non signée)    Fonctions retournant un INTEGER*8 (valeur binaire non signée)
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 3304  integer8 position_caractere_de_chaine(st Line 3374  integer8 position_caractere_de_chaine(st
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Fonctions renvoyant une liste chaînée (pointeur sur *struct_liste_chainee)    Fonctions renvoyant une liste chaînée (pointeur sur *struct_liste_chainee)
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 3353  struct_objet *parametres_sql(struct_proc Line 3423  struct_objet *parametres_sql(struct_proc
         struct_objet *s_parametres);          struct_objet *s_parametres);
 struct_objet *simplification(struct_processus *s_etat_processus,  struct_objet *simplification(struct_processus *s_etat_processus,
         struct_objet *s_objet);          struct_objet *s_objet);
   
   struct_arbre_variables *allocation_noeud(struct_processus *s_etat_processus);
   struct_arbre_variables **allocation_tableau_noeuds(
           struct_processus *s_etat_processus);
   
   /*
   --------------------------------------------------------------------------------
     Fonctions renvoyant un pointeur sur une *struct_liste_variables_statiques
     ou *struct_liste_variables_partagees
   --------------------------------------------------------------------------------
   */
   
   struct_liste_variables_statiques *recherche_variable_statique(struct_processus
           *s_etat_processus, unsigned char *nom_variable,
           union_position_variable position, unsigned char origine);
   struct_liste_variables_partagees *recherche_variable_partagee(struct_processus
           *s_etat_processus, unsigned char *nom_variable,
           union_position_variable position, unsigned char origine);
 #endif  #endif
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Fonctions gérant les arbres de simplification    Fonctions gérant les arbres de simplification
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 3374  void simplification_arbre(struct_process Line 3462  void simplification_arbre(struct_process
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Fonctions gérant la complétion automatique    Fonctions gérant la complétion automatique
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 3386  char **completion_matches(); Line 3474  char **completion_matches();
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Arithmétique    Arithmétique
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 3407  void f77multiplicationci_(complex16 *ca, Line 3495  void f77multiplicationci_(complex16 *ca,
 void f77multiplicationcr_(complex16 *ca, real8 *rb, complex16 *resultat);  void f77multiplicationcr_(complex16 *ca, real8 *rb, complex16 *resultat);
   
 void f77puissancecc_(complex16 *ca, complex16 *cb, complex16 *resultat);  void f77puissancecc_(complex16 *ca, complex16 *cb, complex16 *resultat);
 void f77puissanceci_(complex16 *ca, integer8 *ib, complex16 *resultat,  void f77puissanceci_(complex16 *ca, integer8 *ib, complex16 *resultat);
         integer4 *troncature);  
 void f77puissancecr_(complex16 *ca, real8 *rb, complex16 *resultat);  void f77puissancecr_(complex16 *ca, real8 *rb, complex16 *resultat);
 void f77puissanceic_(integer8 *ia, complex16 *cb, complex16 *resultat);  void f77puissanceic_(integer8 *ia, complex16 *cb, complex16 *resultat);
 void f77puissanceii_(integer8 *ia, integer8 *ib, integer8 *resultat);  void f77puissanceii_(integer8 *ia, integer8 *ib, integer8 *resultat);
 void f77puissanceir_(integer8 *ia, real8 *rb, real8 *resultat);  void f77puissanceir_(integer8 *ia, real8 *rb, real8 *resultat);
 void f77puissancerc_(real8 *ra, complex16 *cb, complex16 *resultat);  void f77puissancerc_(real8 *ra, complex16 *cb, complex16 *resultat);
 void f77puissanceri_(real8 *ra, integer8 *ib, real8 *resultat,  void f77puissanceri_(real8 *ra, integer8 *ib, real8 *resultat);
         integer4 *troncature);  
 void f77puissancerr_(real8 *ra, real8 *rb, real8 *resultat);  void f77puissancerr_(real8 *ra, real8 *rb, real8 *resultat);
   
 void f77racinecarreec_(complex16 *ca, complex16 *resultat);  void f77racinecarreec_(complex16 *ca, complex16 *resultat);
Line 3432  void f77soustractionrc_(real8 *ra, compl Line 3518  void f77soustractionrc_(real8 *ra, compl
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Trigonométrie complexe    Trigonométrie complexe
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 3529  void zgeev_(unsigned char *calcul_vp_gau Line 3615  void zgeev_(unsigned char *calcul_vp_gau
         integer4 *erreur, integer4 longueur_1, integer4 longueur_2);          integer4 *erreur, integer4 longueur_1, integer4 longueur_2);
   
     /*      /*
      * Valeurs propres généralisées       * Valeurs propres généralisées
      */       */
   
 void zggev_(unsigned char *calcul_vp_gauches, unsigned char *calcul_vp_droits,  void zggev_(unsigned char *calcul_vp_gauches, unsigned char *calcul_vp_droits,
Line 3542  void zggev_(unsigned char *calcul_vp_gau Line 3628  void zggev_(unsigned char *calcul_vp_gau
         integer4 *erreur, integer4 longueur_1, integer4 longueur_2);          integer4 *erreur, integer4 longueur_1, integer4 longueur_2);
   
     /*      /*
      * Moindres carrés       * Moindres carrés
      */       */
   
 void dgelsd_(integer4 *nombre_lignes_a, integer4 *nombre_colonnes_a,  void dgelsd_(integer4 *nombre_lignes_a, integer4 *nombre_colonnes_a,
Line 3557  void zgelsd_(integer4 *nombre_lignes_a, Line 3643  void zgelsd_(integer4 *nombre_lignes_a,
         real8 *rwork, integer4 *iwork, integer4 *info);          real8 *rwork, integer4 *iwork, integer4 *info);
   
     /*      /*
      * Moindres carrés généralisé       * Moindres carrés généralisé
      */       */
   
     /*      /*
      * Décomposition en valeurs singulières       * Décomposition en valeurs singulières
      */       */
   
 void dgesvd_(unsigned char *jobu, unsigned char *jobvh,  void dgesvd_(unsigned char *jobu, unsigned char *jobvh,
Line 3618  void zgees_(unsigned char *calcul_vecteu Line 3704  void zgees_(unsigned char *calcul_vecteu
         real8 *rwork, logical4 *bwork, integer4 *info,          real8 *rwork, logical4 *bwork, integer4 *info,
         integer4 l1, integer4 l2);          integer4 l1, integer4 l2);
   
         /* Déterminant et rang */          /* Déterminant et rang */
 void dgecon_(unsigned char *norm, integer4 *n, real8 *a, integer4 *lda,  void dgecon_(unsigned char *norm, integer4 *n, real8 *a, integer4 *lda,
         real8 *anorm, real8 *rcond, real8 *work, integer4 *iwork,          real8 *anorm, real8 *rcond, real8 *work, integer4 *iwork,
         integer4 *info, integer4 l1);          integer4 *info, integer4 l1);
Line 3639  void zgelsy_(integer4 *m, integer4 *n, i Line 3725  void zgelsy_(integer4 *m, integer4 *n, i
 #endif  #endif
   
 /*  /*
  * Fonction testant la requête d'arrêt (nécessaire pour tester le   * Fonction testant la requête d'arrêt (nécessaire pour tester le
  * drapeau depuis une bibliothèque).   * drapeau depuis une bibliothèque).
  */   */
   
 int test_arret(struct_processus *s_etat_processus);  int test_arret(struct_processus *s_etat_processus);
Removed from v.1.176  
changed lines
  Added in v.1.191

CVSweb interface <joel.bertrand@systella.fr>